abler-api 0.1.41 → 0.1.43

package/dist/es/pp-util.js

@@ -1,2017 +0,0 @@
-import require$$0 from 'crypto';
-import require$$1 from 'abler-util';
-import require$$2 from 'abler-db';
-import require$$3 from 'abler-net';
-import require$$4 from 'fs';
-import require$$1$1 from 'path';
-import require$$1$2 from 'abler-messenger';
-import require$$0$1 from 'node-cron';
-
-const crypto = require$$0;
-const ppUtil$4 = require$$1.ppUtil;
-const {
-  dbUtil,
-  kvStorage
-} = require$$2;
-const {
-  netUtil: netUtil$1
-} = require$$3;
-const fs$1 = require$$4;
-let conf$3, appSetting$1, err$2, 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;
-
-class apiUtil$2 {
-  static debugFlag = ppUtil$4.newGuid(); //应用必须设置，否则谁也不知道是啥
-
-  static testFlag = ppUtil$4.newGuid();
-  static envId_dev = "?"; // static apiCallRecSaver;
-
-  static config(appConfig, appErrCfg, appDbSql) {
-    ppUtil$4.config(appConfig, appErrCfg);
-    conf$3 = appConfig;
-    appSetting$1 = conf$3?.appSetting;
-    err$2 = appErrCfg, dbSql = appDbSql;
-    apiUtil$2.debugFlag = appSetting$1?.debugFlag || apiUtil$2.debugFlag;
-    apiUtil$2.testFlag = appSetting$1?.testFlag || apiUtil$2.testFlag; // apiUtil.apiCallRecSaver = apiCallRecSaver;
-  } //#region ===== 需要应用系统重写的方法
-
-  /**
-   * 根据机构标识获取机构的 ApiSecret
-   * @param companyId
-   * @returns {*}
-   */
-
-
-  static _getApiSecret(companyId) {
-    return ppUtil$4.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
-  //#region ===== API服务相关工具
-
-  /**
-   * 从请求中解出数据，包括路径参数、查询参数和Body
-   * @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];
-          }
-        } else {
-          req._requestParams = req.body;
-        }
-      } 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 {
-                obj[key] = JSON.parse(value);
-                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],
-      apiSecret: req.headers[hnApiSecret] || params[pnApiSecret],
-      clientIp: apiUtil$2.getClientIp(req)
-    };
-    return tokenData;
-  }
-  /**
-   * 为从传入请求中解出的参数对象设置一些函数属性，包括 asNumber, asBool
-   * @param params
-   */
-
-
-  static setParamsFunctions(params) {
-    ppUtil$4.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} 之间的数字`];
-      }
-
-      return result;
-    });
-    ppUtil$4.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);
-      res.redirect(redirectUrl);
-    } else {
-      res.send(data);
-    }
-  }
-  /**
-   * 生成 API 成功返回结果
-   * @param data
-   * @param req
-   * @returns {{datetime: Date, success: boolean, stateCode: number, message: string}}
-   */
-
-
-  static apiSuccess(data, req) {
-    let response = {
-      success: true,
-      stateCode: 0,
-      message: '',
-      datetime: new Date()
-    };
-
-    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) {
-    configNeeded();
-    let response = err$2.ERROR(error, err$2.errorLangParamFlag + ppUtil$4.getMsgLang(req));
-    response.datetime = new Date();
-
-    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) {
-        try {
-          response.send(data);
-        } catch (e) {
-          console.log(`response.send 出错了，req.url: ${response.req.url}, response：`, response);
-          console.log("异常信息", e);
-        }
-      }
-    }, function (error) {
-      console.log('ERROR:', error);
-
-      if (!response.finished) {
-        response.send(error);
-      }
-    });
-  }
-  /**
-   * API 服务结束，包装数据并发送响应
-   * @param response
-   * @param promise
-   */
-
-
-  static async responseOf(response, promise) {
-    promise.then(function (data) {
-      // console.log('RES:', apiSuccess(data));
-      if (!response.finished) response.send(apiUtil$2.apiSuccess(data, response.req));
-    }, function (error) {
-      console.log('ERROR:', error);
-      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: {}};
-
-    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
-        //     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.replacements = parameters; // if (arguments.length > 1) //其后的每个参数是要求必须存在的参数名称
-    // {
-    //     for(i=1; i<arguments.length; i++){
-    //         var paramName = arguments[i];
-    //         if (!qryOptions.replacements[paramName])
-    //             error();
-    //     }
-    // }
-
-    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) {
-    //     // 根据企业标识获取身份认证限制相关设置，如果没有传递企业标识，
-    //     // 则尝试从options.companyInfo或options.contractOrder中获取
-    //     Object.defineProperty(options, "companyId", {
-    //         get: function () {
-    //             var result;
-    //             if (this.companyInfo) {
-    //                 result = this.companyInfo.companyId;
-    //             } else if (this.contractOrder) {
-    //                 result = this.contractOrder.companyId;
-    //             } else if (this._companyId) {
-    //                 result = this._companyId;
-    //             }
-    //             return result;
-    //         }
-    //     });
-    //     Object.defineProperty(options, "identifyLimit", {
-    //         get: function () {
-    //             if (!this._identifyLimit) {
-    //                 // this._identifyLimit = ppUtil.waitPromise(_getIdentifyLimit(this.companyId));
-    //                 throw "options._identifyLimit 没有赋值";
-    //             }
-    //
-    //             return this._identifyLimit;
-    //         },
-    //         // configurable : true
-    //     });
-    // }
-    if (res) {
-      Object.defineProperty(options, '_res', {
-        value: res,
-        enumerable: false
-      });
-    }
-
-    return options;
-  }
-  /**
-   * 从请求头获取token
-   * @param req
-   * @param res
-   * @param noErr
-   * @returns {Promise<*>}
-   */
-
-
-  static extractToken(req, res, noErr) {
-    configNeeded();
-
-    if (!req.accessToken) {
-      //检查post的信息或者url查询参数或者头信息
-      let 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);
-
-          if (res) {
-            res.send(err$2.ERROR(err$2.TOKEN_NEEDED));
-          } else if (!noErr) {
-            throw err$2.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.idNumDisturbing)) {
-      //todo: 检查IP
-      params.__internal__ = true;
-      req.ignoreToken = true; // if (params.idNum || params.personId) {
-      //     return queryPersonUser(params.idNum, params.personId)
-      //         .then(async userInfo => {
-      //             if (!userInfo) {
-      //                 // console.log('queryPersonUser error.', e);
-      //                 throw err.TOKEN_INVALID;
-      //             }
-      //             if (req.tokenValidater) await req.tokenValidater(userInfo, req)
-      //             req.userInfo = userInfo;
-      //             return true
-      //         })
-      // } else {
-      //     return true
-      // }
-
-      return true;
-    } else {
-      // console.log('token error.', req.accessToken);
-      throw err$2.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);
-    const expireTime = apiUtil$2.tokenExpireTime(req);
-    return await apiUtil$2.restoreTokenData(tokenKey, expireTime).then(async function (data) {
-      req.userInfo = apiUtil$2.setUserIdNo(data, data._idNo);
-      if (req.tokenValidater) await req.tokenValidater(req.userInfo, req);
-      return true;
-    }, async function (e) {
-      // 如果给定的token不存在，看看是不是平台内部调用
-      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");
-      } else {
-        req.__debug__ = false;
-      } // console.log("__debug__:", req.__debug__, "dbgToken:", dbgToken);
-
-    }
-
-    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);
-        req.__postman__ = dbgToken === testToken && (envId.indexOf("myfacesign.com") < 0 || envId.indexOf(".dev.") > 0);
-      } else {
-        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;
-  }
-  /**
-   * 获取用户令牌保存键
-   * @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
-   * @param tokenData
-   * @param dataId
-   * @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;
-    }
-
-    kvStorage.storeObj(token, tokenData, timeout);
-
-    if (dataId) {
-      kvStorage.restoreValue("token_" + dataId).then(function (oldToken) {
-        if (oldToken !== token) {
-          kvStorage.unstoreValue(oldToken);
-        } else {
-          dataId = "";
-        }
-      }, function (e) {}).then(() => {
-        if (dataId !== "") kvStorage.storeValue("token_" + dataId, token, timeout);
-      });
-    }
-  }
-  /**
-   * 恢复令牌数据
-   * @param accessToken
-   * @param expireTime
-   * @returns {Promise<any>}
-   */
-
-
-  static async restoreTokenData(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 dbQueryOne(dbSql.loadApiUsage, {
-          replacements: {
-            id: req.apiCallRecId
-          }
-        }).then(rec => {
-          req.apiCallRec = rec;
-          return req.apiCallRec;
-        });
-      } else {
-        let params = extractParams(req); // let contentLength = parseInt(req.headers["content-length"]) || 0;
-
-        let rec = {
-          id: newGuid(),
-          companyId: tokenData.apiKey || '',
-          orderId: params.orderId || '',
-          signerId: params.signerId || '',
-          userId: params.userId || '',
-          contractName: params.contractName || '',
-          spOrderNum: params.spOrderNum || '',
-          notifyUri: params.notifyUri || '',
-          fileName: params.fileName || '',
-          fileHash: params.fileHash || '',
-          fileKeyHash: params.fileKeyHash || '',
-          fileSignedHash: params.fileSignedHash || '',
-          createTime: new Date(),
-          secret: tokenData.apiSecret || '',
-          fromIp: tokenData.clientIp || '',
-          method: req.method,
-          uri: req.route.path,
-          urlParams: req.url.split("?")[1] || "",
-          contentType: (req.headers["content-type"] || '').substring(0, 45),
-          // body: contentLength < 500 ? req.rawBody || '' : 'lob data, size:' + contentLength,
-          body: _getBodyLogStr(req),
-          resultCode: params.resultCode || '0',
-          resultInfo: params.resultInfo || '',
-          resultData: params.resultData || ''
-        };
-
-        if (rec.secret !== "") {
-          rec.secret = ppUtil$4.getEncAse192(rec.secret);
-        }
-
-        req.apiCallRec = rec;
-      }
-    }
-
-    return req.apiCallRec;
-  }
-  /**
-   * 查询机构信息
-   * @param companyId
-   * @param nullable
-   * @returns {Promise<null|*>}
-   */
-
-
-  static async queryCompanyInfo(companyId, nullable) {
-    return await dbUtil.dbQueryOne(dbSql.queryCompanyInfo, {
-      companyId
-    }, nullable);
-  }
-  /**
-   * 获取企业有效证书
-   * @param companyId: 企业标识
-   */
-
-
-  static async getCompanyCertificate(companyId) {
-    let certInfo = {
-      // 正式启用的证书
-      certLiving: null,
-      certLivingId: '',
-      // 备用证书
-      certSpare: null,
-      certSpareId: ''
-    };
-    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(); // 公司正式证书
-
-      certInfo.certLiving = pubKeyData;
-      certInfo.certLivingId = certRec.id;
-      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(); // 公司备用证书
-
-        certInfo.certSpare = pubKeyData1;
-        certInfo.certSpareId = certRec1.id;
-      }).catch(e => {
-        // console.log('获取备用证书失败。', e);
-        certInfo.certSpare = null;
-      });
-    }).then(() => {
-      return certInfo;
-    }).catch(e => {
-      console.log('获取企业证书失败:\n', e);
-      throw [err$2.ACCESS_REFUSED, `获取企业证书失败：${err$2.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, `必须在请求头中设置时戳`];
-      }
-
-      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}秒`];
-      }
-
-      let signature = req.headers.signature;
-
-      if (!signature) {
-        throw [err$2.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;
-        tokenData.certLivingId = info.certLivingId;
-        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);
-        }
-      }).then(() => {
-        return doVerify(signData, signature, tokenData.certPublicKey);
-      });
-    } catch (e) {
-      // 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,
-            msgArgv: "签名验证异常",
-            data: e
-          };
-        }
-      }
-
-      if (!verifyOK && tokenData.certPublicKeySpare) {
-        try {
-          // 再用备用证书验证
-          let verifySpare = crypto.createVerify('SHA256');
-          verifySpare.write(signData);
-          verifySpare.end();
-          verifyOK = verifySpare.verify(tokenData.certPublicKeySpare, signature, 'base64');
-
-          if (verifyOK) {
-            // 备用证书验证成功了，则将备用证书替换为正式证书
-            console.log(`公司(${tokenData.apiKey})备用证书验签成功，正式启用...`);
-            return dbUtil.dbTrans(trans => {
-              let p1 = dbUtil.dbExec(dbSql.deleteCertRecById, {
-                replacements: {
-                  id: tokenData.certLivingId
-                },
-                transaction: trans
-              });
-              let p2 = dbUtil.dbExec(dbSql.spareCertToLiving, {
-                replacements: {
-                  id: tokenData.certSpareId
-                },
-                transaction: trans
-              });
-              return Promise.all([p1, p2]);
-            }).then(() => {
-              tokenData.certPublicKey = tokenData.certPublicKeySpare;
-              delete tokenData.certLivingId;
-              delete tokenData.certSpareId;
-              delete tokenData.certPublicKeySpare;
-              let token = apiUtil$2.extractToken(req);
-
-              if (token) {
-                apiUtil$2.storeToken(apiTokenStoreKey(token), tokenData, tokenData.apiKey, req);
-              }
-
-              console.log(`公司(${tokenData.apiKey})备用证书成功转换为正式证书`);
-            });
-          }
-        } catch (e) {
-          console.log("SPO服务签名验证异常(备用证书), ", e);
-          throw {
-            eo: err$2.ACCESS_REFUSED,
-            msgArgv: "签名验证异常(spare)",
-            data: e
-          };
-        }
-      }
-
-      if (!verifyOK) {
-        console.log("SPO服务签名验证失败, tokenData: ", tokenData);
-        throw [err$2.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 || ""];
-      });
-    }
-
-    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 白名单，改为验证证书签名
-      // 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()) return companyInfo;
-      return apiUtil$2.verifyApiSignature(tokenData, req).then(x => {
-        return companyInfo;
-      }, e => {
-        throw e;
-      });
-    }
-
-    throw [err$2.API_KEY_INVALID, tokenData.apiKey];
-  }
-  /**
-   * 检查令牌数据是否存在
-   * @param token
-   * @returns {*}
-   */
-
-
-  static tokenDataExist(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]]) {
-        //     paramExists = true;
-        // } else {
-        //     if (params[names[1]]) {
-        //         paramExists = true;
-        //         params[names[0]] = params[names[1]];
-        //         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));
-    }
-
-    return Promise.resolve(paramSufix);
-  }
-  /**
-   * 获取客户端IP地址
-   * @param req
-   * @returns {*|string|string}
-   */
-
-
-  static getClientIp(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);
-    }
-
-    return ip;
-  }
-  /**
-   * 获取与本机一起提供服务的所有主机
-   * @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
-    };
-  }
-  /**
-   * 检查指定的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({
-        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 host = params.host || myIp;
-    if (!myEnvHosts.hosts.contains(host)) throw [err$2.ACCESS_REFUSED, `环境${conf$3.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
-   * @param port
-   * @param params
-   * @param req
-   * @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}`];
-    }
-
-    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 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}`];
-      }
-    }
-
-    return {
-      parent,
-      parentKey,
-      key,
-      value
-    };
-  } //#endregion
-  //region ====中间件
-
-  /**
-   * 检查令牌，若存在则将其的用户信息置入req，否则返回错误信息
-   */
-
-
-  static async $checkToken(req, res, next) {
-    try {
-      await apiUtil$2.checkRequestToken(req);
-      await next();
-    } catch (e) {
-      res.send(err$2.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) {
-            //     // 如果没有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
-        });
-      }
-
-      return true;
-    } catch (e) {
-      res.send(err$2.ERROR(e));
-      return false;
-    }
-  }
-  /**
-   * 标识此请求已经完成了签名验证或者无需进行签名验证
-   */
-
-
-  static $signatureVerified(req, res, next) {
-    req.signatureVerified = true;
-    return true;
-  }
-  /**
-   * 标识此请求是从前端发过来的，比如移动端、PC浏览器等，区别于SPO一般的服务端后台请求。
-   * 如果在请求参数中包含有签名参数，则将其移到请求头中
-   */
-
-
-  static $isMobile(req, res, next) {
-    req.isMobile = true;
-
-    if (!req.signatureVerified) {
-      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查询参数或者头信息
-    let tokenData = apiUtil$2.extractTokenData(req);
-    let 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);
-    } else if (!tokenData.apiKey) {
-      errResponse = apiUtil$2.spoApiFail([err$2.PARAMETER_NEEDED, "apiKey"], req);
-    } else if (!tokenData.apiSecret) {
-      errResponse = apiUtil$2.spoApiFail([err$2.PARAMETER_NEEDED, "apiSecret"], req);
-    }
-
-    if (errResponse != null) {
-      apiUtil$2._saveApiCallRec(req.apiCallRec, errResponse);
-
-      apiUtil$2.sendOrRedirect(req, res, errResponse);
-    } else {
-      apiUtil$2.checkApiCallValid(tokenData, req).then(companyInfo => {
-        params.companyId = params.companyId || companyInfo.companyId;
-        req.companyInfo = companyInfo;
-        next();
-      }, e => {
-        console.log('apiCallInvalid:', e);
-        let errResponse = spoApiFail(e, req);
-
-        apiUtil$2._saveApiCallRec(req.apiCallRec, errResponse);
-
-        apiUtil$2.sendOrRedirect(req, res, 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));
-
-      return;
-    }
-
-    apiUtil$2.restoreTokenData(apiUtil$2.apiTokenStoreKey(accessToken)).then(p => {
-      // req.headers[hnApiKey] = p.apiKey || '';
-      // req.headers[hnApiSecret] = p.apiSecret || '';
-      if (req.isMobile) {
-        // GET 请求的应该都是H5页面，由手机前端发起，需要把headers中的请求方ip换成服务端的
-        // todo: 如何在API访问记录中记住请求者（手机端）的真实IP
-        req.headers['x-phone-ip'] = apiUtil$2.getClientIp(req);
-        req.headers['x-real-ip'] = p.clientIp;
-      } else {
-        p.clientIp = apiUtil$2.getClientIp(req);
-      }
-
-      req.isApiCall = true;
-      req.tokenData = p;
-      return apiUtil$2.$checkApiKeyOld(req, res, next);
-    }).catch(e => {
-      apiUtil$2.sendOrRedirect(req, res, apiUtil$2.spoApiFail(err$2.TOKEN_INVALID, req));
-    });
-  }
-  /**
-   * 检查请求令牌，允许个人用户令牌和机构令牌，若不存在或不合法，则返回错误信息
-   * @param req
-   * @param res
-   * @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不存在，看看是不是平台内部调用
-
-
-      return await apiUtil$2.checkInternalToken(req).catch(e => {
-        res.send(apiUtil$2.apiFail(e, req));
-        return false;
-      });
-    }
-  } //#endregion
-  //region ====一些通用服务功能
-
-  /**
-   * 获取配置数据
-   * @param options
-   * @returns {Promise<boolean|*>}
-   */
-  // api/config/appSetting.ossEnabled
-
-
-  static async getConfigValue(options) {
-    configNeeded();
-    const params = options.replacements;
-    let item = params.item;
-    delete params.item;
-    if (await apiUtil$2.checkForwardsHost(options)) return true;
-    let c = apiUtil$2.parseCfgPath(item);
-    delete c.parent;
-    c.host = ppUtil$4.getMyIp();
-    return c;
-  }
-  /**
-   * 设置配置数据
-   * @param options
-   * @returns {Promise<*>}
-   */
-
-
-  static async setConfigValue(options) {
-    configNeeded();
-    const params = options.replacements;
-    let item = params.item;
-    delete params.item; // if (await checkForwardsHost(options))
-    //     return true;
-
-    await apiUtil$2.parametersOK(params, "value");
-    let c = apiUtil$2.parseCfgPath(item);
-
-    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;
-  } //#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$$4;
-const path = require$$1$1;
-const ppUtil$3 = require$$1.ppUtil;
-const ppRedis = require$$2.ppRedis;
-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) {
-    preconditions$1.checkFunctions.push({
-      check: checkFunc,
-      args: args
-    });
-    return preconditions$1;
-  }
-
-  static async checkAll() {
-    for (let i = 0; i < preconditions$1.checkFunctions.length; i++) {
-      const f = preconditions$1.checkFunctions[i];
-      preconditions$1.addCheckPromise(f.check(f.args));
-    }
-
-    for (let i = 0; i < preconditions$1.checkPromises.length; i++) {
-      let msg = await preconditions$1.checkPromises[i];
-
-      if (msg) {
-        if (!preconditions$1.messages) {
-          preconditions$1.messages = [];
-        }
-
-        preconditions$1.messages.push(`${preconditions$1.messages.length + 1}. ${msg}`);
-      }
-    }
-
-    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]);
-      // }
-    }
-
-    if (!(await fs.async_exists("../log"))) {
-      await fs.async_mkdir("../log");
-    }
-
-    await fs.async_writeFile(`../log/preconditions`, text);
-    return !text;
-  } // 检查器
-
-  /**
-   * 检查本机外部配置文件版本
-   */
-
-
-  static async checkExEnvSetting(loadjs) {
-    return await checkExEnvSetting(loadjs);
-  }
-  /**
-   * redis 可用性检查
-   */
-
-
-  static async checkRedis() {
-    return await checkRedis();
-  } // /**
-  //  * 数据库可用性及业务数据版本版本检查
-  //  */
-  // 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}`;
-  }
-}
-
-async function checkExEnvSetting(loadjs) {
-  if (!conf$2._envSetting.localSettingImported) {
-    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) {
-        delete require.cache[fileName];
-        ppUtil$3.importExEnvSetting(conf$2._envSetting, fileName, loadjs);
-      }
-
-      return msg;
-    }
-  }
-} // 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);
-
-}
-
-var ppPrecond = preconditions$1;
-
-// 若 redis 可用，则使用基于 redis 的消息订阅发布系统
-// 若 redis 不可用，则将消息转发到其它主机
-
-const {
-  ppUtil: ppUtil$2
-} = require$$1;
-const RedisMessenger = require$$1$2;
-const {
-  netUtil
-} = require$$3;
-let conf$1;
-
-class commonMessenger$2 {
-  static myMsgAddr = "";
-  static redisMessenger = null;
-  static onMessage = [];
-
-  static initMessenger(appConfig, appErrCfg, msgChannel) {
-    conf$1 = appConfig;
-    this.redisMessenger = conf$1.redis.enabled ? new RedisMessenger(appConfig, appErrCfg, msgChannel).subscribe(msgChannel) : null;
-    this.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 (this.redisMessenger) {
-        myIp = `${conf$1.pm_id}@${myIp}`;
-      }
-
-      conf$1.myMsgAddr = myIp;
-      console.log(`myMsgAddr: `, conf$1.myMsgAddr);
-    }
-
-    return conf$1.myMsgAddr;
-  }
-
-  static setMessageHandle(messageHandle) {
-    if (this.redisMessenger) {
-      return this.redisMessenger.setMessageHandle(messageHandle, msgChannel);
-    }
-
-    if (commonMessenger$2.onMessage.indexOf(messageHandle) < 0) {
-      commonMessenger$2.onMessage.push(messageHandle);
-    }
-
-    return commonMessenger$2;
-  }
-
-  static async publishMessage(message) {
-    if (this.redisMessenger) {
-      return this.redisMessenger.publish(message, msgChannel);
-    } else {
-      //没有消息处理器，则将消息转发到目标地址（不支持pm2多进程）
-      if (message.destAddr) {
-        await forwardMessage(message);
-      } 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);
-          }
-        }
-      }
-    }
-  }
-
-  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) {
-        console.log(e);
-      }
-    }
-  }
-
-}
-
-async function forwardMessage(message) {
-  let reqOptions = {
-    url: `https://${message.destAddr}:${appSetting.listenPort}/api/message`,
-    method: "POST",
-    data: message
-  };
-  let res = await netUtil.apiRequest(reqOptions).catch(e => {
-    console.log(`转发消息失败, url: ${reqOptions.url}`, e);
-    throw e;
-  });
-  return res.data;
-}
-
-var ppMessengerEx = commonMessenger$2;
-
-/**
- * CSCA 自动任务
- * ==============
- */
-const CRON = require$$0$1;
-const {
-  ppUtil: ppUtil$1
-} = require$$1;
-const apiUtil$1 = ppUtilApi;
-const commonMessenger$1 = ppMessengerEx;
-const MT_SCHEDULE_STATE = 'schedule-state',
-      MT_SCHEDULE_STATE_REPLY = 'schedule-state-reply';
-let conf, err;
-
-class schedule$1 {
-  static tasks = {};
-  /**
-   * 注册一个计划任务
-   * @param taskName
-   * @param taskCaption
-   * @param cronExp
-   * @param taskFunc
-   * @param autoStart
-   * @returns {Promise<{}|{}|{cron: *, _message_: string}|any>}
-   */
-
-  static async registerTask(taskName, taskCaption, cronExp, taskFunc, autoStart) {
-    if (!conf) {
-      ppUtil$1.configNeeded();
-      conf = ppUtil$1.appConfig;
-      err = ppUtil$1.appErrCfg;
-    }
-
-    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,
-        caption: taskCaption,
-        cronExp: cronExp,
-        taskFunc: taskFunc,
-        schedule: null,
-        doScheduleTask: async function () {
-          let self = this;
-          if (this._pp_task) self = this._pp_task;
-          console.log(new Date().format('[yyyy/MM/dd hh:mm:ss:S]'), `开始执行${self.caption}任务 ...`);
-          await self.taskFunc();
-          console.log(new Date().format('[yyyy/MM/dd hh:mm:ss:S]'), `${self.caption}任务执行结束`);
-        }
-      };
-      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 {
-      name: task.name,
-      caption: task.caption,
-      cronExp: task.cronExp,
-      state: task.schedule ? "started" : "stopped",
-      _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 req = options._res.req;
-
-    if (req) {
-      if (req.method === 'GET') {
-        delete params.state;
-      } else {
-        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) => {
-        commonMessenger$1.setMessageHandle(message => {
-          if (message._type === MT_SCHEDULE_STATE_REPLY && message.replyId === replyId) {
-            replyId = '';
-            resolve(message.result);
-            return;
-          }
-
-          if (message._type === MT_SCHEDULE_STATE) {
-            if (schedule$1.enabled()) {
-              message.result = schedule$1._state(message.params);
-              message._type = MT_SCHEDULE_STATE_REPLY;
-              message.destAddr = message.replyAddr;
-              commonMessenger$1.publishMessage(message);
-            }
-          }
-        });
-        commonMessenger$1.publishMessage({
-          _type: MT_SCHEDULE_STATE,
-          replyId,
-          replyAddr: conf.myMsgAddr,
-          params
-        }).catch(e => {
-          replyId = '';
-          reject(e);
-        });
-        setTimeout(() => {
-          if (replyId) {
-            reject("schedule.state: 等待处理结果超时");
-          }
-        }, 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);
-      } else if ("stopped" === params.state) {
-        apiResult = await this.stop(task);
-      } else {
-        throw [err.INVALID_PARAM, `(${params.state}), 只能是 started/stopped`];
-      }
-
-      if (params.runOnce) {
-        task = this.findTask(params.taskName);
-        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() {
-    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;
-    }
-
-    return enabled;
-  }
-
-}
-
-var ppSchedule = schedule$1;
-
-const apiUtil = ppUtilApi;
-const preconditions = ppPrecond;
-const commonMessenger = ppMessengerEx;
-const schedule = ppSchedule;
-var ppUtil = {
-  apiUtil,
-  preconditions,
-  commonMessenger,
-  schedule
-};
-
-export { ppUtil as default };