shenkun
/
web
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
42 Commits
2 Branches
580MB
Tree: 0a31dce3d8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0a31dce3d8'
${ noResults }
web/test/oaassist/server/wwwroot/resource/js/wpsjsrpcsdk.js

1355 lines
49KB
Raw Blame History 

  1. (function (global, factory) {

  2. 

  3.     "use strict";

  4. 

  5.     if (typeof module === "object" && typeof module.exports === "object") {

  6.         module.exports = factory(global, true);

  7.     } else {

  8.         factory(global);

  9.     }

  10. 

  11. })(typeof window !== "undefined" ? window : this, function (window, noGlobal) {

  12. 

  13.     "use strict";

  14. 

  15.     var bFinished = true;

  16. 

  17.     /**

  18.      * 兼容IE低版本的创建httpobj对象的方法

  19.      * @returns httpobj，可用于进行数据传输的http的对象

  20.      */

  21.     function getHttpObj() {

  22.         var httpobj = null;

  23.         if (IEVersion() < 10) {

  24.             try {

  25.                 httpobj = new XDomainRequest();

  26.             } catch (e1) {

  27.                 httpobj = new createXHR();

  28.             }

  29.         } else {

  30.             httpobj = new createXHR();

  31.         }

  32.         return httpobj;

  33.     }

  34.     //兼容IE低版本的创建xmlhttprequest对象的方法

  35.     /**

  36.      * 兼容IE低版本的创建xmlhttprequest对象的方法

  37.      * @returns xmlhttprequest对象，兼容低版本IE

  38.      */

  39.     function createXHR() {

  40.         if (typeof XMLHttpRequest != 'undefined') { //兼容高版本浏览器

  41.             return new XMLHttpRequest();

  42.         } else if (typeof ActiveXObject != 'undefined') { //IE6 采用 ActiveXObject， 兼容IE6

  43.             var versions = [ //由于MSXML库有3个版本，因此都要考虑

  44.                 'MSXML2.XMLHttp.6.0',

  45.                 'MSXML2.XMLHttp.3.0',

  46.                 'MSXML2.XMLHttp'

  47.             ];

  48. 

  49.             for (var i = 0; i < versions.length; i++) {

  50.                 try {

  51.                     return new ActiveXObject(versions[i]);

  52.                 } catch (e) {

  53.                     //跳过

  54.                 }

  55.             }

  56.         } else {

  57.             throw new Error('您的浏览器不支持XHR对象');

  58.         }

  59.     }

  60. 

  61.     /**

  62.      * 通过该接口给服务器发请求

  63.      * @param {*} options       参数对象，具体包含的参数如下：

  64.      * @param {*} url           网页路径，传输地址

  65.      * @param {*} type          传输类型，POST / GET / PUT

  66.      * @param {*} sendData      传输的数据

  67.      * @param {*} callback      回调函数

  68.      * @param {*} tryCount      请求失败后的尝试次数

  69.      * @param {*} bPop          是否弹出浏览器提示对话框

  70.      * @param {*} timeout       请求等待响应的时间，超过时间请求实效

  71.      * @param {*} concurrent    请求是否同步发送

  72.      * @param {*} client        wpsclient对象

  73.      * @returns NULL

  74.      */

  75.     function startWps(options) {

  76.         if (!bFinished && !options.concurrent) {

  77.             if (options.callback)

  78.                 options.callback({

  79.                     status: 1,

  80.                     message: "上一次请求没有完成"

  81.                 });

  82.             return;

  83.         }

  84.         bFinished = false;

  85. 

  86.         function startWpsInnder(tryCount) {

  87.             if (tryCount <= 0) {

  88.                 if (bFinished)

  89.                     return;

  90.                 bFinished = true;

  91.                 if (options.callback)

  92.                     options.callback({

  93.                         status: 2,

  94.                         message: "请允许浏览器打开WPS Office"

  95.                     });

  96.                 return;

  97.             }

  98.             var xmlReq = getHttpObj();

  99.             //WPS客户端提供的接收参数的本地服务，HTTP服务端口为58890，HTTPS服务端口为58891

  100.             //这俩配置，取一即可，不可同时启用

  101.             xmlReq.open('POST', options.url);

  102.             xmlReq.onload = function (res) {

  103.                 bFinished = true;

  104.                 if (initCloudsvr == true) {

  105.                     initCloudsvr = false;

  106.                 }

  107.                 if (options.callback) {

  108.                     if(res.target.response == "{\"data\": \"Failed to send message to WPS.\"}"){

  109.                         options.callback({

  110.                             status: 1,

  111.                             message: IEVersion() < 10 ? xmlReq.responseText : res.target.response

  112.                         });

  113.                     }

  114.                     else {

  115.                         options.callback({

  116.                             status: 0,

  117.                             response: IEVersion() < 10 ? xmlReq.responseText : res.target.response

  118.                         });

  119.                     }

  120.                 }

  121.             }

  122.             xmlReq.ontimeout = xmlReq.onerror = function (res) {

  123.                 xmlReq.bTimeout = true;

  124.                 if (tryCount == options.tryCount && options.bPop && initCloudsvr == false) { //打开wps并传参

  125.                     InitWpsCloudSvr();

  126.                 }

  127.                 setTimeout(function () {

  128.                     startWpsInnder(tryCount - 1)

  129.                 }, 1000);

  130.             }

  131.             if (IEVersion() < 10) {

  132.                 xmlReq.onreadystatechange = function () {

  133.                     if (xmlReq.readyState != 4)

  134.                         return;

  135.                     if (xmlReq.bTimeout) {

  136.                         return;

  137.                     }

  138.                     if (xmlReq.status === 200)

  139.                         xmlReq.onload();

  140.                     else

  141.                         xmlReq.onerror();

  142.                 }

  143.             }

  144.             xmlReq.timeout = options.timeout;

  145.             xmlReq.send(options.sendData)

  146.         }

  147.         startWpsInnder(options.tryCount);

  148.         return;

  149.     }

  150. 

  151.     var fromCharCode = String.fromCharCode;

  152.     // encoder stuff

  153.     var cb_utob = function (c) {

  154.         if (c.length < 2) {

  155.             var cc = c.charCodeAt(0);

  156.             return cc < 0x80 ? c :

  157.                 cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> 6)) +

  158.                     fromCharCode(0x80 | (cc & 0x3f))) :

  159.                     (fromCharCode(0xe0 | ((cc >>> 12) & 0x0f)) +

  160.                         fromCharCode(0x80 | ((cc >>> 6) & 0x3f)) +

  161.                         fromCharCode(0x80 | (cc & 0x3f)));

  162.         } else {

  163.             var cc = 0x10000 +

  164.                 (c.charCodeAt(0) - 0xD800) * 0x400 +

  165.                 (c.charCodeAt(1) - 0xDC00);

  166.             return (fromCharCode(0xf0 | ((cc >>> 18) & 0x07)) +

  167.                 fromCharCode(0x80 | ((cc >>> 12) & 0x3f)) +

  168.                 fromCharCode(0x80 | ((cc >>> 6) & 0x3f)) +

  169.                 fromCharCode(0x80 | (cc & 0x3f)));

  170.         }

  171.     };

  172.     var re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;

  173.     var utob = function (u) {

  174.         return u.replace(re_utob, cb_utob);

  175.     };

  176.     var _encode = function (u) {

  177.         var isUint8Array = Object.prototype.toString.call(u) === '[object Uint8Array]';

  178.         if (isUint8Array)

  179.             return u.toString('base64')

  180.         else

  181.             return btoa(utob(String(u)));

  182.     }

  183. 

  184.     if (typeof window.btoa !== 'function') window.btoa = func_btoa;

  185. 

  186.     function func_btoa(input) {

  187.         var str = String(input);

  188.         var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';

  189.         for (

  190.             // initialize result and counter

  191.             var block, charCode, idx = 0, map = chars, output = '';

  192.             // if the next str index does not exist:

  193.             //   change the mapping table to "="

  194.             //   check if d has no fractional digits

  195.             str.charAt(idx | 0) || (map = '=', idx % 1);

  196.             // "8 - idx % 1 * 8" generates the sequence 2, 4, 6, 8

  197.             output += map.charAt(63 & block >> 8 - idx % 1 * 8)

  198.         ) {

  199.             charCode = str.charCodeAt(idx += 3 / 4);

  200.             if (charCode > 0xFF) {

  201.                 throw new InvalidCharacterError("'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.");

  202.             }

  203.             block = block << 8 | charCode;

  204.         }

  205.         return output;

  206.     }

  207. 

  208.     /**

  209.      * 将字符串进行Base64编码

  210.      * @param {*} u         需要编码的数据

  211.      * @param {*} urisafe   返回值，编码后的数据

  212.      * @returns             urisafe

  213.      */

  214.     var encode = function (u, urisafe) {

  215.         return !urisafe ?

  216.             _encode(u) :

  217.             _encode(String(u)).replace(/[+\/]/g, function (m0) {

  218.                 return m0 == '+' ? '-' : '_';

  219.             }).replace(/=/g, '');

  220.     };

  221. 

  222.     /**

  223.      * 获取IE浏览器版本

  224.      * @returns     IE浏览器版本

  225.      */

  226.     function IEVersion() {

  227.         var userAgent = navigator.userAgent; //取得浏览器的userAgent字符串  

  228.         var isIE = userAgent.indexOf("compatible") > -1 && userAgent.indexOf("MSIE") > -1; //判断是否IE<11浏览器  

  229.         var isEdge = userAgent.indexOf("Edge") > -1 && !isIE; //判断是否IE的Edge浏览器  

  230.         var isIE11 = userAgent.indexOf('Trident') > -1 && userAgent.indexOf("rv:11.0") > -1;

  231.         if (isIE) {

  232.             var reIE = new RegExp("MSIE (\\d+\\.\\d+);");

  233.             reIE.test(userAgent);

  234.             var fIEVersion = parseFloat(RegExp["$1"]);

  235.             if (fIEVersion == 7) {

  236.                 return 7;

  237.             } else if (fIEVersion == 8) {

  238.                 return 8;

  239.             } else if (fIEVersion == 9) {

  240.                 return 9;

  241.             } else if (fIEVersion == 10) {

  242.                 return 10;

  243.             } else {

  244.                 return 6; //IE版本<=7

  245.             }

  246.         } else if (isEdge) {

  247.             return 20; //edge

  248.         } else if (isIE11) {

  249.             return 11; //IE11  

  250.         } else {

  251.             return 30; //不是ie浏览器

  252.         }

  253.     }

  254. 

  255.     /**

  256.      * 启动wps客户端，加载项执行操作，无返回值

  257.      * @param {*} options       参数对象，详情见下：

  258.      * @param {*} clientType    加载项类型， wps / wpp / et

  259.      * @param {*} name          加载项名称

  260.      * @param {*} func          客户端加载项要执行的方法

  261.      * @param {*} param         客户端家乡执行方法的参数

  262.      * @param {*} urlBase       网页路径前缀

  263.      * @param {*} callback      回调函数

  264.      * @param {*} tryCount      请求失败后的尝试次数

  265.      * @param {*} bPop          是否弹出浏览器提示对话框

  266.      * @param {*} wpsclient     wpsclient对象

  267.      */

  268.     function WpsStart(options) {

  269.         var startInfo = {

  270.             "name": options.name,

  271.             "function": options.func,

  272.             "info": options.param.param,

  273.             "jsPluginsXml": options.param.jsPluginsXml

  274.         };

  275.         var strData = JSON.stringify(startInfo);

  276.         if (IEVersion() < 10) {

  277.             try {

  278.                 eval("strData = '" + JSON.stringify(startInfo) + "';");

  279.             } catch (err) {

  280. 

  281.             }

  282.         }

  283. 

  284.         var baseData = encode(strData);

  285.         var url = options.urlBase + "/" + options.clientType + "/runParams";

  286.         var data = "ksowebstartup" + options.clientType + "://" + baseData;

  287.         startWps({

  288.             url: url,

  289.             sendData: data,

  290.             callback: options.callback,

  291.             tryCount: options.tryCount,

  292.             bPop: options.bPop,

  293.             timeout: 5000,

  294.             concurrent: false,

  295.             client: options.wpsclient

  296.         });

  297.     }

  298. 

  299.     /**

  300.      * 服务端版本为空时，通过该接口启动wps

  301.      * @param {*} options       参数对象，详情见下：

  302.      * @param {*} clientType    加载项类型， wps / wpp / et

  303.      * @param {*} name          加载项名称

  304.      * @param {*} func          客户端加载项要执行的方法

  305.      * @param {*} param         客户端家乡执行方法的参数

  306.      * @param {*} urlBase       网页路径前缀

  307.      * @param {*} callback      回调函数

  308.      * @param {*} wpsclient     wpsclient对象

  309.      * @param {*} concurrent    请求是否同步发送

  310.      */

  311.     function WpsStartWrap(options) {

  312.         WpsStart({

  313.             clientType: options.clientType,

  314.             name: options.name,

  315.             func: options.func,

  316.             param: options.param,

  317.             urlBase: options.urlBase,

  318.             callback: options.callback,

  319.             tryCount: 4,

  320.             bPop: true,

  321.             wpsclient: options.wpsclient,

  322.         })

  323.     }

  324. 

  325.     /**

  326.      * 支持浏览器触发，WPS有返回值的启动

  327.      *

  328.      * @param {*} clientType	组件类型

  329.      * @param {*} name			WPS加载项名称

  330.      * @param {*} func			WPS加载项入口方法

  331.      * @param {*} param			参数：包括WPS加载项内部定义的方法，参数等

  332.      * @param {*} callback		回调函数

  333.      * @param {*} tryCount		重试次数

  334.      * @param {*} bPop			是否弹出浏览器提示对话框

  335.      */

  336.     var exId = 0;

  337.     function WpsStartWrapExInner(options) {

  338.         var infocontent = options.param.param;

  339.         if (!options.wpsclient || options.wpsclient.single) {

  340.             infocontent = JSON.stringify(options.param.param);

  341.             var rspUrl = options.urlBase + "/transferEcho/runParams";

  342.             var time = new Date();

  343.             var cmdId = "js" + time.getTime() + "_" + exId;

  344.             var funcEx = "var res = " + options.func;

  345.             var cbCode = "var xhr = new XMLHttpRequest();xhr.open('POST', '" + rspUrl + "');xhr.send(JSON.stringify({id: '" + cmdId + "', response: res}));" //res 为func执行返回值

  346.             var infoEx = infocontent + ");" + cbCode + "void(0";

  347.             options.func = funcEx;

  348.             infocontent = infoEx;

  349.         }

  350.         var startInfo = {

  351.             "name": options.name,

  352.             "function": options.func,

  353.             "info": infocontent,

  354.             "showToFront": options.param.showToFront,

  355.             "jsPluginsXml": options.param.jsPluginsXml,

  356.         };

  357. 

  358.         var strData = JSON.stringify(startInfo);

  359.         if (IEVersion() < 10) {

  360.             try {

  361.                 eval("strData = '" + JSON.stringify(startInfo) + "';");

  362.             } catch (err) {

  363. 

  364.             }

  365.         }

  366. 

  367.         var baseData = encode(strData);

  368.         var wrapper;

  369. 

  370.         if (!options.wpsclient|| options.wpsclient.single) {

  371.             var url = options.urlBase + "/transfer/runParams";

  372.             var data = "ksowebstartup" + options.clientType + "://" + baseData;

  373.             wrapper = {

  374.                 id: cmdId,

  375.                 app: options.clientType,

  376.                 data: data,

  377.                 serverId: serverId,

  378.                 mode: options.silentMode ? "true" : "false",

  379.             };

  380.         }

  381.         else {

  382.             var url = options.urlBase + "/transferEx/runParams";

  383.             wrapper = {

  384.                 id: options.wpsclient.clientId,

  385.                 app: options.clientType,

  386.                 data: baseData,

  387.                 mode: options.wpsclient.silentMode ? "true" : "false",

  388.                 serverId: serverId

  389.             };

  390.         }

  391.         wrapper = JSON.stringify(wrapper);

  392.         startWps({

  393.             url: url,

  394.             sendData: wrapper,

  395.             callback: options.callback,

  396.             tryCount: options.tryCount,

  397.             bPop: options.bPop,

  398.             timeout: 0,

  399.             concurrent: options.concurrent,

  400.             client: options.wpsclient

  401.         });

  402.     }

  403. 

  404.     var serverVersion = "wait"

  405.     var cloudSvrStart = true;

  406.     var initCloudsvr = false;

  407.     /**

  408.      * 获取服务端版本号的接口

  409.      * @param {*} options       参数对象，详情见下：

  410.      * @param {*} clientType    加载项类型， wps / wpp / et

  411.      * @param {*} name          加载项名称

  412.      * @param {*} func          客户端加载项要执行的方法

  413.      * @param {*} param         客户端家乡执行方法的参数

  414.      * @param {*} urlBase       网页路径前缀

  415.      * @param {*} callback      回调函数

  416.      * @param {*} wpsclient     wpsclient对象

  417.      * @param {*} concurrent    请求是否同步发送   

  418.      */

  419.     function WpsStartWrapVersionInner(options) {

  420.         if (serverVersion == "wait") {

  421.             if (cloudSvrStart == false) {

  422.                 InitWpsCloudSvr();

  423.                 initCloudsvr = true;

  424.             }

  425.             startWps({

  426.                 url: options.urlBase + '/version',

  427.                 sendData: JSON.stringify({ serverId: serverId }),

  428.                 callback: function (res) {

  429.                     if (res.status !== 0) {

  430.                         options.callback(res)

  431.                         return;

  432.                     }

  433.                     serverVersion = res.response;

  434.                     cloudSvrStart = true;

  435.                     options.tryCount = 1

  436.                     options.bPop = false

  437.                     if (serverVersion === "") {

  438.                         WpsStart(options)

  439.                     } else if (serverVersion < "1.0.1" && options.wpsclient) {

  440.                         options.wpsclient.single = true;

  441.                         WpsStartWrapExInner(options);

  442.                     } else {

  443.                         WpsStartWrapExInner(options);

  444.                     }

  445.                 },

  446.                 tryCount: 4,

  447.                 bPop: true,

  448.                 timeout: 5000,

  449.                 concurrent: options.concurrent

  450.             });

  451.         } else {

  452.             options.tryCount = 4

  453.             options.bPop = true

  454.             if (serverVersion === "") {

  455.                 WpsStartWrap(options)

  456.             } else if (serverVersion < "1.0.1" && options.wpsclient) {

  457.                 options.wpsclient.single = true;

  458.                 WpsStartWrapExInner(options);

  459.             } else {

  460.                 WpsStartWrapExInner(options);

  461.             }

  462.         }

  463.     }

  464. 

  465.     var HeartBeatCode =

  466.         "function getHttpObj() {\n"

  467.         + "            var httpobj = null;\n"

  468.         + "            if (IEVersion() < 10) {\n"

  469.         + "                try {\n"

  470.         + "                    httpobj = new XDomainRequest();\n"

  471.         + "                } catch (e1) {\n"

  472.         + "                    httpobj = new createXHR();\n"

  473.         + "                }\n"

  474.         + "            } else {\n"

  475.         + "                httpobj = new createXHR();\n"

  476.         + "            }\n"

  477.         + "            return httpobj;\n"

  478.         + "        }\n"

  479.         + "        \n"

  480.         + "        function createXHR() {\n"

  481.         + "            if (typeof XMLHttpRequest != 'undefined') {\n"

  482.         + "                return new XMLHttpRequest();\n"

  483.         + "            } else if (typeof ActiveXObject != 'undefined') {\n"

  484.         + "                var versions = [\n"

  485.         + "                    'MSXML2.XMLHttp.6.0',\n"

  486.         + "                    'MSXML2.XMLHttp.3.0',\n"

  487.         + "                    'MSXML2.XMLHttp'\n"

  488.         + "                ];\n"

  489.         + "        \n"

  490.         + "                for (var i = 0; i < versions.length; i++) {\n"

  491.         + "                    try {\n"

  492.         + "                        return new ActiveXObject(versions[i]);\n"

  493.         + "                    } catch (e) {\n"

  494.         + "                        \n"

  495.         + "                    }\n"

  496.         + "                }\n"

  497.         + "            } else {\n"

  498.         + "                throw new Error('您的浏览器不支持XHR对象');\n"

  499.         + "            }\n"

  500.         + "        }\n"

  501.         + "        \n"

  502.         + "        function IEVersion() {\n"

  503.         + "            var userAgent = navigator.userAgent; \n"

  504.         + "            var isIE = userAgent.indexOf('compatible') > -1 && userAgent.indexOf('MSIE') > -1;\n"

  505.         + "            var isEdge = userAgent.indexOf('Edge') > -1 && !isIE; \n"

  506.         + "            var isIE11 = userAgent.indexOf('Trident') > -1 && userAgent.indexOf('rv:11.0') > -1;\n"

  507.         + "            if (isIE) {\n"

  508.         + "                var reIE = new RegExp('MSIE (\\d+\\.\\d+);');\n"

  509.         + "                reIE.test(userAgent);\n"

  510.         + "                var fIEVersion = parseFloat(RegExp['$1']);\n"

  511.         + "                if (fIEVersion == 7) {\n"

  512.         + "                    return 7;\n"

  513.         + "                } else if (fIEVersion == 8) {\n"

  514.         + "                    return 8;\n"

  515.         + "                } else if (fIEVersion == 9) {\n"

  516.         + "                    return 9;\n"

  517.         + "                } else if (fIEVersion == 10) {\n"

  518.         + "                    return 10;\n"

  519.         + "                } else {\n"

  520.         + "                    return 6; \n"

  521.         + "                }\n"

  522.         + "            } else if (isEdge) {\n"

  523.         + "                return 20; \n"

  524.         + "            } else if (isIE11) {\n"

  525.         + "                return 11; \n"

  526.         + "            } else {\n"

  527.         + "                return 30; \n"

  528.         + "            }\n"

  529.         + "        }\n"

  530.         + "        var heartBeatStart = false;\n"

  531.         + "        function checkLastRegTime() {\n"

  532.         + "            var now = new Date().valueOf();\n"

  533.         + "            var TimeGap = now - LastRegTime;\n"

  534.         + "            if (TimeGap > 5000 && !heartBeatStart) {\n"

  535.         + "                HeartBeat();\n"

  536.         + "                heartBeatStart = true;\n"

  537.         + "            }\n"

  538.         + "        }\n"

  539.         + "        \n"

  540.         + "        function HeartBeat() {\n"

  541.         + "            var heartBeatItem = function () {\n"

  542.         + "                var xhr = getHttpObj();\n"

  543.         + "                xhr.onload = function (e) {\n"

  544.         + "                    self.setTimeout(heartBeatItem, 5000);\n"

  545.         + "                }\n"

  546.         + "                xhr.onerror = function (e) {\n"

  547.         + "                    self.setTimeout(heartBeatItem, 5000);\n"

  548.         + "                }\n"

  549.         + "                xhr.ontimeout = function (e) {\n"

  550.         + "                    self.setTimeout(heartBeatItem, 5000);\n"

  551.         + "                }\n"

  552.         + "                xhr.open('POST', 'http://127.0.0.1:58890/askwebnotify', true);\n"

  553.         + "                xhr.timeout = 2000;\n"

  554.         + "                xhr.send(JSON.stringify(paramStr));\n"

  555.         + "            }\n"

  556.         + "            heartBeatItem();\n"

  557.         + "        }\n"

  558.         + "        \n"

  559.         + "        var paramStr;\n"

  560.         + "        var startCheck = false;\n"

  561.         + "        self.addEventListener('message', function (event) {\n"

  562.         + "            var data = event.data;\n"

  563.         + "                paramStr = data.param\n"

  564.         + "                paramStr.heartBeat = true\n"

  565.         + "                LastRegTime = data.LastRegTime;\n"

  566.         + "                if (!startCheck) {\n"

  567.         + "                    startCheck = true;\n"

  568.         + "                    self.setInterval(checkLastRegTime, 5000)\n"

  569.         + "                }\n"

  570.         + "        }, false);\n"

  571.     /**

  572.      * 生成guid的接口

  573.      * @returns guid

  574.      */

  575.     function guid() {

  576.         return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {

  577.             var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);

  578.             return v.toString(16);

  579.         });

  580.     }

  581. 

  582.     /**

  583.      * 开启多用户的接口

  584.      */

  585.     var serverId = undefined

  586.     function EnableMultiUser() {

  587.         serverId = getServerId();

  588.     }

  589. 

  590.     /**

  591.      * 自定义协议启动服务端

  592.      * 默认不带参数serverId，linux未升级之前不要使用多用户

  593.      */

  594.     function InitWpsCloudSvr () {

  595.         if(serverId == undefined)

  596.             window.location.href = "ksoWPSCloudSvr://start=RelayHttpServer"//是否启动wps弹框

  597.         else

  598.             window.location.href = "ksoWPSCloudSvr://start=RelayHttpServer" + "&serverId=" + serverId //是否启动wps弹框

  599.     }

  600.     

  601.     /**

  602.      * 获取serverId的接口

  603.      * @returns serverId

  604.      */

  605.     function getServerId() {

  606.         if (window.localStorage) {

  607.             if (localStorage.getItem("serverId")) {

  608.                 //

  609.             }

  610.             else {

  611.                 localStorage.setItem("serverId", guid());

  612.             }

  613.             return localStorage.getItem("serverId");

  614.         }

  615.         else {

  616.             return guid();

  617.         }

  618.     }

  619. 

  620.     /**

  621.      * 将字符串转成二进制，这里用来将字符串化后的js代码转成二进制文件

  622.      * @param {*} code 

  623.      * @returns js文件对象的url

  624.      */

  625.     function codeToBlob(code) {

  626.         var blob = new Blob([code], { type: 'text/javascript' }); // 生成js文件对象

  627.         var objectURL = window.URL.createObjectURL(blob); // 生成js文件的url

  628.         return objectURL;

  629.     }

  630. 

  631.     var RegWebNotifyMap = { wps: {}, wpp: {}, et: {} }

  632.     var bWebNotifyUseTimeout = true

  633.     function WebNotifyUseTimeout(value) {

  634.         bWebNotifyUseTimeout = value ? true : false

  635.     }

  636.     var g_businessId = Number(Math.random().toString().substr(3, 5) + Date.parse(new Date())).toString(36);

  637.     var HeartBeatWorker

  638.     if (window.Worker) {

  639.         try {

  640.             HeartBeatWorker = new Worker(codeToBlob(HeartBeatCode));

  641.         } catch (error) {

  642.             //

  643.         }

  644.     }

  645.     var g_LastRegTime;

  646.     /**

  647.      * 注册一个前端页面接收WPS传来消息的方法

  648.      * @param {*} clientType wps | et | wpp

  649.      * @param {*} name WPS加载项的名称

  650.      * @param {*} callback 回调函数

  651.      * @param {*} wpsclient wpsclient对象

  652.      */

  653.     function RegWebNotify(clientType, name, callback, wpsclient) {

  654.         if (clientType != "wps" && clientType != "wpp" && clientType != "et")

  655.             return;

  656.         var paramStr = {}

  657.         if (wpsclient) {

  658.             if (wpsclient.notifyRegsitered == true) {

  659.                 return

  660.             }

  661.             wpsclient.notifyRegsitered = true;

  662.             paramStr = {

  663.                 clientId: wpsclient.clientId,

  664.                 name: name,

  665.                 type: clientType,

  666.                 serverId: serverId

  667.             }

  668.             if (HeartBeatWorker)

  669.                 paramStr.businessId = g_businessId

  670.         }

  671.         else {

  672.             if (typeof callback != 'function')

  673.                 return

  674.             if (RegWebNotifyMap[clientType][name]) {

  675.                 RegWebNotifyMap[clientType][name] = callback;

  676.                 return

  677.             }

  678.             var RegWebNotifyID = new Date().valueOf() + ''

  679.             paramStr = {

  680.                 id: RegWebNotifyID,

  681.                 name: name,

  682.                 type: clientType,

  683.                 serverId: serverId

  684.             }

  685.             if (HeartBeatWorker)

  686.                 paramStr.businessId = g_businessId

  687.             RegWebNotifyMap[clientType][name] = callback

  688.         }

  689. 

  690.         var askItem = function () {

  691.             var xhr = getHttpObj()

  692.             xhr.onload = function (e) {

  693.                 if (xhr.responseText == "WPSInnerMessage_quit") {

  694.                     return;

  695.                 }

  696.                 try {

  697.                     var resText = JSON.parse(xhr.responseText);

  698.                     if (typeof resText == 'object') {

  699.                         paramStr.messageId = resText.msgId;

  700.                     }

  701.                     if (wpsclient) {

  702.                         if (typeof resText.data == 'object')  // 如果发的数据是字符串化后的json对象，这里的resText.data就是一个json对象，可以输出自己想要的json数据

  703.                             wpsclient.OnRegWebNotify(resText.data.data)

  704.                         else

  705.                             wpsclient.OnRegWebNotify(resText.data)

  706.                     } else {

  707.                         var func = RegWebNotifyMap[clientType][name]

  708.                         if (typeof resText.data == 'object')  // 如果发的数据是字符串化后的json对象，这里的resText.data就是一个json对象，可以输出自己想要的json数据

  709.                             func(resText.data.data)

  710.                         else

  711.                             func(resText.data)

  712.                     }

  713.                 }

  714.                 catch (e) {

  715.                     // 这里做一个容错，即使json解析失败，也要把msgId提取出来，发回给服务端，避免消息清不掉一直重复发送

  716.                     // 同时把data也取出来，但是格式无法保证

  717.                     var str = xhr.responseText

  718.                     var idx1 = str.indexOf(":")

  719.                     var idx2 = str.indexOf(",")

  720.                     paramStr.messageId = parseInt(str.substring(idx1 + 1, idx2))

  721.                     var idx3 = str.indexOf("\"data\"")

  722.                     var idx4 = str.indexOf("}")

  723.                     var data = str.substring(idx3, idx4)

  724.                     if (wpsclient) {

  725.                         if (data)

  726.                             wpsclient.OnRegWebNotify(data)

  727.                         else

  728.                             wpsclient.OnRegWebNotify(xhr.responseText)

  729.                     } else {

  730.                         var func = RegWebNotifyMap[clientType][name]

  731.                         if (data)

  732.                             func(data)

  733.                         else

  734.                             func(xhr.responseText)

  735.                     }

  736.                 }

  737.                 window.setTimeout(askItem, 300)

  738.             }

  739.             xhr.onerror = function (e) {

  740.                 if (bWebNotifyUseTimeout)

  741.                     window.setTimeout(askItem, 1000)

  742.                 else

  743.                     window.setTimeout(askItem, 10000)

  744.             }

  745.             xhr.ontimeout = function (e) {

  746.                 if (bWebNotifyUseTimeout)

  747.                     window.setTimeout(askItem, 300)

  748.                 else

  749.                     window.setTimeout(askItem, 10000)

  750.             }

  751.             if (IEVersion() < 10) {

  752.                 xhr.onreadystatechange = function () {

  753.                     if (xhr.readyState != 4)

  754.                         return;

  755.                     if (xhr.bTimeout) {

  756.                         return;

  757.                     }

  758.                     if (xhr.status === 200)

  759.                         xhr.onload();

  760.                     else

  761.                         xhr.onerror();

  762.                 }

  763.             }

  764.             xhr.open('POST', GetUrlBase() + '/askwebnotify', true)

  765.             if (bWebNotifyUseTimeout)

  766.                 xhr.timeout = 2000;

  767.             if (HeartBeatWorker) {

  768.                 g_LastRegTime = new Date().valueOf();

  769.                 var param = {

  770.                     param: {

  771.                         name: name,

  772.                         type: clientType,

  773.                         businessId: g_businessId,

  774.                         serverId: serverId

  775.                     },

  776.                     LastRegTime: g_LastRegTime

  777.                 }

  778.                 HeartBeatWorker.postMessage(param)

  779.             }

  780.             xhr.send(JSON.stringify(paramStr));

  781.         }

  782.         window.setTimeout(askItem, 2000)

  783.     }

  784. 

  785.     /**

  786.      * 获取网页路径前缀

  787.      * @returns url前缀

  788.      */

  789.     function GetUrlBase() {

  790.         if (location.protocol == "https:")

  791.             return "https://127.0.0.1:58891"

  792.         return "http://127.0.0.1:58890"

  793.     }

  794. 

  795.     /**

  796.      * 获取服务端版本号的接口，这里主要是初始化一些参数

  797.      * @param {*} clientType    加载项类型， wps / wpp / et

  798.      * @param {*} name          加载项名称

  799.      * @param {*} func          客户端加载项要执行的方法

  800.      * @param {*} param         客户端家乡执行方法的参数

  801.      * @param {*} callback      回调函数

  802.      * @param {*} showToFront   设置客户端是否显示到前面

  803.      * @param {*} jsPluginsXml  设置加载项路径

  804.      * @param {*} silentMode    静默启动WPS

  805.      */

  806.     function WpsStartWrapVersion(clientType, name, func, param, callback, showToFront, jsPluginsXml,silentMode) {

  807.         var paramEx = {

  808.             jsPluginsXml: jsPluginsXml ? jsPluginsXml : "",

  809.             showToFront: typeof (showToFront) == 'boolean' ? showToFront : true,

  810.             param: (typeof (param) == 'object' ? param : JSON.parse(param))

  811.         }

  812.         var options = {

  813.             clientType: clientType,

  814.             name: name,

  815.             func: func,

  816.             param: paramEx,

  817.             urlBase: GetUrlBase(),

  818.             callback: callback,

  819.             wpsclient: undefined,

  820.             concurrent: true,

  821.             silentMode:silentMode

  822.         }

  823.         WpsStartWrapVersionInner(options);

  824.     }

  825. 

  826.     //从外部浏览器远程调用 WPS 加载项中的方法

  827.     var WpsInvoke = {

  828.         InvokeAsHttp: WpsStartWrapVersion,

  829.         InvokeAsHttps: WpsStartWrapVersion,

  830.         RegWebNotify: RegWebNotify,

  831.         ClientType: {

  832.             wps: "wps",

  833.             et: "et",

  834.             wpp: "wpp"

  835.         },

  836.         CreateXHR: getHttpObj,

  837.         IsClientRunning: IsClientRunning

  838.     }

  839. 

  840.     window.wpsclients = [];

  841.     /**

  842.      * @constructor WpsClient           wps客户端

  843.      * @param {string} clientType       必传参数，加载项类型，有效值为"wps","wpp","et"；分别表示文字，演示，电子表格

  844.      */

  845.     function WpsClient(clientType) {

  846.         /**

  847.          * 设置RegWebNotify的回调函数，加载项给业务端发消息通过该函数

  848.          * @memberof WpsClient

  849.          * @member onMessage

  850.          */

  851.         this.onMessage;

  852. 

  853.         /**

  854.          * 设置加载项路径

  855.          * @memberof WpsClient

  856.          * @member jsPluginsXml

  857.          */

  858.         this.jsPluginsXml;

  859. 

  860.         /**

  861.          * 内部成员，外部无需调用

  862.          */

  863.         this.notifyRegsitered = false;

  864.         this.clientId = "";

  865.         this.concurrent = false;

  866.         this.clientType = clientType;

  867.         this.firstRequest = true;

  868. 

  869.         /**

  870.          * 内部函数，外部无需调用

  871.          * @param {*} options 

  872.          */

  873.         this.initWpsClient = function (options) {

  874.             options.clientType = this.clientType

  875.             options.wpsclient = this

  876.             options.concurrent = this.firstRequest ? true : this.concurrent

  877.             this.firstRequest = false;

  878.             WpsStartWrapVersionInner(options)

  879.         }

  880. 

  881.         /**

  882.          * 以http启动

  883.          * @param {string} name              加载项名称

  884.          * @param {string} func              要调用的加载项中的函数行

  885.          * @param {string} param             在加载项中执行函数func要传递的数据

  886.          * @param {function({int, string})} callback        回调函数，status = 0 表示成功，失败请查看message信息

  887.          * @param {bool} showToFront         设置wps是否显示到前面来

  888.          * @return {string}                  "Failed to send message to WPS." 发送消息失败，客户端已关闭；

  889.          *                                   "WPS Addon is not response." 加载项阻塞，函数执行失败

  890.          */

  891.         this.InvokeAsHttp = function (name, func, param, callback, showToFront) {

  892.             function clientCallback(res) {

  893.                 //this不是WpsClient

  894.                 if (res.status !== 0 || serverVersion < "1.0.1") {

  895.                     if (callback) 

  896.                         callback(res);

  897.                     RegWebNotify(clientType, name, this.client.onMessage)

  898.                     return;

  899.                 }

  900.                 var resObject = JSON.parse(res.response);

  901.                 if (this.client.clientId == "") {

  902.                     this.client.clientId = resObject.clientId;

  903.                 }

  904.                 this.client.concurrent = true;

  905.                 if (typeof resObject.data == "object")

  906.                     res.response = JSON.stringify(resObject.data);

  907.                 else

  908.                     res.response = resObject.data;

  909.                 if (IEVersion() < 10)

  910.                     eval(" res.response = '" + res.response + "';");

  911.                 if (callback)

  912.                     callback(res);

  913.                 this.client.RegWebNotify(name);

  914.             }

  915.             var paramEx = {

  916.                 jsPluginsXml: this.jsPluginsXml ? this.jsPluginsXml : "",

  917.                 showToFront: typeof (showToFront) == 'boolean' ? showToFront : true,

  918.                 param: (typeof (param) == 'object' ? param : JSON.parse(param))

  919.             }

  920.             this.initWpsClient({

  921.                 name: name,

  922.                 func: func,

  923.                 param: paramEx,

  924.                 urlBase: GetUrlBase(),

  925.                 callback: clientCallback

  926.             })

  927.         }

  928. 

  929.         /**

  930.          * 以https启动

  931.          * @param {string} name              加载项名称

  932.          * @param {string} func              要调用的加载项中的函数行

  933.          * @param {string} param             在加载项中执行函数func要传递的数据

  934.          * @param {function({int, string})} callback        回调函数，status = 0 表示成功，失败请查看message信息

  935.          * @param {bool} showToFront         设置wps是否显示到前面来

  936.          */

  937.         this.InvokeAsHttps = function (name, func, param, callback, showToFront) {

  938.             var paramEx = {

  939.                 jsPluginsXml: this.jsPluginsXml ? this.jsPluginsXml : "",

  940.                 showToFront: typeof (showToFront) == 'boolean' ? showToFront : true,

  941.                 param: (typeof (param) == 'object' ? param : JSON.parse(param))

  942.             }

  943.             this.initWpsClient({

  944.                 name: name,

  945.                 func: func,

  946.                 param: paramEx,

  947.                 urlBase: GetUrlBase(),

  948.                 callback: callback

  949.             })

  950.         }

  951. 

  952.         /**

  953.          * 内部函数，外部无需调用

  954.          * @param {*} name 

  955.          */

  956.         this.RegWebNotify = function (name) {

  957.             RegWebNotify(this.clientType, name, null, this);

  958.         }

  959. 

  960.         /**

  961.          * 消息注册函数的回调函数

  962.          * @param {*} message   客户端发来的消息

  963.          */

  964.         this.OnRegWebNotify = function (message) {

  965.             if (this.onMessage)

  966.                 this.onMessage(message)

  967.         }

  968. 

  969.         /**

  970.          * 以静默模式启动客户端

  971.          * @param {string} name                 必传参数，加载项名称

  972.          * @param {function({int, string})} [callback]         回调函数，status = 0 表示成功，失败请查看message信息

  973.          */

  974.         this.StartWpsInSilentMode = function (name, callback) {

  975.             function initCallback(res) {

  976.                 //this不是WpsClient

  977.                 if (res.status !== 0 || serverVersion < "1.0.1") {

  978.                     if (callback) 

  979.                         callback(res);

  980.                     RegWebNotify(clientType, name, this.client.onMessage)

  981.                     return;

  982.                 }

  983.                 if (this.client.clientId == "") {

  984.                     this.client.clientId = JSON.parse(res.response).clientId;

  985.                     window.wpsclients[window.wpsclients.length] = { name: name, client: this.client };

  986.                 }

  987.                 res.response = JSON.stringify(JSON.parse(res.response).data);

  988.                 this.client.concurrent = true;

  989.                 if (callback) {

  990.                     callback(res);

  991.                 }

  992.                 this.client.RegWebNotify(name);

  993.             }

  994.             var paramEx = {

  995.                 jsPluginsXml: this.jsPluginsXml,

  996.                 showToFront: false,

  997.                 param: { status: "InitInSilentMode" }

  998.             }

  999.             this.silentMode = true;

  1000.             this.initWpsClient({

  1001.                 name: name,

  1002.                 func: "",

  1003.                 param: paramEx,

  1004.                 urlBase: GetUrlBase(),

  1005.                 callback: initCallback

  1006.             })

  1007.         }

  1008. 

  1009.         /**

  1010.          * 显示客户端到最前面

  1011.          * @param {string} name             必传参数，加载项名称

  1012.          * @param {function({int, string})} [callback]     回调函数

  1013.          */

  1014.         this.ShowToFront = function (name, callback) {

  1015.             if (serverVersion < "1.0.1") {

  1016.                 if (callback) {

  1017.                     callback({

  1018.                         status: 4,

  1019.                         message: "当前客户端不支持，请升级客户端"

  1020.                     });

  1021.                     return;

  1022.                 }

  1023.                 return;

  1024.             }

  1025.             if (this.clientId == "") {

  1026.                 if (callback) callback({

  1027.                     status: 3,

  1028.                     message: "没有静默启动客户端"

  1029.                 });

  1030.                 return;

  1031.             }

  1032.             var paramEx = {

  1033.                 jsPluginsXml: "",

  1034.                 showToFront: true,

  1035.                 param: { status: "ShowToFront" }

  1036.             }

  1037.             this.initWpsClient({

  1038.                 name: name,

  1039.                 func: "",

  1040.                 param: paramEx,

  1041.                 urlBase: GetUrlBase(),

  1042.                 callback: callback

  1043.             })

  1044.         }

  1045. 

  1046.         /**

  1047.          * 关闭未显示出来的静默启动客户端

  1048.          * @param {string} name             必传参数，加载项名称

  1049.          * @param {function({int, string})} [callback]     回调函数

  1050.          */

  1051.         this.CloseSilentClient = function (name, callback) {

  1052.             if (serverVersion < "1.0.1") {

  1053.                 if (callback) {

  1054.                     callback({

  1055.                         status: 4,

  1056.                         message: "当前客户端不支持，请升级客户端"

  1057.                     });

  1058.                     return;

  1059.                 }

  1060.                 return;

  1061.             }

  1062.             if (this.clientId == "") {

  1063.                 if (callback) callback({

  1064.                     status: 3,

  1065.                     message: "没有静默启动客户端"

  1066.                 });

  1067.                 return;

  1068.             }

  1069.             var paramEx = {

  1070.                 jsPluginsXml: "",

  1071.                 showToFront: false,

  1072.                 param: undefined

  1073.             }

  1074.             var func;

  1075.             if (this.clientType == "wps")

  1076.                 func = "wps.WpsApplication().Quit"

  1077.             else if (this.clientType == "et")

  1078.                 func = "wps.EtApplication().Quit"

  1079.             else if (this.clientType == "wpp")

  1080.                 func = "wps.WppApplication().Quit"

  1081. 

  1082.             function closeSilentClient(res) {

  1083.                 if (res.status == 0)

  1084.                     this.client.clientId = ""

  1085.                 if (callback) callback(res);

  1086.                 return;

  1087.             }

  1088.             this.initWpsClient({

  1089.                 name: name,

  1090.                 func: func,

  1091.                 param: paramEx,

  1092.                 urlBase: GetUrlBase(),

  1093.                 callback: closeSilentClient

  1094.             })

  1095.         }

  1096. 

  1097.         /**

  1098.          * 当前客户端是否在运行，使用WpsClient.IsClientRunning()进行调用

  1099.          * @param {function({int, string})} [callback]      回调函数，"Client is running." 客户端正在运行

  1100.          *                                                  "Client is not running." 客户端没有运行

  1101.          */

  1102.         this.IsClientRunning = function (callback) {

  1103.             if (serverVersion < "1.0.1") {

  1104.                 if (callback) {

  1105.                     callback({

  1106.                         status: 4,

  1107.                         message: "当前客户端不支持，请升级客户端"

  1108.                     });

  1109.                     return;

  1110.                 }

  1111.                 return;

  1112.             }

  1113.             IsClientRunning(this.clientType, callback, this)

  1114.         }

  1115.     }

  1116. 

  1117.     /**

  1118.      * 初始化sdk，用来减少在服务进程启动时自定义协议弹框出现的次数

  1119.      */

  1120.     function InitSdk() {

  1121.         var url = GetUrlBase() + "/version";

  1122.         startWps({

  1123.             url: url,

  1124.             callback: function (res) {

  1125.                 if (res.status !== 0) {

  1126.                     cloudSvrStart = false;

  1127.                     return;

  1128.                 }

  1129.                 if (serverVersion == "wait") {

  1130.                     InitMultiUser();

  1131.                 }

  1132.             },

  1133.             tryCount: 1,

  1134.             bPop: false,

  1135.             timeout: 1000

  1136.         });

  1137.     }

  1138.     InitSdk();

  1139. 

  1140.     /**

  1141.      * 初始化多用户模式

  1142.      */

  1143.     function InitMultiUser() {

  1144.         var url = GetUrlBase() + "/version";

  1145.         startWps({

  1146.             url: url,

  1147.             sendData: JSON.stringify({ serverId: serverId }),

  1148.             callback: function (res) {

  1149.                 if (res.status !== 0) {

  1150.                     cloudSvrStart = false;

  1151.                     return;

  1152.                 }

  1153.                 if (serverVersion == "wait") {

  1154.                     serverVersion = res.response;

  1155.                     cloudSvrStart = true;

  1156.                 }

  1157.             },

  1158.             tryCount: 1,

  1159.             bPop: false,

  1160.             timeout: 1000

  1161.         });

  1162.     }

  1163. 

  1164.     if (typeof noGlobal === "undefined") {

  1165.         window.WpsInvoke = WpsInvoke;

  1166.         window.WpsClient = WpsClient;

  1167.         window.WebNotifyUseTimeout = WebNotifyUseTimeout;

  1168.         window.EnableMultiUser = EnableMultiUser;

  1169.     }

  1170. 

  1171.     /**

  1172.      * 当前客户端是否在运行，使用WpsInvoke.IsClientRunning()进行调用

  1173.      * @param {string} clientType       加载项类型

  1174.      * @param {function} [callback]      回调函数，"Client is running." 客户端正在运行

  1175.      *                                   "Client is not running." 客户端没有运行

  1176.      */

  1177.     function IsClientRunning(clientType, callback, wpsclient) {

  1178.         var url = GetUrlBase() + "/isRunning";

  1179.         var wrapper = {

  1180.             id: wpsclient == undefined ? undefined : wpsclient.clientId,

  1181.             app: clientType,

  1182.             serverId: serverId

  1183.         }

  1184.         wrapper = JSON.stringify(wrapper);

  1185.         startWps({

  1186.             url: url,

  1187.             sendData: wrapper,

  1188.             callback: callback,

  1189.             tryCount: 1,

  1190.             bPop: false,

  1191.             timeout: 2000,

  1192.             concurrent: true,

  1193.             client: wpsclient

  1194.         });

  1195.     }

  1196. 

  1197.     /**

  1198.      * 获取publish.xml的内容

  1199.      * @param {*} callBack 回调函数

  1200.      */

  1201.     function WpsAddonGetAllConfig(callBack) {

  1202.         var baseData = JSON.stringify({ serverId: serverId });

  1203.         startWps({

  1204.             url: GetUrlBase() + "/publishlist",

  1205.             type: "POST",

  1206.             sendData: baseData,

  1207.             callback: callBack,

  1208.             tryCount: 3,

  1209.             bPop: true,

  1210.             timeout: 5000,

  1211.             concurrent: true

  1212.         });

  1213.     }

  1214. 

  1215.     /**

  1216.      * 检查ribbon.xml文件是否有效

  1217.      * @param {*} element   参数对象

  1218.      * @param {*} callBack  回调函数

  1219.      */

  1220.     function WpsAddonVerifyStatus(element, callBack) {

  1221.         var xmlReq = getHttpObj();

  1222.         var offline = element.online === "false";

  1223.         var url = offline ? element.url : element.url + "ribbon.xml";

  1224.         xmlReq.open("POST", GetUrlBase() + "/redirect/runParams");

  1225.         xmlReq.onload = function (res) {

  1226.             if (offline && !res.target.response.startsWith("7z")) {

  1227.                 callBack({ status: 1, msg: "不是有效的7z格式" + url });

  1228.             } else if (!offline && !res.target.response.startsWith("<customUI")) {

  1229.                 callBack({ status: 1, msg: "不是有效的ribbon.xml, " + url })

  1230.             } else {

  1231.                 callBack({ status: 0, msg: "OK" })

  1232.             }

  1233.         }

  1234.         xmlReq.onerror = function (res) {

  1235.             xmlReq.bTimeout = true;

  1236.             callBack({ status: 2, msg: "网页路径不可访问，如果是跨域问题，不影响使用" + url })

  1237.         }

  1238.         xmlReq.ontimeout = function (res) {

  1239.             xmlReq.bTimeout = true;

  1240.             callBack({ status: 3, msg: "访问超时" + url })

  1241.         }

  1242.         if (IEVersion() < 10) {

  1243.             xmlReq.onreadystatechange = function () {

  1244.                 if (xmlReq.readyState != 4)

  1245.                     return;

  1246.                 if (xmlReq.bTimeout) {

  1247.                     return;

  1248.                 }

  1249.                 if (xmlReq.status === 200)

  1250.                     xmlReq.onload();

  1251.                 else

  1252.                     xmlReq.onerror();

  1253.             }

  1254.         }

  1255.         xmlReq.timeout = 5000;

  1256.         var data = {

  1257.             method: "get",

  1258.             url: url,

  1259.             data: ""

  1260.         }

  1261.         var sendData = FormatSendData(data)

  1262.         xmlReq.send(sendData);

  1263.     }

  1264. 

  1265.     /**

  1266.      * 部署加载项，包括启动enable / disable禁用 / disableall禁用所有

  1267.      * @param {*} element   参数对象

  1268.      * @param {*} cmd       具体操作，enable / disable / disableall

  1269.      * @param {*} callBack  回调函数

  1270.      */

  1271.     function WpsAddonHandleEx(element, cmd, callBack) {

  1272.         var data = FormatData(element, cmd);

  1273.         startWps({

  1274.             url: GetUrlBase() + "/deployaddons/runParams",

  1275.             type: "POST",

  1276.             sendData: data,

  1277.             callback: callBack,

  1278.             tryCount: 3,

  1279.             bPop: true,

  1280.             timeout: 5000,

  1281.             concurrent: true

  1282.         });

  1283.     }

  1284. 

  1285.     /**

  1286.      * 启用加载项

  1287.      * @param {*} element   参数对象

  1288.      * @param {*} callBack  回调函数

  1289.      */

  1290.     function WpsAddonEnable(element, callBack) {

  1291.         WpsAddonHandleEx(element, "enable", callBack)

  1292.     }

  1293. 

  1294.     /**

  1295.      * 禁用加载项

  1296.      * @param {*} element   参数对象

  1297.      * @param {*} callBack  回调函数

  1298.      */

  1299.     function WpsAddonDisable(element, callBack) {

  1300.         WpsAddonHandleEx(element, "disable", callBack)

  1301.     }

  1302. 

  1303.     /**

  1304.      * 生成json格式的数据

  1305.      * @param {*} element   参数对象

  1306.      * @param {*} cmd       具体操作，enable / disable / disableall

  1307.      * @returns base64编码后的数据

  1308.      */

  1309.     function FormatData(element, cmd) {

  1310.         var data = {

  1311.             "cmd": cmd, //"enable", 启用， "disable", 禁用, "disableall", 禁用所有

  1312.             "name": element.name,

  1313.             "url": element.url,

  1314.             "addonType": element.addonType,

  1315.             "online": element.online,

  1316.             "version": element.version

  1317.         }

  1318.         return FormatSendData(data);

  1319.     }

  1320. 

  1321.     /**

  1322.      * 将json格式的数据字符串化，并进行base64编码

  1323.      * @param {*} data  数据

  1324.      * @returns base64编码后的数据

  1325.      */

  1326.     function FormatSendData(data) {

  1327.         var strData = JSON.stringify(data);

  1328.         if (IEVersion() < 10)

  1329.             eval("strData = '" + JSON.stringify(strData) + "';");

  1330. 

  1331.         if (serverVersion == "1.0.2") {

  1332.             var base64Data = encode(strData);

  1333.             return JSON.stringify({

  1334.                 serverId: serverId,

  1335.                 data: base64Data

  1336.             })

  1337.         }

  1338.         else {

  1339.             return encode(strData);

  1340.         }

  1341.     }

  1342.     //管理 WPS 加载项

  1343.     var WpsAddonMgr = {

  1344.         getAllConfig: WpsAddonGetAllConfig,

  1345.         verifyStatus: WpsAddonVerifyStatus,

  1346.         enable: WpsAddonEnable,

  1347.         disable: WpsAddonDisable,

  1348.     }

  1349. 

  1350.     if (typeof noGlobal === "undefined") {

  1351.         window.WpsAddonMgr = WpsAddonMgr;

  1352.     }

  1353. 

  1354.     return { WpsInvoke: WpsInvoke, WpsAddonMgr: WpsAddonMgr, version: "1.0.21" };

  1355. });