abler-api 0.1.71 → 0.1.73

package/dist/cjs/pp-util.js

@@ -1,102 +1,328 @@
 'use strict';
 
-var require$$0 = require('crypto');
-var require$$1 = require('basic-auth');
+var require$$0 = require('fs');
+var require$$1$1 = require('crypto');
+var require$$2$1 = require('basic-auth');
 var require$$2 = require('abler-util');
 var require$$3 = require('abler-db');
-var require$$4 = require('abler-net');
-var require$$5 = require('fs');
-var require$$1$1 = require('path');
+var require$$5 = require('abler-net');
+var require$$1 = require('path');
 var require$$1$2 = require('abler-messenger');
 var require$$0$1 = require('node-cron');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
-var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
+var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
+var require$$2__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$2$1);
 var require$$2__default = /*#__PURE__*/_interopDefaultLegacy(require$$2);
 var require$$3__default = /*#__PURE__*/_interopDefaultLegacy(require$$3);
-var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4);
 var require$$5__default = /*#__PURE__*/_interopDefaultLegacy(require$$5);
-var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
+var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
 var require$$1__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$1$2);
 var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
 
-const crypto = require$$0__default["default"];
-const getBasicAuthorization = require$$1__default["default"];
+const fs$1 = require$$0__default["default"];
+const path = require$$1__default["default"];
 const ppUtil$4 = require$$2__default["default"].ppUtil;
 const {
   dbUtil: dbUtil$1,
-  kvStorage: kvStorage$1
+  ppRedis,
+  kvStorage: kvStorage$1,
+  redisSimulator
+} = require$$3__default["default"];
+let conf$3, err$2;
+// const dbCheck = require('../dbupdate/dd-version');
+
+/**
+ * API服务启动时前置条件检查
+ * ok = await preconditions
+ *     .setAppName(conf.thisApp)
+ *     .addCheckPromise(preconditions.checkExEnvSetting())
+ *     .addCheckPromise(preconditions.checkRedis())
+ *     .addCheckPromise(checkDatabase())
+ *     .addChecker(myChecker, args)
+ *     .checkAll()
+ */
+class preconditions$2 {
+  static appName;
+  static checkFunctions = [];
+  static checkPromises = [];
+  static setAppName(aName) {
+    ppUtil$4.configNeeded();
+    conf$3 = ppUtil$4.appConfig;
+    err$2 = ppUtil$4.appErrCfg;
+    preconditions$2.appName = aName || conf$3.thisApp;
+    return preconditions$2;
+  }
+  static addCheckPromise(p) {
+    preconditions$2.checkPromises.push(p);
+    return preconditions$2;
+  }
+  static addChecker(checkFunc, args, blocked) {
+    preconditions$2.checkFunctions.push({
+      check: checkFunc,
+      args: args,
+      blocked: blocked
+    });
+    return preconditions$2;
+  }
+  static pushMessage(msg) {
+    if (msg) {
+      if (!preconditions$2.messages) {
+        preconditions$2.messages = [];
+      }
+      preconditions$2.messages.push(`${preconditions$2.messages.length + 1}. ${msg}`);
+    }
+    return msg;
+  }
+  static async checkAll() {
+    try {
+      // for (let i = 0; i < preconditions.checkFunctions.length; i++) {
+      //     const f = preconditions.checkFunctions[i];
+      //     // preconditions.addCheckPromise(f.check(f.args));
+      //     preconditions.pushMessage(await f.check(f.args));
+      // }
+      while (preconditions$2.checkFunctions.length > 0) {
+        const f = preconditions$2.checkFunctions.shift();
+        if (preconditions$2.pushMessage(await f.check(f.args)) && f.blocked) {
+          break;
+        }
+      }
+
+      // for (let i = 0; i < preconditions.checkPromises.length; i++) {
+      //     preconditions.pushMessage(await preconditions.checkPromises[i]);
+      // }
+      while (preconditions$2.checkPromises.length > 0) {
+        const p = preconditions$2.checkPromises.shift();
+        preconditions$2.pushMessage(await p);
+      }
+    } catch (e) {
+      preconditions$2.pushMessage(e.message);
+    }
+    let text = "";
+    if (preconditions$2.messages) {
+      text = `*** 由于以下原因，${preconditions$2.appName} 尚不能正常提供服务：\n\n` + preconditions$2.messages.join("\n\n") + "\n\n*** 请检查以上各项条件，修复后重新启动服务";
+      console.log("\n" + text);
+      // for (let i = 0; i < preconditions.messages.length; i++) {
+      //     console.log(preconditions.messages[i]);
+      // }
+    }
+    if (!(await fs$1.async_exists("../log"))) {
+      await fs$1.async_mkdir("../log");
+    }
+    await fs$1.async_writeFile(`../log/preconditions`, text);
+    return !text;
+  }
+
+  // 检查器
+
+  /**
+   * 检查本机外部配置文件版本
+   */
+  static async checkExEnvSetting(loadjs) {
+    return await checkExEnvSetting(loadjs);
+  }
+
+  /**
+   * redis 可用性检查
+   */
+  static async checkRedis() {
+    return await checkRedis();
+  }
+
+  /**
+   * 初始化数据库连接
+   */
+  static async initDb() {
+    return await initDb();
+  }
+
+  /**
+   * 初始化键值对存储器
+   */
+  static async initKvStorage(dbSql) {
+    return await initKvStorage(dbSql);
+  }
+
+  // /**
+  //  * 数据库可用性及业务数据版本版本检查
+  //  */
+  // static async checkDatabase() {
+  //     return await checkDatabase();
+  // }
+}
+async function createEnvSettingFile(fileName, lastEnvSettingEx) {
+  try {
+    const cfgText = await ppUtil$4.doCreateEnvSettingFile(fileName, lastEnvSettingEx);
+    if (cfgText.indexOf(`cfgVersion: "${conf$3._envSetting.cfgVersion}"`) > 0) {
+      console.log(`\n*** 已創建新的本機環境配置文件\n${fileName}\n请檢查各項內容是否正确(此项更新服务可正常运行)\n\n`);
+      return "";
+    }
+    return `已創建新的本機環境配置文件\n${fileName}\n请檢查並正確設置各項內容，然後將配置版本號修改為${conf$3._envSettings.default.cfgVersion}`;
+  } catch (e) {
+    return `創建本機環境配置文件失敗\n《${fileName}》\n${err$2.ERROR(e).message}`;
+  }
+}
+async function checkExEnvSetting(loadjs) {
+  if (conf$3._envSetting.localSettingImported) return "";
+  try {
+    let fileName = conf$3.getEnvSettingFileName();
+    if (!fs$1.existsSync(fileName)) {
+      return await createEnvSettingFile(fileName);
+    }
+    let envSettingEx = loadjs(fileName);
+    if (envSettingEx.cfgVersion !== conf$3._envSettings.default.cfgVersion) {
+      if (envSettingEx.cfgVersion !== "0.0") {
+        let fp = path.parse(fileName);
+        let lastVerFileName = path.join(fp.dir, fp.name + envSettingEx.cfgVersion + fp.ext);
+        if (!fs$1.existsSync(lastVerFileName)) {
+          fs$1.renameSync(fileName, lastVerFileName);
+        }
+      }
+      let msg = await createEnvSettingFile(fileName, envSettingEx);
+      if (msg) {
+        return msg;
+      }
+      delete require.cache[fileName];
+    }
+    ppUtil$4.importExEnvSetting(conf$3._envSetting, fileName, loadjs);
+  } catch (e) {
+    return `导入本机环境配置失败\n${e.stack}`;
+  }
+}
+
+// async function checkDatabase() {
+//     return dbCheck.check().then(info => info.updateMessage);
+// }
+
+async function checkRedis() {
+  if (!conf$3.redis.enabled) return "";
+  const redis = ppRedis.newClient("kv");
+  // console.log(`checkRedis begin：`);
+  await ppUtil$4.wait(15 * 1000, param => {
+    if (redis.ready && redis.connected || redis.error) {
+      return true;
+    }
+  }).catch(e => {
+    redis.error = e;
+  });
+  if (redis.error) {
+    console.log(`未能成功連接 redis： ${redis.error}，請檢查相關設置`);
+    return `未能成功連接 redis： ${redis.error}，請檢查相關設置`;
+  }
+  // console.log(`checkRedis done：`);
+  // console.log(redis);
+}
+async function initDb() {
+  try {
+    dbUtil$1.config(conf$3, err$2);
+  } catch (e) {
+    if (e.reason === 'bad decrypt') {
+      e = new Error(`解密数据库密码(${conf$3.dbconn.dbpwd})失败`);
+    }
+    // if (e.reason === 'bad decrypt') {
+    //     e = new Error(`解密Redis密码(${conf.redis.password})失败`);
+    // }
+    return `初始化数据库连接失败(${e.message})`;
+  }
+}
+async function initKvStorage(dbSql) {
+  try {
+    kvStorage$1.config(conf$3, err$2);
+    if (conf$3.redis.enabled) {
+      kvStorage$1.setRedis(ppRedis.newClient("kv"));
+    } else {
+      kvStorage$1.setRedis(new redisSimulator(dbSql));
+    }
+  } catch (e) {
+    // if (e.reason === 'bad decrypt') {
+    //     e = new Error(`解密Redis密码(${conf.redis.password})失败`);
+    // }
+    return `初始化键值对存储器失败(${e.message})`;
+  }
+}
+var ppPrecond = preconditions$2;
+
+const fs = require$$0__default["default"];
+const crypto = require$$1__default$1["default"];
+const getBasicAuthorization = require$$2__default$1["default"];
+const ppUtil$3 = require$$2__default["default"].ppUtil;
+const {
+  dbUtil,
+  kvStorage
 } = require$$3__default["default"];
 const {
   netUtil: netUtil$1
-} = require$$4__default["default"];
-const fs$1 = require$$5__default["default"];
-let conf$3, appSetting$1, err$2, dbSql;
+} = require$$5__default["default"];
+const preconditions$1 = ppPrecond;
+let conf$2, appSetting, err$1, dbSql;
 const pnToken = "access_token",
-      hnToken = pnToken,
-      pnApiKey = "apiKey",
-      hnApiKey = pnApiKey.toLowerCase(),
-      // 我们接收到的 headers 中的字段名总是全小写的
-pnApiSecret = "apiSecret",
-      hnApiSecret = pnApiSecret.toLowerCase();
-const MD5 = ppUtil$4.MD5,
-      moveProperty = ppUtil$4.moveProperty;
-
+  hnToken = pnToken,
+  pnApiKey = "apiKey",
+  hnApiKey = pnApiKey.toLowerCase(),
+  // 我们接收到的 headers 中的字段名总是全小写的
+  pnApiSecret = "apiSecret",
+  hnApiSecret = pnApiSecret.toLowerCase();
+const MD5 = ppUtil$3.MD5,
+  moveProperty = ppUtil$3.moveProperty;
 class apiUtil$2 {
-  static debugFlag = ppUtil$4.newGuid(); //应用必须设置，否则谁也不知道是啥
-
-  static testFlag = ppUtil$4.newGuid();
+  static debugFlag = ppUtil$3.newGuid(); //应用必须设置，否则谁也不知道是啥
+  static testFlag = ppUtil$3.newGuid();
   static envId_dev = "?";
   static _validateBasicAuth = function (userName, password) {
     throw {
       status: 500,
       message: 'no basic auth validator'
     };
-  }; // static apiCallRecSaver;
+  };
+
+  // static apiCallRecSaver;
 
   static config(appConfig, appErrCfg, appDbSql) {
-    conf$3 = appConfig;
-    appSetting$1 = conf$3?.appSetting;
-    err$2 = appErrCfg;
+    conf$2 = appConfig;
+    appSetting = conf$2?.appSetting;
+    err$1 = appErrCfg;
     dbSql = appDbSql;
-    ppUtil$4.config(appConfig, appErrCfg);
-    kvStorage$1.config(appConfig, appErrCfg);
-    apiUtil$2.debugFlag = appSetting$1?.debugFlag || apiUtil$2.debugFlag;
-    apiUtil$2.testFlag = appSetting$1?.testFlag || apiUtil$2.testFlag; // apiUtil.apiCallRecSaver = apiCallRecSaver;
-  } //#region ===== 需要应用系统重写的方法
+    ppUtil$3.config(appConfig, appErrCfg);
+    kvStorage.config(appConfig, appErrCfg);
+    apiUtil$2.debugFlag = appSetting?.debugFlag || apiUtil$2.debugFlag;
+    apiUtil$2.testFlag = appSetting?.testFlag || apiUtil$2.testFlag;
+    // apiUtil.apiCallRecSaver = apiCallRecSaver;
+    preconditions$1.setAppName();
+  }
+
+  //#region ===== 需要应用系统重写的方法
 
   /**
    * 根据机构标识获取机构的 ApiSecret
    * @param companyId
    * @returns {*}
    */
-
-
   static _getApiSecret(companyId) {
-    return ppUtil$4.newGuid();
+    return ppUtil$3.newGuid();
   }
+
   /**
    * 保存 API 调用记录,应用系统必须重写此方法
    * @param rec
    * @param responseData
    * @returns {Promise<unknown>}
    */
-
-
   static async _saveApiCallRec(rec, responseData) {
     return false;
   }
+
   /**
    * 检查API调用签名是否已经完成了验证
    * @param req
    */
-
-
   static signatureVerified(req) {
     return req?.signatureVerified;
-  } //#endregion
+  }
+
+  //#endregion
+
   //#region ===== API服务相关工具
 
   /**
@@ -104,16 +330,12 @@ class apiUtil$2 {
    * @param req
    * @returns {*}
    */
-
-
   static extractParams(req) {
     if (!req._requestParams) {
       if (req.method === "POST" || req.method === "PUT") {
         let contentType = req.headers["content-type"] || "application/json";
-
         if (contentType.startsWith("multipart/form-data")) {
           req._requestParams = new Object();
-
           for (let k in req.body) {
             req._requestParams[k] = req.body[k];
           }
@@ -123,14 +345,11 @@ class apiUtil$2 {
       } else {
         req._requestParams = req.query;
       }
-
       if (req.headers["content-type"] !== "application/json") {
         const obj = req._requestParams;
-
         for (let key in obj) {
           if (!obj.hasOwnProperty(key)) continue;
           let value = obj[key];
-
           if (typeof value === "string" && value.length > 0) {
             if (value[0] === "{" || value[0] === "[") {
               try {
@@ -138,31 +357,24 @@ class apiUtil$2 {
                 continue;
               } catch (e) {}
             }
-
             let x = JSON.hbDateConv(key, value);
-
             if (x !== value) {
               obj[key] = x;
             }
           }
         }
       }
-
       if (req.params) {
         req._requestParams = Object.assign(req.params, req._requestParams);
       }
-
       apiUtil$2.setParamsFunctions(req._requestParams);
     }
-
     return req._requestParams;
   }
-
   static extractTokenData(req) {
     if (req.tokenData) {
       return req.tokenData;
     }
-
     let params = apiUtil$2.extractParams(req);
     let tokenData = {
       apiKey: req.headers[hnApiKey] || params[pnApiKey],
@@ -171,38 +383,34 @@ class apiUtil$2 {
     };
     return tokenData;
   }
+
   /**
    * 为从传入请求中解出的参数对象设置一些函数属性，包括 asNumber, asBool
    * @param params
    */
-
-
   static setParamsFunctions(params) {
-    ppUtil$4.defUnenumProp(params, "asNumber", function (name, minValue, maxValue, defaultValue) {
+    ppUtil$3.defUnenumProp(params, "asNumber", function (name, minValue, maxValue, defaultValue) {
       // if (!this.hasOwnProperty(name)) // {} 定义的对象没有 hasOwnProperty 函数
       if (this[name] === undefined) return defaultValue;
       let result = +this[name];
-
       if (typeof result !== "number" || result < minValue || result > maxValue) {
-        throw [err$2.INVALID_PARAM, `参数 ${name} 必须是 ${minValue} ~ ${maxValue} 之间的数字`];
+        throw [err$1.INVALID_PARAM, `参数 ${name} 必须是 ${minValue} ~ ${maxValue} 之间的数字`];
       }
-
       return result;
     });
-    ppUtil$4.defUnenumProp(params, "asBool", function (name, defaultValue) {
+    ppUtil$3.defUnenumProp(params, "asBool", function (name, defaultValue) {
       if (this[name] === undefined) return defaultValue;
       let result = JSON.parse(this[name]);
       return !!result;
     });
   }
+
   /**
    * 将返回结果转向到指定地址或者通过response发送返回结果
    * @param res
    * @param redirectUrl
    * @param data
    */
-
-
   static sendOrRedirect(res, redirectUrl, data) {
     if (redirectUrl) {
       redirectUrl = netUtil$1.urlAppendParams(redirectUrl, data, true);
@@ -211,14 +419,13 @@ class apiUtil$2 {
       res.send(data);
     }
   }
+
   /**
    * 生成 API 成功返回结果
    * @param data
    * @param req
    * @returns {{datetime: Date, success: boolean, stateCode: number, message: string}}
    */
-
-
   static apiSuccess(data, req, spOrderNum) {
     let response = {
       success: true,
@@ -226,86 +433,73 @@ class apiUtil$2 {
       message: '',
       datetime: new Date()
     };
-
     if (spOrderNum) {
       response.spOrderNum = spOrderNum;
     }
-
     if (req && req.headers) {
       let userAgent = req.headers["user-agent"];
-
       if (userAgent && userAgent.startsWith("Postman")) {
         response._elapse = (new Date().valueOf() - req.headers.timestamp) / 1000;
       }
     }
-
     if (data && data._message_) {
       response.message = data._message_;
       delete data._message_;
     }
-
     response.data = data;
     if (Array.isArray(data) && typeof data.recordCount != 'undefined') response.recordCount = data.recordCount;
     return response;
   }
+
   /**
    * 生成 API 失败返回结果
    * @param error
    * @param req
    * @returns {*}
    */
-
-
   static apiFail(error, req, spOrderNum) {
     configNeeded();
-    let response = err$2.ERROR(error, err$2.errorLangParamFlag + ppUtil$4.getMsgLang(req));
+    let response = err$1.ERROR(error, err$1.errorLangParamFlag + ppUtil$3.getMsgLang(req));
     response.datetime = new Date();
-
     if (spOrderNum) {
       response.spOrderNum = spOrderNum;
     }
-
     if (req && req.headers) {
       let userAgent = req.headers["user-agent"];
-
       if (userAgent && userAgent.startsWith("Postman")) {
         response._elapse = (new Date().valueOf() - req.headers.timestamp) / 1000;
       }
     }
-
     return response;
   }
+
   /**
    * 生成面向服务商的API成功返回结果
    * @param data
    * @param req
    * @returns {*}
    */
-
-
   static spoApiSucc(data, req) {
     let params = apiUtil$2.extractParams(req);
     return apiUtil$2.apiSuccess(data, req, params.spOrderNum);
   }
+
   /**
    * 生成面向服务商的API失败返回结果
    * @param error
    * @param req
    * @returns {*}
    */
-
-
   static spoApiFail(error, req) {
     let params = apiUtil$2.extractParams(req);
     return apiUtil$2.apiFail(error, req, params.spOrderNum);
   }
+
   /**
    * API 服务结束，发送响应
    * @param response
    * @param promise
    */
-
-
   static sendResponse(response, promise) {
     promise.then(function (data) {
       if (!response.finished) {
@@ -323,13 +517,12 @@ class apiUtil$2 {
       }
     });
   }
+
   /**
    * API 服务结束，包装数据并发送响应
    * @param response
    * @param promise
    */
-
-
   static async responseOf(response, promise) {
     promise.then(function (data) {
       // console.log('RES:', apiSuccess(data));
@@ -339,64 +532,58 @@ class apiUtil$2 {
       if (!response.finished) response.send(apiUtil$2.apiFail(error, response.req));
     });
   }
+
   /**
    * 面向服务商的API结束，发送响应
    * @param response
    * @param promise
    */
-
-
   static async spoApiResponse(response, promise) {
     promise.then(function (result) {
       let responseData = apiUtil$2.spoApiSucc(result, response.req);
-
       apiUtil$2._saveApiCallRec(response.req.apiCallRec, responseData);
-
       if (!response.finished) response.send(responseData);
     }, function (error) {
       // console.log('ERROR:', error);
       let responseData = apiUtil$2.spoApiFail(error, response.req);
-
       apiUtil$2._saveApiCallRec(response.req.apiCallRec, responseData);
-
       if (!response.finished) response.send(responseData);
     });
   }
+
   /**
    * 从请求参数中获取查询参数
     * @param req
    * @param res
    * @returns {*}
    */
-
-
   static getQueryOptions(req, res) {
-    req.headers.timestamp = new Date().valueOf(); // let options = {replacements: {}};
-
+    req.headers.timestamp = new Date().valueOf();
+    // let options = {replacements: {}};
     let options = {};
     let parameters = apiUtil$2.extractParams(req);
-
     for (let qryParam in parameters) {
       if (qryParam !== 'token') {
         if (['start', 'limit', 'orderby', 'orderBy'].indexOf(qryParam) >= 0) {
           options[qryParam] = parameters[qryParam];
           delete parameters[qryParam];
-        } // else
+        }
+        // else
         //     options.replacements[qryParam] = parameters[qryParam];
-
       }
     }
-
     if (options.limit && !options.start) {
       options.start = 0;
     }
-
     if (options.orderby) {
       options.orderBy = options.orderby;
-    } // options.__debug__ = req.headers['__debug__'] && req.headers['__debug__'] == "true";
+    }
+
+    // options.__debug__ = req.headers['__debug__'] && req.headers['__debug__'] == "true";
 
+    options.replacements = parameters;
 
-    options.replacements = parameters; // if (arguments.length > 1) //其后的每个参数是要求必须存在的参数名称
+    // if (arguments.length > 1) //其后的每个参数是要求必须存在的参数名称
     // {
     //     for(i=1; i<arguments.length; i++){
     //         var paramName = arguments[i];
@@ -408,14 +595,13 @@ class apiUtil$2 {
     options.userInfo = req.userInfo;
     return apiUtil$2.setOptionsPropFuncions(options, res);
   }
+
   /**
    * 为API请求 options 设置属性
    * @param options
    * @param res
    * @returns {{identifyLimit}|*}
    */
-
-
   static setOptionsPropFuncions(options, res) {
     // if (!options.identifyLimit) {
     //     // 根据企业标识获取身份认证限制相关设置，如果没有传递企业标识，
@@ -451,9 +637,9 @@ class apiUtil$2 {
         enumerable: false
       });
     }
-
     return options;
   }
+
   /**
    * 从请求头获取token
    * @param req
@@ -461,64 +647,53 @@ class apiUtil$2 {
    * @param noErr
    * @returns {Promise<*>}
    */
-
-
   static extractToken(req, res, noErr) {
     configNeeded();
-
     if (!req.accessToken) {
       let token = req.header('Authorization');
-
       if (token && token.startsWith('Bearer ')) {
         token = token.substring(7);
       } else {
         //检查post的信息或者url查询参数或者头信息
         token = req.headers[hnToken] || req.headers['x-access-token']; //向后兼容
       }
-
       if (!token) {
         let params = apiUtil$2.extractParams(req);
         token = params[pnToken];
-
         if (token) {
           delete params[pnToken];
         } else if (params.token) {
           token = params.token; //向后兼容
-
           delete params.token;
         } else {
           // 如果没有token，则返回错误
-          console.log(err$2.TOKEN_NEEDED);
-
+          console.log(err$1.TOKEN_NEEDED);
           if (res) {
-            res.send(err$2.ERROR(err$2.TOKEN_NEEDED));
+            res.send(err$1.ERROR(err$1.TOKEN_NEEDED));
           } else if (!noErr) {
-            throw err$2.TOKEN_NEEDED;
+            throw err$1.TOKEN_NEEDED;
           }
         }
       }
-
       req.accessToken = token;
     }
-
     return req.accessToken;
   }
+
   /**
    * 检查是不是内部调用，应用系统可替换此函数实施更隐秘的检查
    * @param req
    * @returns {Promise<boolean|undefined>}
    */
-
-
   static async checkInternalToken(req) {
     // return await checkInternalToken(req);
     const params = apiUtil$2.extractParams(req);
     req.accessToken = req.accessToken || apiUtil$2.extractToken(req);
-
-    if (req.accessToken === MD5(ppUtil$4.commonHashDisturbing)) {
+    if (req.accessToken === MD5(ppUtil$3.commonHashDisturbing)) {
       //todo: 检查IP
       params.__internal__ = true;
-      req.ignoreToken = true; // if (params.idNum || params.personId) {
+      req.ignoreToken = true;
+      // if (params.idNum || params.personId) {
       //     return queryPersonUser(params.idNum, params.personId)
       //         .then(async userInfo => {
       //             if (!userInfo) {
@@ -532,20 +707,18 @@ class apiUtil$2 {
       // } else {
       //     return true
       // }
-
       return true;
     } else {
       // console.log('token error.', req.accessToken);
-      throw err$2.TOKEN_INVALID;
+      throw err$1.TOKEN_INVALID;
     }
   }
+
   /**
    * 检查请求是否存在合法的token，若不存在则抛出异常
    * @param req
    * @returns {Promise<void>}
    */
-
-
   static async checkRequestToken(req) {
     req.accessToken = req.accessToken || apiUtil$2.extractToken(req);
     const tokenKey = apiUtil$2.userTokenStoreKey(req.accessToken);
@@ -559,39 +732,35 @@ class apiUtil$2 {
       return await apiUtil$2.checkInternalToken(req);
     });
   }
+
   /**
    * 检查是不是调试模式
    * @param req
    * @returns {*|boolean|boolean}
    */
-
-
   static isDebugMode(req) {
     if (req.__debug__ === undefined) {
       let dbgToken = req.headers['__debug__'] || req.headers[apiUtil$2.debugFlag];
-
       if (dbgToken) {
         let envId = process.env.ECS_DEPLOY_ID;
-        req.__debug__ = dbgToken && dbgToken === MD5(req.headers.timestamp, ppUtil$4.commonHashDisturbing) && (envId === "florist_longdan" || envId === "shuzi");
+        req.__debug__ = dbgToken && dbgToken === MD5(req.headers.timestamp, ppUtil$3.commonHashDisturbing) && (envId === "florist_longdan" || envId === "shuzi");
       } else {
         req.__debug__ = false;
-      } // console.log("__debug__:", req.__debug__, "dbgToken:", dbgToken);
-
+      }
+      // console.log("__debug__:", req.__debug__, "dbgToken:", dbgToken);
     }
-
-    return req.__debug__; // return req.headers["postman-token"] || req.headers['__debug__'] && req.headers['__debug__'] == "true";
+    return req.__debug__;
+    // return req.headers["postman-token"] || req.headers['__debug__'] && req.headers['__debug__'] == "true";
   }
+
   /**
    * 检查是不是测试模式
    * @param req
    * @returns {*|boolean}
    */
-
-
   static isTestMode(req) {
     if (req.__postman__ === undefined) {
       let dbgToken = req.headers["__postman__"] || req.headers[apiUtil$2.testFlag];
-
       if (dbgToken) {
         let envId = process.env.ECS_DEPLOY_ID;
         let testToken = MD5(req.headers.timestamp, apiUtil$2.extractToken(req, null, true) || req.headers.apikey);
@@ -600,65 +769,59 @@ class apiUtil$2 {
         req.__postman__ = false;
       }
     }
-
     return req.__postman__;
   }
+
   /**
    * 获取令牌过期时长
    * @param req
    * @returns {any}
    */
-
-
   static tokenExpireTime(req) {
-    return apiUtil$2.isDebugMode(req) ? 30 * 24 * 60 * 60 : apiUtil$2.isTestMode(req) ? 4 * 60 * 60 : appSetting$1.tokenExpireTime;
+    return apiUtil$2.isDebugMode(req) ? 30 * 24 * 60 * 60 : apiUtil$2.isTestMode(req) ? 4 * 60 * 60 : appSetting.tokenExpireTime;
   }
+
   /**
    * 获取用户令牌保存键
    * @param token
    * @returns {string}
    */
-
-
   static userTokenStoreKey(token) {
     return "ut_" + token;
   }
+
   /**
    * 获取机构令牌保存键
    * @param token
    * @returns {string}
    */
-
-
   static apiTokenStoreKey(token) {
     return "api_" + token;
   }
+
   /**
    * 判断是不是香港身份证
    * @param idNum
    * @returns {boolean}
    */
-
-
   static checkIsHKIC(idNum) {
     return idNum.length === 8;
   }
+
   /**
    * 将身份证号码暂存到用户信息中
    * @param userInfo
    * @param idNum
    * @returns {*}
    */
-
-
   static setUserIdNo(userInfo, idNum) {
     if (userInfo && idNum) {
       userInfo._idNo = idNum;
       userInfo.isHKIC = apiUtil$2.checkIsHKIC(idNum);
     }
-
     return userInfo;
   }
+
   /**
    * 暂存令牌
    * @param token
@@ -667,53 +830,46 @@ class apiUtil$2 {
    * @param req
    * @returns {Promise<void>}
    */
-
-
   static async storeToken(token, tokenData, dataId, req) {
     // let timeout = tokenData.clientIp.substring(0, 8) == "192.168." ? 90 * 24 : 1;
     let timeout = apiUtil$2.tokenExpireTime(req);
-
     if (req.certPublicKey) {
       tokenData.certPublicKey = req.certPublicKey;
     }
-
-    await kvStorage$1.storeObj(token, tokenData, timeout);
-
+    await kvStorage.storeObj(token, tokenData, timeout);
     if (dataId) {
-      await kvStorage$1.restoreValue("token_" + dataId).then(async oldToken => {
+      await kvStorage.restoreValue("token_" + dataId).then(async oldToken => {
         if (oldToken !== token) {
-          await kvStorage$1.unstoreValue(oldToken);
+          await kvStorage.unstoreValue(oldToken);
         } else {
           dataId = "";
         }
       }, function (e) {}).then(async () => {
-        if (dataId !== "") await kvStorage$1.storeValue("token_" + dataId, token, timeout);
+        if (dataId !== "") await kvStorage.storeValue("token_" + dataId, token, timeout);
       });
     }
   }
+
   /**
    * 恢复令牌数据
    * @param accessToken
    * @param expireTime
    * @returns {Promise<any>}
    */
-
-
   static async restoreTokenData(accessToken, expireTime) {
-    return await kvStorage$1.restoreObj(accessToken, expireTime);
+    return await kvStorage.restoreObj(accessToken, expireTime);
   }
+
   /**
    * 创建 API 调用记录
    * @param tokenData
    * @param req
    * @returns {any}
    */
-
-
   static createApiCallRec(tokenData, req) {
     if (!req.apiCallRec) {
       if (req.apiCallRecId) {
-        return dbUtil$1.dbQueryOne(dbSql.loadApiUsage, {
+        return dbUtil.dbQueryOne(dbSql.loadApiUsage, {
           replacements: {
             id: req.apiCallRecId
           }
@@ -722,10 +878,10 @@ class apiUtil$2 {
           return req.apiCallRec;
         });
       } else {
-        let params = apiUtil$2.extractParams(req); // let contentLength = parseInt(req.headers["content-length"]) || 0;
-
+        let params = apiUtil$2.extractParams(req);
+        // let contentLength = parseInt(req.headers["content-length"]) || 0;
         let rec = {
-          id: ppUtil$4.newGuid(),
+          id: ppUtil$3.newGuid(),
           companyId: tokenData.apiKey || '',
           orderId: params.orderId || '',
           signerId: params.signerId || '',
@@ -750,54 +906,44 @@ class apiUtil$2 {
           resultInfo: params.resultInfo || '',
           resultData: params.resultData || ''
         };
-
         if (rec.secret !== "") {
-          rec.secret = ppUtil$4.getEncAse192(rec.secret);
+          rec.secret = ppUtil$3.getEncAse192(rec.secret);
         }
-
         req.apiCallRec = rec;
       }
     }
-
     return req.apiCallRec;
-
     function _getBodyLogStr(req) {
       let contentLength = parseInt(req.headers["content-length"]) || 0;
       if (contentLength < 500) return req.rawBody || '';
       let tempBody = {};
-
       for (let key in req.body) {
         let value = req.body[key];
-
         if (typeof value == 'string' && value.length > 500) {
           value = value.substring(0, 31) + '...(' + value.length + ')';
         }
-
         tempBody[key] = value;
       }
-
       return JSON.stringify(tempBody);
     }
   }
+
   /**
    * 查询机构信息
    * @param companyId
    * @param nullable
    * @returns {Promise<null|*>}
    */
-
-
   static async queryCompanyInfo(companyId, nullable) {
-    return await dbUtil$1.dbQueryOne(dbSql.queryCompanyInfo, {
+    return await dbUtil.dbQueryOne(dbSql.queryCompanyInfo, {
       companyId
     }, nullable);
   }
+
   /**
    * 获取企业有效证书
    * @param companyId: 企业标识
    */
-
-
   static async getCompanyCertificate(companyId) {
     let certInfo = {
       // 正式启用的证书
@@ -807,26 +953,26 @@ class apiUtil$2 {
       certSpare: null,
       certSpareId: ''
     };
-    return await dbUtil$1.dbQueryOne(dbSql.queryCertDataByOwner, {
+    return await dbUtil.dbQueryOne(dbSql.queryCertDataByOwner, {
       ownerId: companyId,
       applyId: "company"
     }, false).then(certRec => {
       // console.log('当前证书:\n', certRec);
       // checkCertStatus(certRec);
       let certData = JSON.parse(certRec.certBody);
-      let pubKeyData = Buffer.from(certData.cert, "base64").toString(); // 公司正式证书
-
+      let pubKeyData = Buffer.from(certData.cert, "base64").toString();
+      // 公司正式证书
       certInfo.certLiving = pubKeyData;
       certInfo.certLivingId = certRec.id;
-      return dbUtil$1.dbQueryOne(dbSql.queryCertDataByOwner, {
+      return dbUtil.dbQueryOne(dbSql.queryCertDataByOwner, {
         ownerId: companyId,
         applyId: "company_spare"
       }, false).then(certRec1 => {
         // console.log('备用证书:\n', certRec1);
         // checkCertStatus(certRec1);
         let certData1 = JSON.parse(certRec1.certBody);
-        let pubKeyData1 = Buffer.from(certData1.cert, "base64").toString(); // 公司备用证书
-
+        let pubKeyData1 = Buffer.from(certData1.cert, "base64").toString();
+        // 公司备用证书
         certInfo.certSpare = pubKeyData1;
         certInfo.certSpareId = certRec1.id;
       }).catch(e => {
@@ -837,55 +983,45 @@ class apiUtil$2 {
       return certInfo;
     }).catch(e => {
       console.log('获取企业证书失败:\n', e);
-      throw [err$2.ACCESS_REFUSED, `获取企业证书失败：${err$2.ERROR(e).message}`];
+      throw [err$1.ACCESS_REFUSED, `获取企业证书失败：${err$1.ERROR(e).message}`];
     });
   }
+
   /**
    * 验证API调用签名
    * @param tokenData
    * @param req
    * @returns {Promise<*|boolean>}
    */
-
-
   static async verifyApiSignature(tokenData, req) {
     try {
       if (!req.headers.timestamp) {
-        throw [err$2.ACCESS_REFUSED, `必须在请求头中设置时戳`];
+        throw [err$1.ACCESS_REFUSED, `必须在请求头中设置时戳`];
       }
-
       let timestamp = parseInt(req.headers.timestamp);
       let currentTime = new Date().valueOf();
       let maxTimeDiff = apiUtil$2.isDebugMode(req) ? 7 * 24 * 3600 : apiUtil$2.isTestMode(req) ? 4 * 3600 : 100; // 100
-
       if (timestamp.toString() == "NaN" || currentTime < timestamp - 5000 || currentTime - timestamp > maxTimeDiff * 1000) {
-        throw [err$2.ACCESS_REFUSED, `时戳(${timestamp})无效，当前时戳：${currentTime},时差 ${(currentTime - timestamp) / 1000}秒`];
+        throw [err$1.ACCESS_REFUSED, `时戳(${timestamp})无效，当前时戳：${currentTime},时差 ${(currentTime - timestamp) / 1000}秒`];
       }
-
       let signature = req.headers.signature;
-
       if (!signature) {
-        throw [err$2.ACCESS_REFUSED, `必须在请求头中提供签名`];
+        throw [err$1.ACCESS_REFUSED, `必须在请求头中提供签名`];
       }
-
       let signData = apiUtil$2.extractToken(req, null, true) || tokenData.apiKey;
       signData += timestamp;
-
       if (apiUtil$2.isDebugMode(req) || apiUtil$2.isTestMode(req)) {
         let publicKey = req.headers.publickey || req.body.publicKey || req.query.publicKey;
-
         if (publicKey) {
           publicKey = decodeURIComponent(publicKey);
           tokenData.certPublicKey = publicKey;
           req.certPublicKey = publicKey;
         }
       }
-
       if (tokenData.certPublicKey) {
         let verifyResult = doVerify(signData, signature, tokenData.certPublicKey);
         return await verifyResult;
       }
-
       return apiUtil$2.getCompanyCertificate(tokenData.apiKey).then(info => {
         tokenData.certPublicKey = info.certLiving;
         tokenData.certPublicKeySpare = info.certSpare;
@@ -893,7 +1029,6 @@ class apiUtil$2 {
         tokenData.certSpareId = info.certSpareId;
         req.certPublicKey = info.certLiving;
         let token = apiUtil$2.extractToken(req, null, true);
-
         if (token) {
           apiUtil$2.storeToken(apiUtil$2.apiTokenStoreKey(token), tokenData, tokenData.apiKey, req);
         }
@@ -904,29 +1039,25 @@ class apiUtil$2 {
       // return Promise.reject(e);
       throw e;
     }
-
     function doVerify(signData, signature) {
       let verify = crypto.createVerify('SHA256');
       verify.write(signData);
       verify.end();
       let verifyOK = false;
-
       try {
         // 先用正式证书验证
         verifyOK = verify.verify(tokenData.certPublicKey, signature, 'base64');
       } catch (e) {
         console.log("SPO服务签名验证异常(正式证书), ", e);
         verifyOK = false;
-
         if (!tokenData.certPublicKeySpare) {
           throw {
-            eo: err$2.ACCESS_REFUSED,
+            eo: err$1.ACCESS_REFUSED,
             msgArgv: "签名验证异常",
             data: e
           };
         }
       }
-
       if (!verifyOK && tokenData.certPublicKeySpare) {
         try {
           // 再用备用证书验证
@@ -934,18 +1065,17 @@ class apiUtil$2 {
           verifySpare.write(signData);
           verifySpare.end();
           verifyOK = verifySpare.verify(tokenData.certPublicKeySpare, signature, 'base64');
-
           if (verifyOK) {
             // 备用证书验证成功了，则将备用证书替换为正式证书
             console.log(`公司(${tokenData.apiKey})备用证书验签成功，正式启用...`);
-            return dbUtil$1.dbTrans(trans => {
-              let p1 = dbUtil$1.dbExec(dbSql.deleteCertRecById, {
+            return dbUtil.dbTrans(trans => {
+              let p1 = dbUtil.dbExec(dbSql.deleteCertRecById, {
                 replacements: {
                   id: tokenData.certLivingId
                 },
                 transaction: trans
               });
-              let p2 = dbUtil$1.dbExec(dbSql.spareCertToLiving, {
+              let p2 = dbUtil.dbExec(dbSql.spareCertToLiving, {
                 replacements: {
                   id: tokenData.certSpareId
                 },
@@ -958,59 +1088,51 @@ class apiUtil$2 {
               delete tokenData.certSpareId;
               delete tokenData.certPublicKeySpare;
               let token = apiUtil$2.extractToken(req);
-
               if (token) {
                 apiUtil$2.storeToken(apiUtil$2.apiTokenStoreKey(token), tokenData, tokenData.apiKey, req);
               }
-
               console.log(`公司(${tokenData.apiKey})备用证书成功转换为正式证书`);
             });
           }
         } catch (e) {
           console.log("SPO服务签名验证异常(备用证书), ", e);
           throw {
-            eo: err$2.ACCESS_REFUSED,
+            eo: err$1.ACCESS_REFUSED,
             msgArgv: "签名验证异常(spare)",
             data: e
           };
         }
       }
-
       if (!verifyOK) {
         console.log("SPO服务签名验证失败, tokenData: ", tokenData);
-        throw [err$2.ACCESS_REFUSED, "签名验证未通过"];
+        throw [err$1.ACCESS_REFUSED, "签名验证未通过"];
       }
-
       return verifyOK;
     }
   }
+
   /**
    * 检查API调用之合法性
    * @param tokenData
    * @param req
    * @returns {Promise<any>}
    */
-
-
   static async checkApiCallValid(tokenData, req) {
     if (!tokenData.companyInfo) {
       tokenData.companyInfo = await apiUtil$2.queryCompanyInfo(tokenData.apiKey, true).catch(e => {
         console.log("执行企业信息查询发生异常", e);
-        throw [err$2.API_KEY_INVALID, "执行企业信息查询发生异常：" + e.message || ""];
+        throw [err$1.API_KEY_INVALID, "执行企业信息查询发生异常：" + e.message || ""];
       });
     }
-
     const companyInfo = tokenData.companyInfo;
-
     if (companyInfo != null) {
       let secret = apiUtil$2._getApiSecret(tokenData.apiKey);
-
-      if (secret !== tokenData.apiSecret) throw err$2.API_SCREPT_INVALID; // 不再检查 IP 白名单，改为验证证书签名
+      if (secret !== tokenData.apiSecret) throw err$1.API_SCREPT_INVALID;
+      // 不再检查 IP 白名单，改为验证证书签名
       // console.log("fromIp:", tokenData.clientIp, "ipWhiteList:", companyInfo.ipWhiteList);
       // let whiteList = companyInfo.ipWhiteList || "";
       // // 没有设置ip白名单的就不检查了
       // if (whiteList == "" || ipMatched(tokenData.clientIp, whiteList + ",127.0.0.1,1"))
-
       if (apiUtil$2.signatureVerified(req)) return companyInfo;
       return apiUtil$2.verifyApiSignature(tokenData, req).then(x => {
         return companyInfo;
@@ -1018,30 +1140,26 @@ class apiUtil$2 {
         throw e;
       });
     }
-
-    throw [err$2.API_KEY_INVALID, tokenData.apiKey];
+    throw [err$1.API_KEY_INVALID, tokenData.apiKey];
   }
+
   /**
    * 检查令牌数据是否存在
    * @param token
    * @returns {*}
    */
-
-
   static tokenDataExist(token) {
-    return kvStorage$1.stored(token);
+    return kvStorage.stored(token);
   }
-
   static parametersOK(params) {
     configNeeded();
     let paramSufix = params._param_sufix || "";
-
     for (let i = 1; i < arguments.length; i++) {
       let paramName = arguments[i];
       let paramExists = false;
-
       if (paramName.includes("/")) {
-        let names = paramName.split("/"); // if (params[names[0]]) {
+        let names = paramName.split("/");
+        // if (params[names[0]]) {
         //     paramExists = true;
         // } else {
         //     if (params[names[1]]) {
@@ -1050,113 +1168,96 @@ class apiUtil$2 {
         //         delete params[names[1]];
         //     }
         // }
-
         for (let ind in names) {
           let name = names[ind];
-
           if (typeof params[name] != 'undefined') {
             paramExists = true;
             break;
           }
-
           if (paramSufix != "" && typeof params[name + paramSufix] != 'undefined') {
             paramExists = true;
             break;
           }
         }
-
         paramName = `${paramName} 之一`;
       } else {
         paramExists = typeof params[paramName] != 'undefined' || typeof params[paramName + paramSufix] != 'undefined';
       }
-
-      if (!paramExists) return ppUtil$4.errorPormise(err$2.ERROR(err$2.PARAMETER_NEEDED, paramName));
+      if (!paramExists) return ppUtil$3.errorPormise(err$1.ERROR(err$1.PARAMETER_NEEDED, paramName));
     }
-
     return Promise.resolve(paramSufix);
   }
+
   /**
    * 获取客户端IP地址
    * @param req
    * @returns {*|string|string}
    */
-
-
   static getClientIp(req) {
     if (!req.hasOwnProperty("clientIp")) {
-      let ip = req.headers["x-real-ip"] || req.headers["x-true-ip"] || req.headers['x-forwarded-for'] || req.headers['x-forward-for'] || req.connection.remoteAddress || req.socket.remoteAddress || req.headers['host'] || ""; // console.log("Request IP:", ip, "req: ", req);
-
+      let ip = req.headers["x-real-ip"] || req.headers["x-true-ip"] || req.headers['x-forwarded-for'] || req.headers['x-forward-for'] || req.connection.remoteAddress || req.socket.remoteAddress || req.headers['host'] || "";
+      // console.log("Request IP:", ip, "req: ", req);
       if (ip.indexOf(",") >= 0) {
         ip = ip.split(',')[0];
       }
-
       if (ip.indexOf(":") >= 0) {
         ip = ip.substring(ip.lastIndexOf(':') + 1);
       }
-
       req.clientIp = ip;
     }
-
     return req.clientIp;
   }
+
   /**
    * 获取与本机一起提供服务的所有主机
    * @param params
    * @returns {{port: (number|number), hosts: [string]}}
    */
-
-
   static getEnvHosts(params) {
     configNeeded();
     return {
-      hosts: appSetting$1.serverHosts || ["localhost"],
-      port: appSetting$1.listenPort || +params.port || 8443
+      hosts: appSetting.serverHosts || ["localhost"],
+      port: appSetting.listenPort || +params.port || 8443
     };
   }
+
   /**
    * 检查指定的host和发送请求的ip是不是自己的ip
    * @param host
    * @param req
    * @returns {Promise<*>}
    */
-
-
   static async hostIsMySelf(host, req) {
     let clientIp = apiUtil$2.getClientIp(req);
-
     try {
-      return !!ppUtil$4.getMyIp({
+      return !!ppUtil$3.getMyIp({
         hosts: [host, clientIp]
       });
     } catch (e) {
       return false;
     }
   }
+
   /**
    * 检查是否应该把请求转发到其它服务器，若是则转发
    * @param options
    * @returns {Promise<boolean>}
    */
-
-
   static async checkForwardsHost(options) {
     configNeeded();
     const params = options.replacements;
     const myEnvHosts = apiUtil$2.getEnvHosts(params);
-    const myIp = ppUtil$4.getMyIp();
+    const myIp = ppUtil$3.getMyIp();
     const host = params.host || myIp;
-    if (!myEnvHosts.hosts.contains(host)) throw [err$2.ACCESS_REFUSED, `环境${conf$3.envId}貌似无此主机：${params.host}`];
-
+    if (!myEnvHosts.hosts.contains(host)) throw [err$1.ACCESS_REFUSED, `环境${conf$2.envId}貌似无此主机：${params.host}`];
     if (!apiUtil$2.hostIsMySelf(host, options._res.req)) {
       let result = await apiUtil$2.forwardsTo(host, myEnvHosts.port, params, options._res.req, myIp);
-
       options._res.send(result);
-
       return true;
     }
-
     return false;
   }
+
   /**
    * 将收到的请求转发到另一台主机
    * @param anotherIp
@@ -1166,181 +1267,156 @@ class apiUtil$2 {
    * @param lanClient
    * @returns {Promise<*>}
    */
-
-
   static async forwardsTo(anotherIp, port, params, req, lanClient) {
     let url = anotherIp.indexOf("://") > 0 ? anotherIp : `${req.headers.scheme}://${anotherIp}:${port}${req.originalUrl}`;
-
     if (url.indexOf("?") > 0) {
       url = url.substring(0, url.indexOf("?"));
     }
-
     let reqOptions = {
       method: req.method,
       url: url,
       data: params
     };
     let result = await netUtil$1.apiRequest(reqOptions);
-
     if (result.status !== 200) {
       console.log(`访问 ${reqOptions.url} 出错`, result.status, result.res.statusMessage);
-      throw [err$2.EXCEPTION, `[${result.status}] - ${result.res.statusMessage}`];
+      throw [err$1.EXCEPTION, `[${result.status}] - ${result.res.statusMessage}`];
     }
-
     return result.data;
   }
+
   /**
    * 解析配置项路径
    * @param keyPath
    * @returns {{parent: null, parentKey: string, value, key: string}}
    */
-
-
   static parseCfgPath(keyPath) {
     let keys = Array.isArray(keyPath) ? keyPath : keyPath.split(".");
     let parentKey = "";
     let key = "config";
-    let value = conf$3;
+    let value = conf$2;
     let parent = null;
-
     for (let i = 0; i < keys.length; i++) {
       parent = value;
       parentKey += (parentKey ? "." : "") + key;
       key = keys[i];
       value = parent[key];
-
       if (value === undefined) {
-        throw [err$2.INVALID_PARAM, `无此配置项: ${key}`];
+        throw [err$1.INVALID_PARAM, `无此配置项: ${key}`];
       }
     }
-
     return {
       parent,
       parentKey,
       key,
       value
     };
-  } //#endregion
+  }
+
+  //#endregion
+
   //region ====中间件
 
   /**
    * 检查令牌，若存在则将其的用户信息置入req，否则返回错误信息
    */
-
-
   static async $checkToken(req, res, next) {
     try {
       await apiUtil$2.checkRequestToken(req);
       next();
     } catch (e) {
-      res.send(err$2.ERROR(e));
+      res.send(err$1.ERROR(e));
     }
-
     return false;
   }
+
   /**
    * 检查令牌，若存在则将其用户信息置入req
    */
-
-
   static async $getToken(req, res, next) {
     function extractToken(req, res) {
       if (!req.accessToken) {
         //检查post的信息或者url查询参数或者头信息
         let token = req.headers["access_token"] || req.headers['x-access-token']; //向后兼容
-
         if (!token) {
           let params = apiUtil$2.extractParams(req);
           token = params["access_token"];
-
           if (token) {
             delete params["access_token"];
           } else if (params.token) {
             token = params.token; //向后兼容
-
-            delete params.token; // } else if (res) {
+            delete params.token;
+            // } else if (res) {
             //     // 如果没有token，则返回错误
             //     console.log(err.TOKEN_NEEDED);
             //     res.send(err.ERROR(err.TOKEN_NEEDED));
           }
         }
-
         req.accessToken = token;
       }
-
       return req.accessToken;
     }
-
     try {
       if (extractToken(req, res)) {
         await apiUtil$2.restoreTokenData(apiUtil$2.userTokenStoreKey(req.accessToken), apiUtil$2.tokenExpireTime(req)).then(function (data) {
           req.userInfo = apiUtil$2.setUserIdNo(data, data._idNo);
-        }, function (e) {//no token
+        }, function (e) {
+          //no token
         });
       }
-
       return true;
     } catch (e) {
-      res.send(err$2.ERROR(e));
+      res.send(err$1.ERROR(e));
       return false;
     }
   }
+
   /**
    * 标识此请求已经完成了签名验证或者无需进行签名验证
    */
-
-
   static $signatureVerified(req, res, next) {
     req.signatureVerified = true;
     next();
   }
+
   /**
    * 标识此请求是从前端发过来的，比如移动端、PC浏览器等，区别于SPO一般的服务端后台请求。
    * 如果在请求参数中包含有签名参数，则将其移到请求头中
    */
-
-
   static $isMobile(req, res, next) {
     req.isMobile = true;
-
     if (!apiUtil$2.signatureVerified(req)) {
       let params = apiUtil$2.extractParams(req);
       moveProperty(params, req.headers, "access_token");
       moveProperty(params, req.headers, "timestamp");
-
       if (moveProperty(params, req.headers, "signature")) {
         req.headers.signature = decodeURIComponent(req.headers.signature);
       }
     }
-
     next();
   }
+
   /**
    * 检查企业 API 调用合法性 (apiKey, apiSecret)
    * @param req
    * @param res
    * @param next
    */
-
-
   static $checkApiKeyOld(req, res, next) {
     //检查post的信息或者url查询参数或者头信息
     const tokenData = apiUtil$2.extractTokenData(req);
     const params = apiUtil$2.extractParams(req);
     apiUtil$2.createApiCallRec(tokenData, req);
     let errResponse = null;
-
     if (!tokenData.clientIp) {
-      errResponse = apiUtil$2.spoApiFail(err$2.GET_CLIENTIP_FAIL, req);
+      errResponse = apiUtil$2.spoApiFail(err$1.GET_CLIENTIP_FAIL, req);
     } else if (!tokenData.apiKey) {
-      errResponse = apiUtil$2.spoApiFail([err$2.PARAMETER_NEEDED, "apiKey"], req);
+      errResponse = apiUtil$2.spoApiFail([err$1.PARAMETER_NEEDED, "apiKey"], req);
     } else if (!tokenData.apiSecret) {
-      errResponse = apiUtil$2.spoApiFail([err$2.PARAMETER_NEEDED, "apiSecret"], req);
+      errResponse = apiUtil$2.spoApiFail([err$1.PARAMETER_NEEDED, "apiSecret"], req);
     }
-
     if (errResponse != null) {
       apiUtil$2._saveApiCallRec(req.apiCallRec, errResponse);
-
       apiUtil$2.sendOrRedirect(res, params.redirectUrl || params.callbackUrl, errResponse);
     } else {
       apiUtil$2.checkApiCallValid(tokenData, req).then(companyInfo => {
@@ -1350,32 +1426,26 @@ class apiUtil$2 {
       }, e => {
         console.log('apiCallInvalid:', e);
         let errResponse = apiUtil$2.spoApiFail(e, req);
-
         apiUtil$2._saveApiCallRec(req.apiCallRec, errResponse);
-
         apiUtil$2.sendOrRedirect(res, params.redirectUrl || params.callbackUrl, errResponse);
       });
     }
   }
+
   /**
    * 检查机构令牌
    */
-
-
   static $checkApiKey(req, res, next) {
     if (req.ignoreToken) {
       next();
       return;
     }
-
     let accessToken = apiUtil$2.extractToken(req);
-
     if (!accessToken) {
-      res.send(apiUtil$2.spoApiFail(err$2.TOKEN_NEEDED, req)); // apiUtil.sendOrRedirect(req, res, spoApiFail(err.TOKEN_NEEDED, req));
-
+      res.send(apiUtil$2.spoApiFail(err$1.TOKEN_NEEDED, req));
+      // apiUtil.sendOrRedirect(req, res, spoApiFail(err.TOKEN_NEEDED, req));
       return;
     }
-
     apiUtil$2.restoreTokenData(apiUtil$2.apiTokenStoreKey(accessToken)).then(p => {
       // req.headers[hnApiKey] = p.apiKey || '';
       // req.headers[hnApiSecret] = p.apiSecret || '';
@@ -1387,15 +1457,15 @@ class apiUtil$2 {
       } else {
         p.clientIp = apiUtil$2.getClientIp(req);
       }
-
       req.isApiCall = true;
       req.tokenData = p;
       return apiUtil$2.$checkApiKeyOld(req, res, next);
     }).catch(e => {
       const params = apiUtil$2.extractParams(req);
-      apiUtil$2.sendOrRedirect(res, params.redirectUrl || params.callbackUrl, apiUtil$2.spoApiFail(err$2.TOKEN_INVALID, req));
+      apiUtil$2.sendOrRedirect(res, params.redirectUrl || params.callbackUrl, apiUtil$2.spoApiFail(err$1.TOKEN_INVALID, req));
     });
   }
+
   /**
    * 检查请求令牌，允许个人用户令牌和机构令牌，若不存在或不合法，则返回错误信息
    * @param req
@@ -1403,31 +1473,25 @@ class apiUtil$2 {
    * @param next
    * @returns {Promise<void|boolean|boolean|undefined>}
    */
-
-
   static async $checkTokenOrApiKey(req, res, next) {
     let accessToken = apiUtil$2.extractToken(req, res);
-
     if (accessToken) {
       let tokenExist = await apiUtil$2.tokenDataExist(apiUtil$2.userTokenStoreKey(accessToken));
-
       if (tokenExist) {
         return await apiUtil$2.$checkToken(req, res, next);
       }
-
       tokenExist = await apiUtil$2.tokenDataExist(apiUtil$2.apiTokenStoreKey(accessToken));
-
       if (tokenExist) {
         return apiUtil$2.$checkApiKey(req, res, next);
-      } // 如果给定的token不存在，看看是不是平台内部调用
-
-
+      }
+      // 如果给定的token不存在，看看是不是平台内部调用
       return await apiUtil$2.checkInternalToken(req).catch(e => {
         res.send(apiUtil$2.apiFail(e, req));
         return false;
       });
     }
   }
+
   /**
    * 基本验证，应用系统应该预先设置验证函数 _validateBasicAuth(userName, password)
    * @param req
@@ -1435,12 +1499,9 @@ class apiUtil$2 {
    * @param next
    * @returns {Promise<*>}
    */
-
-
   static async $basicAuth(req, res, next) {
     try {
       const authorization = getBasicAuthorization(req);
-
       if (!authorization) {
         throw {
           status: 401,
@@ -1451,7 +1512,6 @@ class apiUtil$2 {
           }
         };
       }
-
       if (!(await apiUtil$2._validateBasicAuth(authorization.name, authorization.pass, req, res, next))) {
         throw {
           status: 401,
@@ -1468,373 +1528,113 @@ class apiUtil$2 {
           res.set('WWW-Authenticate', `Basic realm=${e.message}`);
           return res.status(401).send(e.message);
         } catch {}
-        res.set('WWW-Authenticate', `Basic realm=validate fail`);
-      }
-
-      return res.status(e.status || 500).send(e.error || e);
-    }
-
-    next();
-  } //#endregion
-  //region ====一些通用服务功能
-
-  /**
-   * 获取配置数据
-   * @param options
-   * @returns {Promise<boolean|*>}
-   */
-  // api/config/appSetting.ossEnabled
-
-
-  static async getConfigValue(options) {
-    configNeeded();
-    const params = options.replacements;
-    let cfgItem = params._cfgItem;
-    delete params._cfgItem;
-    if (await apiUtil$2.checkForwardsHost(options)) return true;
-    let c = apiUtil$2.parseCfgPath(cfgItem);
-    delete c.parent;
-    c.host = ppUtil$4.getMyIp();
-    return c;
-  }
-  /**
-   * 设置配置数据
-   * @param options
-   * @returns {Promise<*>}
-   */
-
-
-  static async setConfigValue(options) {
-    configNeeded();
-    const params = options.replacements;
-    let cfgItem = params._cfgItem;
-    delete params._cfgItem; // if (await checkForwardsHost(options))
-    //     return true;
-
-    await apiUtil$2.parametersOK(params, "value");
-    let c = apiUtil$2.parseCfgPath(cfgItem);
-
-    if (typeof c.value === "object") {
-      throw [err$2.ACCESS_REFUSED, `暂不支持修改复杂配置`];
-    } // c.oldValue = c.value;
-
-
-    c.newValue = params.value;
-    c.parent[c.key] = c.newValue;
-    delete c.parent;
-    c.host = ppUtil$4.getMyIp();
-    return c; // 应用层自行处理多机同步
-  }
-  /**
-   * 修改重启标志文件
-   * 前提，PM2监视 restart,please.flag 文件，此文件若被修改则重启服务进程
-   * 此服务假设 restart,please.flag 文件最后一行是一个整数，此整数+1后保存
-   * @param options
-   * @returns {Promise<number>}
-   */
-
-
-  static async updateRestartFlag(options) {
-    const fileName = `restart,please.flag`;
-    let text = await fs$1.async_readFile(fileName, 'utf8');
-    const lines = text.split('\r\n');
-    const n = +lines[lines.length - 1] + 1;
-    lines[lines.length - 1] = ' '.repeat(50) + n.toString();
-    text = lines.join('\r\n');
-    await fs$1.async_writeFile(fileName, text);
-    return n;
-  }
-  /**
-   * 创建验证码对象
-   * npm i svg-captcha
-   * npm i svg2png
-   */
-
-
-  static createSvgCaptcha(options) {
-    const captcha = svgCaptcha.create({
-      inverse: options.hasOwnProperty('inverse') ? options.inverse : false,
-      fontSize: options.fontSize || 48,
-      noise: options.noise || 2,
-      width: options.width || 150,
-      height: options.height || 75,
-      size: options.size || 4,
-      charPreset: options.charPreset || '0123456789',
-      ignoreChars: options.ignoreChars || '0oli',
-      color: options.hasOwnProperty('color') ? options.color : true,
-      background: options.background || '#cc9966'
-    });
-    return captcha;
-  } //#endregion
-
-
-}
-
-function configNeeded() {
-  if (!conf$3 || !err$2) {
-    ppUtil$4.configNeeded();
-    conf$3 = ppUtil$4.appConfig;
-    appSetting$1 = conf$3.appSetting;
-    err$2 = ppUtil$4.appErrCfg;
-  }
-}
-
-var ppUtilApi = apiUtil$2;
-
-const fs = require$$5__default["default"];
-const path = require$$1__default$1["default"];
-const ppUtil$3 = require$$2__default["default"].ppUtil;
-const {
-  dbUtil,
-  ppRedis,
-  kvStorage,
-  redisSimulator
-} = require$$3__default["default"];
-let conf$2, err$1; // const dbCheck = require('../dbupdate/dd-version');
-
-/**
- * API服务启动时前置条件检查
- * ok = await preconditions
- *     .setAppName(conf.thisApp)
- *     .addCheckPromise(preconditions.checkExEnvSetting())
- *     .addCheckPromise(preconditions.checkRedis())
- *     .addCheckPromise(checkDatabase())
- *     .addChecker(myChecker, args)
- *     .checkAll()
- */
-
-class preconditions$1 {
-  static appName;
-  static checkFunctions = [];
-  static checkPromises = [];
-
-  static setAppName(aName) {
-    ppUtil$3.configNeeded();
-    conf$2 = ppUtil$3.appConfig;
-    err$1 = ppUtil$3.appErrCfg;
-    preconditions$1.appName = aName || conf$2.thisApp;
-    return preconditions$1;
-  }
-
-  static addCheckPromise(p) {
-    preconditions$1.checkPromises.push(p);
-    return preconditions$1;
-  }
-
-  static addChecker(checkFunc, args, blocked) {
-    preconditions$1.checkFunctions.push({
-      check: checkFunc,
-      args: args,
-      blocked: blocked
-    });
-    return preconditions$1;
-  }
-
-  static pushMessage(msg) {
-    if (msg) {
-      if (!preconditions$1.messages) {
-        preconditions$1.messages = [];
-      }
-
-      preconditions$1.messages.push(`${preconditions$1.messages.length + 1}. ${msg}`);
-    }
-
-    return msg;
-  }
-
-  static async checkAll() {
-    try {
-      // for (let i = 0; i < preconditions.checkFunctions.length; i++) {
-      //     const f = preconditions.checkFunctions[i];
-      //     // preconditions.addCheckPromise(f.check(f.args));
-      //     preconditions.pushMessage(await f.check(f.args));
-      // }
-      while (preconditions$1.checkFunctions.length > 0) {
-        const f = preconditions$1.checkFunctions.shift();
-
-        if (preconditions$1.pushMessage(await f.check(f.args)) && f.blocked) {
-          break;
-        }
-      } // for (let i = 0; i < preconditions.checkPromises.length; i++) {
-      //     preconditions.pushMessage(await preconditions.checkPromises[i]);
-      // }
-
-
-      while (preconditions$1.checkPromises.length > 0) {
-        const p = preconditions$1.checkPromises.shift();
-        preconditions$1.pushMessage(await p);
-      }
-    } catch (e) {
-      preconditions$1.pushMessage(e.message);
-    }
-
-    let text = "";
-
-    if (preconditions$1.messages) {
-      text = `*** 由于以下原因，${preconditions$1.appName} 尚不能正常提供服务：\n\n` + preconditions$1.messages.join("\n\n") + "\n\n*** 请检查以上各项条件，修复后重新启动服务";
-      console.log("\n" + text); // for (let i = 0; i < preconditions.messages.length; i++) {
-      //     console.log(preconditions.messages[i]);
-      // }
+        res.set('WWW-Authenticate', `Basic realm=validate fail`);
+      }
+      return res.status(e.status || 500).send(e.error || e);
     }
+    next();
+  }
 
-    if (!(await fs.async_exists("../log"))) {
-      await fs.async_mkdir("../log");
-    }
+  //#endregion
 
-    await fs.async_writeFile(`../log/preconditions`, text);
-    return !text;
-  } // 检查器
+  //region ====一些通用服务功能
 
   /**
-   * 检查本机外部配置文件版本
+   * 获取配置数据
+   * @param options
+   * @returns {Promise<boolean|*>}
    */
-
-
-  static async checkExEnvSetting(loadjs) {
-    return await checkExEnvSetting(loadjs);
+  // api/config/appSetting.ossEnabled
+  static async getConfigValue(options) {
+    configNeeded();
+    const params = options.replacements;
+    let cfgItem = params._cfgItem;
+    delete params._cfgItem;
+    if (await apiUtil$2.checkForwardsHost(options)) return true;
+    let c = apiUtil$2.parseCfgPath(cfgItem);
+    delete c.parent;
+    c.host = ppUtil$3.getMyIp();
+    return c;
   }
-  /**
-   * redis 可用性检查
-   */
-
 
-  static async checkRedis() {
-    return await checkRedis();
-  }
   /**
-   * 初始化数据库连接
+   * 设置配置数据
+   * @param options
+   * @returns {Promise<*>}
    */
-
-
-  static async initDb() {
-    return await initDb();
+  static async setConfigValue(options) {
+    configNeeded();
+    const params = options.replacements;
+    let cfgItem = params._cfgItem;
+    delete params._cfgItem;
+    // if (await checkForwardsHost(options))
+    //     return true;
+    await apiUtil$2.parametersOK(params, "value");
+    let c = apiUtil$2.parseCfgPath(cfgItem);
+    if (typeof c.value === "object") {
+      throw [err$1.ACCESS_REFUSED, `暂不支持修改复杂配置`];
+    }
+    // c.oldValue = c.value;
+    c.newValue = params.value;
+    c.parent[c.key] = c.newValue;
+    delete c.parent;
+    c.host = ppUtil$3.getMyIp();
+    return c;
+    // 应用层自行处理多机同步
   }
+
   /**
-   * 初始化键值对存储器
+   * 修改重启标志文件
+   * 前提，PM2监视 restart,please.flag 文件，此文件若被修改则重启服务进程
+   * 此服务假设 restart,please.flag 文件最后一行是一个整数，此整数+1后保存
+   * @param options
+   * @returns {Promise<number>}
    */
-
-
-  static async initKvStorage(dbSql) {
-    return await initKvStorage(dbSql);
-  } // /**
-  //  * 数据库可用性及业务数据版本版本检查
-  //  */
-  // static async checkDatabase() {
-  //     return await checkDatabase();
-  // }
-
-
-}
-
-async function createEnvSettingFile(fileName, lastEnvSettingEx) {
-  try {
-    const cfgText = await ppUtil$3.doCreateEnvSettingFile(fileName, lastEnvSettingEx);
-
-    if (cfgText.indexOf(`cfgVersion: "${conf$2._envSetting.cfgVersion}"`) > 0) {
-      console.log(`\n*** 已創建新的本機環境配置文件\n${fileName}\n请檢查各項內容是否正确(此项更新服务可正常运行)\n\n`);
-      return "";
-    }
-
-    return `已創建新的本機環境配置文件\n${fileName}\n请檢查並正確設置各項內容，然後將配置版本號修改為${conf$2._envSettings.default.cfgVersion}`;
-  } catch (e) {
-    return `創建本機環境配置文件失敗\n《${fileName}》\n${err$1.ERROR(e).message}`;
+  static async updateRestartFlag(options) {
+    const fileName = `restart,please.flag`;
+    let text = await fs.async_readFile(fileName, 'utf8');
+    const lines = text.split('\r\n');
+    const n = +lines[lines.length - 1] + 1;
+    lines[lines.length - 1] = ' '.repeat(50) + n.toString();
+    text = lines.join('\r\n');
+    await fs.async_writeFile(fileName, text);
+    return n;
   }
-}
-
-async function checkExEnvSetting(loadjs) {
-  if (conf$2._envSetting.localSettingImported) return "";
-
-  try {
-    let fileName = conf$2.getEnvSettingFileName();
-
-    if (!fs.existsSync(fileName)) {
-      return await createEnvSettingFile(fileName);
-    }
-
-    let envSettingEx = loadjs(fileName);
-
-    if (envSettingEx.cfgVersion !== conf$2._envSettings.default.cfgVersion) {
-      if (envSettingEx.cfgVersion !== "0.0") {
-        let fp = path.parse(fileName);
-        let lastVerFileName = path.join(fp.dir, fp.name + envSettingEx.cfgVersion + fp.ext);
-
-        if (!fs.existsSync(lastVerFileName)) {
-          fs.renameSync(fileName, lastVerFileName);
-        }
-      }
-
-      let msg = await createEnvSettingFile(fileName, envSettingEx);
-
-      if (msg) {
-        return msg;
-      }
-
-      delete require.cache[fileName];
-    }
 
-    ppUtil$3.importExEnvSetting(conf$2._envSetting, fileName, loadjs);
-  } catch (e) {
-    return `导入本机环境配置失败\n${e.stack}`;
+  /**
+   * 创建验证码对象
+   * npm i svg-captcha
+   * npm i svg2png
+   */
+  static createSvgCaptcha(options) {
+    const captcha = svgCaptcha.create({
+      inverse: options.hasOwnProperty('inverse') ? options.inverse : false,
+      fontSize: options.fontSize || 48,
+      noise: options.noise || 2,
+      width: options.width || 150,
+      height: options.height || 75,
+      size: options.size || 4,
+      charPreset: options.charPreset || '0123456789',
+      ignoreChars: options.ignoreChars || '0oli',
+      color: options.hasOwnProperty('color') ? options.color : true,
+      background: options.background || '#cc9966'
+    });
+    return captcha;
   }
-} // async function checkDatabase() {
-//     return dbCheck.check().then(info => info.updateMessage);
-// }
-
-
-async function checkRedis() {
-  if (!conf$2.redis.enabled) return "";
-  const redis = ppRedis.newClient("kv"); // console.log(`checkRedis begin：`);
-
-  await ppUtil$3.wait(15 * 1000, param => {
-    if (redis.ready && redis.connected || redis.error) {
-      return true;
-    }
-  }).catch(e => {
-    redis.error = e;
-  });
-
-  if (redis.error) {
-    console.log(`未能成功連接 redis： ${redis.error}，請檢查相關設置`);
-    return `未能成功連接 redis： ${redis.error}，請檢查相關設置`;
-  } // console.log(`checkRedis done：`);
-  // console.log(redis);
-
-}
-
-async function initDb() {
-  try {
-    dbUtil.config(conf$2, err$1);
-  } catch (e) {
-    if (e.reason === 'bad decrypt') {
-      e = new Error(`解密数据库密码(${conf$2.dbconn.dbpwd})失败`);
-    } // if (e.reason === 'bad decrypt') {
-    //     e = new Error(`解密Redis密码(${conf.redis.password})失败`);
-    // }
-
 
-    return `初始化数据库连接失败(${e.message})`;
-  }
+  //#endregion
 }
-
-async function initKvStorage(dbSql) {
-  try {
-    kvStorage.config(conf$2, err$1);
-
-    if (conf$2.redis.enabled) {
-      kvStorage.setRedis(ppRedis.newClient("kv"));
-    } else {
-      kvStorage.setRedis(new redisSimulator(dbSql));
-    }
-  } catch (e) {
-    // if (e.reason === 'bad decrypt') {
-    //     e = new Error(`解密Redis密码(${conf.redis.password})失败`);
-    // }
-    return `初始化键值对存储器失败(${e.message})`;
+function configNeeded() {
+  if (!conf$2 || !err$1) {
+    ppUtil$3.configNeeded();
+    conf$2 = ppUtil$3.appConfig;
+    appSetting = conf$2.appSetting;
+    err$1 = ppUtil$3.appErrCfg;
   }
 }
+var ppUtilApi = apiUtil$2;
 
-var ppPrecond = preconditions$1;
-
+// 普通消息系统
 // 若 redis 可用，则使用基于 redis 的消息订阅发布系统
 // 若 redis 不可用，则将消息转发到其它主机
 
@@ -1844,49 +1644,39 @@ const {
 const RedisMessenger = require$$1__default$2["default"];
 const {
   netUtil
-} = require$$4__default["default"];
+} = require$$5__default["default"];
 let conf$1;
-
 class commonMessenger$2 {
   static myMsgAddr = "";
   static redisMessenger = null;
   static onMessage = [];
-
   static initMessenger(appConfig, appErrCfg, msgChannel) {
     conf$1 = appConfig;
     commonMessenger$2.redisMessenger = conf$1.redis.enabled ? new RedisMessenger(appConfig, appErrCfg, msgChannel).subscribe(msgChannel) : null;
     commonMessenger$2.myMsgAddr = commonMessenger$2.getMyMsgAddr();
   }
-
   static getMyMsgAddr() {
     if (!conf$1.myMsgAddr) {
       conf$1.pm_id = process.env.pm_id || "0";
       let myIp = ppUtil$2.getMyIp();
-
       if (commonMessenger$2.redisMessenger) {
         myIp = `${conf$1.pm_id}@${myIp}`;
       }
-
       conf$1.myMsgAddr = myIp;
       console.log(`myMsgAddr: `, conf$1.myMsgAddr);
     }
-
     return conf$1.myMsgAddr;
   }
-
-  static setMessageHandle(messageHandle) {
+  static setMessageHandle(messageHandle, msgChannel) {
     if (commonMessenger$2.redisMessenger) {
       return commonMessenger$2.redisMessenger.setMessageHandle(messageHandle, msgChannel);
     }
-
     if (commonMessenger$2.onMessage.indexOf(messageHandle) < 0) {
       commonMessenger$2.onMessage.push(messageHandle);
     }
-
     return commonMessenger$2;
   }
-
-  static async publishMessage(message) {
+  static async publishMessage(message, msgChannel) {
     if (commonMessenger$2.redisMessenger) {
       return commonMessenger$2.redisMessenger.publish(message, msgChannel);
     } else {
@@ -1896,7 +1686,6 @@ class commonMessenger$2 {
       } else {
         for (let i = 0; i < conf$1.appSetting.serverHosts.length; i++) {
           message.destAddr = conf$1.appSetting.serverHosts[i];
-
           if (message.destAddr !== conf$1.myMsgAddr) {
             await forwardMessage(message);
           }
@@ -1904,13 +1693,10 @@ class commonMessenger$2 {
       }
     }
   }
-
   static async handleInternalMessage(options) {
     const message = options.replacements;
-
     for (let i = 0; i < commonMessenger$2.onMessage.length; i++) {
       const appMsgHandle = commonMessenger$2.onMessage[i];
-
       try {
         await appMsgHandle(message);
       } catch (e) {
@@ -1918,12 +1704,10 @@ class commonMessenger$2 {
       }
     }
   }
-
 }
-
 async function forwardMessage(message) {
   let reqOptions = {
-    url: `https://${message.destAddr}:${appSetting.listenPort}/api/message`,
+    url: `https://${message.destAddr}:${conf$1.appSetting.listenPort}/api/message`,
     method: "POST",
     data: message
   };
@@ -1933,7 +1717,6 @@ async function forwardMessage(message) {
   });
   return res.data;
 }
-
 var ppMessengerEx = commonMessenger$2;
 
 /**
@@ -1947,11 +1730,11 @@ const {
 const apiUtil$1 = ppUtilApi;
 const commonMessenger$1 = ppMessengerEx;
 const MT_SCHEDULE_STATE = 'schedule-state',
-      MT_SCHEDULE_STATE_REPLY = 'schedule-state-reply';
+  MT_SCHEDULE_STATE_REPLY = 'schedule-state-reply';
 let conf, err;
-
 class schedule$1 {
   static tasks = {};
+
   /**
    * 注册一个计划任务
    * @param taskName
@@ -1961,18 +1744,15 @@ class schedule$1 {
    * @param autoStart
    * @returns {Promise<{}|{}|{cron: *, _message_: string}|any>}
    */
-
   static async registerTask(taskName, taskCaption, cronExp, taskFunc, autoStart) {
     if (!this.envAllowed()) return {};
     let task = this.findTask(taskName);
-
     if (task) {
       if (task.cronExp !== cronExp || task.taskFunc !== taskFunc) {
         this.stop(taskName);
         task = null;
       }
     }
-
     if (!task) {
       task = {
         name: taskName,
@@ -1989,17 +1769,13 @@ class schedule$1 {
         }
       };
       this.tasks[taskName] = task;
-
       if (autoStart) {
         return await this.start(task);
       }
-
       return this.getTaskInfo(task, "任务已注册。");
     }
-
     return this.getTaskInfo(task, "任务已存在。");
   }
-
   static getTaskInfo(task, msg) {
     // return Object.assign({_message_: msg}, task);
     return {
@@ -2010,75 +1786,62 @@ class schedule$1 {
       _message_: msg
     };
   }
+
   /**
    * 启动任务
    * @param taskOrName
    * @param cronExp
    * @returns {Promise<{}|{cron: *, _message_: string}>}
    */
-
-
   static async start(taskOrName, cronExp) {
     if (!this.envAllowed()) return {};
     let task = taskOrName;
-
     if (typeof task === "string") {
       task = this.findTask(taskOrName);
     }
-
     if (!task) throw [err.INVALID_PARAM, `任务${taskOrName}不存在`];
     cronExp = cronExp || task.cronExp;
-
     if (task.cronExp !== cronExp) {
       this.stop(task);
       task.cronExp = cronExp;
     }
-
     if (task.schedule) {
       return this.getTaskInfo(task, "任务已启动，无需重复启动。");
     }
-
     task.schedule = CRON.schedule(cronExp, task.doScheduleTask);
     task.schedule._task._pp_task = task;
     return this.getTaskInfo(task, "任务已启动。");
   }
+
   /**
    * 停止任务
    * @param taskOrName
    * @returns {Promise<{}|{cron: *, _message_: string}|{_message_: string}>}
    */
-
-
   static async stop(taskOrName) {
     if (!this.envAllowed()) return {};
     let task = taskOrName;
-
     if (typeof task === "string") {
       task = this.findTask(taskOrName);
     }
-
     if (!task) throw [err.INVALID_PARAM, `任务${taskOrName}不存在`];
-
     if (task.schedule) {
       task.schedule.stop();
       task.schedule = null;
       return this.getTaskInfo(task, "任务已停止。");
     }
-
     return this.getTaskInfo(task, "任务未启动，无需停止。");
   }
+
   /**
    * 获取或设置当前状态（来自远程的API调用）
    * @param options
    * @returns {Promise<unknown>}
    */
-
-
   static async state(options) {
-    const params = options.replacements; // await commonMessenger.parametersOK(params, "taskName");
-
+    const params = options.replacements;
+    // await commonMessenger.parametersOK(params, "taskName");
     const req = options._res.req;
-
     if (req) {
       if (req.method === 'GET') {
         delete params.state;
@@ -2086,16 +1849,15 @@ class schedule$1 {
         await apiUtil$1.parametersOK(params, 'taskName', "state");
       }
     }
-
     if (this.envAllowed()) {
       return this._state(params);
-    } // 环境变量启用计划任务，但当前环境不能执行，
+    }
+
+    // 环境变量启用计划任务，但当前环境不能执行，
     // 说明收到此API请求的进程不是第一个进程，或者此前服务器不是第一台服务器，
     // 这种情况下，将此请求作为消息发布出去，
     // 第一台服务器的第一个进程收到消息后进行处理，再将结果作为消息发布，
     // 本进程收到处理结果后果作为响应发送回客户端
-
-
     if (process.env.SCHEDULE_ENABLED) {
       let replyId = ppUtil$1.newGuid();
       return await new Promise((resolve, reject) => {
@@ -2105,7 +1867,6 @@ class schedule$1 {
             resolve(message.result);
             return;
           }
-
           if (message._type === MT_SCHEDULE_STATE) {
             if (schedule$1.enabled()) {
               message.result = schedule$1._state(message.params);
@@ -2131,21 +1892,17 @@ class schedule$1 {
         }, 2 * 60 * 1000);
       });
     }
-
     return {
       _message_: "此环境无自动任务"
     };
   }
-
   static async _state(params) {
     let apiResult = {};
     let task;
-
     if (params.taskName) {
       task = this.findTask(params.taskName);
       if (!task) throw [err.INVALID_PARAM, `任务${params.taskName}不存在`];
     }
-
     if (params.state) {
       if ("started" === params.state) {
         apiResult = await this.start(task, params.cron);
@@ -2154,62 +1911,52 @@ class schedule$1 {
       } else {
         throw [err.INVALID_PARAM, `(${params.state}), 只能是 started/stopped`];
       }
-
       if (params.runOnce) {
         task = this.findTask(params.taskName);
-        apiResult._message_ += "\n正在手动执行任务"; // await
-
+        apiResult._message_ += "\n正在手动执行任务";
+        // await
         task.doScheduleTask();
       }
-
       return this.getTaskInfo(task, apiResult._message_);
     }
-
     if (task) {
       return this.getTaskInfo(task);
     }
-
     const result = [];
-
     for (let k in this.tasks) {
       result.push(this.getTaskInfo(this.tasks[k]));
     }
-
     return result;
   }
-
   static deleteTask(taskName) {
     delete this.tasks[taskName];
   }
-
   static findTask(taskName) {
     return this.tasks[taskName];
   }
+
   /**
    * 确定当前进程环境是否启用自动任务
    */
-
-
   static envAllowed() {
     if (!conf) {
       ppUtil$1.configNeeded();
       conf = ppUtil$1.appConfig;
       err = ppUtil$1.appErrCfg;
     }
-
-    let enabled = // PM2配置中指定了环境变量 SCHEDULE_ENABLED
-    !!process.env.SCHEDULE_ENABLED // 如果PM2启动了多个进程，则只在第一个进程执行
-    && process.env.NODE_APP_INSTANCE === '0'; // // 如果有多台服务器，则只在第一台执行
+    let enabled =
+    // PM2配置中指定了环境变量 SCHEDULE_ENABLED
+    !!process.env.SCHEDULE_ENABLED
+    // 如果PM2启动了多个进程，则只在第一个进程执行
+    && process.env.NODE_APP_INSTANCE === '0';
+    // // 如果有多台服务器，则只在第一台执行
     // if (enabled && conf.appSetting.serverHosts && (conf.appSetting.serverHosts.length > 1)) {
     //     enabled = conf.myMsgAddr.indexOf(conf.appSetting.serverHosts[0]) === 0;
     // }
     // todo: 暂时取消此限制，要通过配置设定
-
     return enabled;
   }
-
 }
-
 var ppSchedule = schedule$1;
 
 const apiUtil = ppUtilApi;