abler-api 0.1.27 → 0.1.28

package/dist/cjs/pp-util.js

@@ -7,6 +7,7 @@ var require$$3 = require('abler-net');
 var require$$0$1 = require('fs');
 var require$$1$1 = require('path');
 var require$$1$2 = require('abler-messenger');
+var require$$0$2 = require('node-cron');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -17,15 +18,16 @@ var require$$3__default = /*#__PURE__*/_interopDefaultLegacy(require$$3);
 var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
 var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
 var require$$1__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$1$2);
+var require$$0__default$2 = /*#__PURE__*/_interopDefaultLegacy(require$$0$2);
 
 const crypto = require$$0__default["default"];
-const ppUtil$3 = require$$1__default["default"].ppUtil;
+const ppUtil$4 = require$$1__default["default"].ppUtil;
 const {
   dbUtil,
   kvStorage
 } = require$$2__default["default"];
 const netUtil$1 = require$$3__default["default"];
-let conf$2, appSetting$1, err$1, dbSql;
+let conf$3, appSetting$1, err$2, dbSql;
 const pnToken = "access_token",
       hnToken = pnToken,
       pnApiKey = "apiKey",
@@ -33,22 +35,22 @@ const pnToken = "access_token",
       // 我们接收到的 headers 中的字段名总是全小写的
 pnApiSecret = "apiSecret",
       hnApiSecret = pnApiSecret.toLowerCase();
-const MD5 = ppUtil$3.MD5,
-      moveProperty = ppUtil$3.moveProperty;
+const MD5 = ppUtil$4.MD5,
+      moveProperty = ppUtil$4.moveProperty;
 
-class apiUtil$1 {
-  static debugFlag = ppUtil$3.newGuid(); //应用必须设置，否则谁也不知道是啥
+class apiUtil$2 {
+  static debugFlag = ppUtil$4.newGuid(); //应用必须设置，否则谁也不知道是啥
 
-  static testFlag = ppUtil$3.newGuid();
+  static testFlag = ppUtil$4.newGuid();
   static envId_dev = "?"; // static apiCallRecSaver;
 
   static config(appConfig, appErrCfg, appDbSql) {
-    ppUtil$3.config(appConfig, appErrCfg);
-    conf$2 = appConfig;
-    appSetting$1 = conf$2?.appSetting;
-    err$1 = appErrCfg, dbSql = appDbSql;
-    apiUtil$1.debugFlag = appSetting$1?.debugFlag || apiUtil$1.debugFlag;
-    apiUtil$1.testFlag = appSetting$1?.testFlag || apiUtil$1.testFlag; // apiUtil.apiCallRecSaver = apiCallRecSaver;
+    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 ===== 需要应用系统重写的方法
 
   /**
@@ -59,7 +61,7 @@ class apiUtil$1 {
 
 
   static _getApiSecret(companyId) {
-    return ppUtil$3.newGuid();
+    return ppUtil$4.newGuid();
   }
   /**
    * 保存 API 调用记录,应用系统必须重写此方法
@@ -136,7 +138,7 @@ class apiUtil$1 {
         req._requestParams = Object.assign(req.params, req._requestParams);
       }
 
-      apiUtil$1.setParamsFunctions(req._requestParams);
+      apiUtil$2.setParamsFunctions(req._requestParams);
     }
 
     return req._requestParams;
@@ -147,11 +149,11 @@ class apiUtil$1 {
       return req.tokenData;
     }
 
-    let params = apiUtil$1.extractParams(req);
+    let params = apiUtil$2.extractParams(req);
     let tokenData = {
       apiKey: req.headers[hnApiKey] || params[pnApiKey],
       apiSecret: req.headers[hnApiSecret] || params[pnApiSecret],
-      clientIp: apiUtil$1.getClientIp(req)
+      clientIp: apiUtil$2.getClientIp(req)
     };
     return tokenData;
   }
@@ -162,18 +164,18 @@ class apiUtil$1 {
 
 
   static setParamsFunctions(params) {
-    ppUtil$3.defUnenumProp(params, "asNumber", function (name, minValue, maxValue, defaultValue) {
+    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$1.INVALID_PARAM, `参数 ${name} 必须是 ${minValue} ~ ${maxValue} 之间的数字`];
+        throw [err$2.INVALID_PARAM, `参数 ${name} 必须是 ${minValue} ~ ${maxValue} 之间的数字`];
       }
 
       return result;
     });
-    ppUtil$3.defUnenumProp(params, "asBool", function (name, defaultValue) {
+    ppUtil$4.defUnenumProp(params, "asBool", function (name, defaultValue) {
       if (this[name] === undefined) return defaultValue;
       let result = JSON.parse(this[name]);
       return !!result;
@@ -238,7 +240,7 @@ class apiUtil$1 {
 
   static apiFail(error, req) {
     configNeeded();
-    let response = err$1.ERROR(error, err$1.errorLangParamFlag + ppUtil$3.getMsgLang(req));
+    let response = err$2.ERROR(error, err$2.errorLangParamFlag + ppUtil$4.getMsgLang(req));
     response.datetime = new Date();
 
     if (req && req.headers) {
@@ -260,8 +262,8 @@ class apiUtil$1 {
 
 
   static spoApiSucc(data, req) {
-    let params = apiUtil$1.extractParams(req);
-    return apiUtil$1.apiSuccess(data, req, params.spOrderNum);
+    let params = apiUtil$2.extractParams(req);
+    return apiUtil$2.apiSuccess(data, req, params.spOrderNum);
   }
   /**
    * 生成面向服务商的API失败返回结果
@@ -272,8 +274,8 @@ class apiUtil$1 {
 
 
   static spoApiFail(error, req) {
-    let params = apiUtil$1.extractParams(req);
-    return apiUtil$1.apiFail(error, req, params.spOrderNum);
+    let params = apiUtil$2.extractParams(req);
+    return apiUtil$2.apiFail(error, req, params.spOrderNum);
   }
   /**
    * API 服务结束，发送响应
@@ -310,10 +312,10 @@ class apiUtil$1 {
   static async responseOf(response, promise) {
     promise.then(function (data) {
       // console.log('RES:', apiSuccess(data));
-      if (!response.finished) response.send(apiUtil$1.apiSuccess(data, response.req));
+      if (!response.finished) response.send(apiUtil$2.apiSuccess(data, response.req));
     }, function (error) {
       console.log('ERROR:', error);
-      if (!response.finished) response.send(apiUtil$1.apiFail(error, response.req));
+      if (!response.finished) response.send(apiUtil$2.apiFail(error, response.req));
     });
   }
   /**
@@ -325,16 +327,16 @@ class apiUtil$1 {
 
   static async spoApiResponse(response, promise) {
     promise.then(function (result) {
-      let responseData = apiUtil$1.spoApiSucc(result, response.req);
+      let responseData = apiUtil$2.spoApiSucc(result, response.req);
 
-      apiUtil$1._saveApiCallRec(response.req.apiCallRec, responseData);
+      apiUtil$2._saveApiCallRec(response.req.apiCallRec, responseData);
 
       if (!response.finished) response.send(responseData);
     }, function (error) {
       console.log('ERROR:', error);
-      let responseData = apiUtil$1.spoApiFail(error, response.req);
+      let responseData = apiUtil$2.spoApiFail(error, response.req);
 
-      apiUtil$1._saveApiCallRec(response.req.apiCallRec, responseData);
+      apiUtil$2._saveApiCallRec(response.req.apiCallRec, responseData);
 
       if (!response.finished) response.send(responseData);
     });
@@ -351,7 +353,7 @@ class apiUtil$1 {
     req.headers.timestamp = new Date().valueOf(); // let options = {replacements: {}};
 
     let options = {};
-    let parameters = apiUtil$1.extractParams(req);
+    let parameters = apiUtil$2.extractParams(req);
 
     for (let qryParam in parameters) {
       if (qryParam !== 'token') {
@@ -383,7 +385,7 @@ class apiUtil$1 {
     // }
 
     options.userInfo = req.userInfo;
-    return apiUtil$1.setOptionsPropFuncions(options, res);
+    return apiUtil$2.setOptionsPropFuncions(options, res);
   }
   /**
    * 为API请求 options 设置属性
@@ -448,7 +450,7 @@ class apiUtil$1 {
       let token = req.headers[hnToken] || req.headers['x-access-token']; //向后兼容
 
       if (!token) {
-        let params = apiUtil$1.extractParams(req);
+        let params = apiUtil$2.extractParams(req);
         token = params[pnToken];
 
         if (token) {
@@ -459,12 +461,12 @@ class apiUtil$1 {
           delete params.token;
         } else {
           // 如果没有token，则返回错误
-          console.log(err$1.TOKEN_NEEDED);
+          console.log(err$2.TOKEN_NEEDED);
 
           if (res) {
-            res.send(err$1.ERROR(err$1.TOKEN_NEEDED));
+            res.send(err$2.ERROR(err$2.TOKEN_NEEDED));
           } else if (!noErr) {
-            throw err$1.TOKEN_NEEDED;
+            throw err$2.TOKEN_NEEDED;
           }
         }
       }
@@ -483,10 +485,10 @@ class apiUtil$1 {
 
   static async checkInternalToken(req) {
     // return await checkInternalToken(req);
-    const params = apiUtil$1.extractParams(req);
-    req.accessToken = req.accessToken || apiUtil$1.extractToken(req);
+    const params = apiUtil$2.extractParams(req);
+    req.accessToken = req.accessToken || apiUtil$2.extractToken(req);
 
-    if (req.accessToken === MD5(ppUtil$3.idNumDisturbing)) {
+    if (req.accessToken === MD5(ppUtil$4.idNumDisturbing)) {
       //todo: 检查IP
       params.__internal__ = true;
       req.ignoreToken = true; // if (params.idNum || params.personId) {
@@ -507,7 +509,7 @@ class apiUtil$1 {
       return true;
     } else {
       // console.log('token error.', req.accessToken);
-      throw err$1.TOKEN_INVALID;
+      throw err$2.TOKEN_INVALID;
     }
   }
   /**
@@ -518,16 +520,16 @@ class apiUtil$1 {
 
 
   static async checkRequestToken(req) {
-    req.accessToken = req.accessToken || apiUtil$1.extractToken(req);
-    const tokenKey = apiUtil$1.userTokenStoreKey(req.accessToken);
-    const expireTime = apiUtil$1.tokenExpireTime(req);
-    return await apiUtil$1.restoreTokenData(tokenKey, expireTime).then(async function (data) {
-      req.userInfo = apiUtil$1.setUserIdNo(data, data._idNo);
+    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$1.checkInternalToken(req);
+      return await apiUtil$2.checkInternalToken(req);
     });
   }
   /**
@@ -539,11 +541,11 @@ class apiUtil$1 {
 
   static isDebugMode(req) {
     if (req.__debug__ === undefined) {
-      let dbgToken = req.headers['__debug__'] || req.headers[apiUtil$1.debugFlag];
+      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$3.commonHashDisturbing) && (envId === "florist_longdan" || envId === "shuzi");
+        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);
@@ -561,11 +563,11 @@ class apiUtil$1 {
 
   static isTestMode(req) {
     if (req.__postman__ === undefined) {
-      let dbgToken = req.headers["__postman__"] || req.headers[apiUtil$1.testFlag];
+      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$1.extractToken(req, null, true) || req.headers.apikey);
+        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;
@@ -582,7 +584,7 @@ class apiUtil$1 {
 
 
   static tokenExpireTime(req) {
-    return apiUtil$1.isDebugMode(req) ? 30 * 24 * 60 * 60 : apiUtil$1.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$1.tokenExpireTime;
   }
   /**
    * 获取用户令牌保存键
@@ -625,7 +627,7 @@ class apiUtil$1 {
   static setUserIdNo(userInfo, idNum) {
     if (userInfo && idNum) {
       userInfo._idNo = idNum;
-      userInfo.isHKIC = apiUtil$1.checkIsHKIC(idNum);
+      userInfo.isHKIC = apiUtil$2.checkIsHKIC(idNum);
     }
 
     return userInfo;
@@ -642,7 +644,7 @@ class apiUtil$1 {
 
   static async storeToken(token, tokenData, dataId, req) {
     // let timeout = tokenData.clientIp.substring(0, 8) == "192.168." ? 90 * 24 : 1;
-    let timeout = apiUtil$1.tokenExpireTime(req);
+    let timeout = apiUtil$2.tokenExpireTime(req);
 
     if (req.certPublicKey) {
       tokenData.certPublicKey = req.certPublicKey;
@@ -723,7 +725,7 @@ class apiUtil$1 {
         };
 
         if (rec.secret !== "") {
-          rec.secret = ppUtil$3.getEncAse192(rec.secret);
+          rec.secret = ppUtil$4.getEncAse192(rec.secret);
         }
 
         req.apiCallRec = rec;
@@ -790,7 +792,7 @@ class apiUtil$1 {
       return certInfo;
     }).catch(e => {
       console.log('获取企业证书失败:\n', e);
-      throw [err$1.ACCESS_REFUSED, `获取企业证书失败：${err$1.ERROR(e).message}`];
+      throw [err$2.ACCESS_REFUSED, `获取企业证书失败：${err$2.ERROR(e).message}`];
     });
   }
   /**
@@ -804,27 +806,27 @@ class apiUtil$1 {
   static async verifyApiSignature(tokenData, req) {
     try {
       if (!req.headers.timestamp) {
-        throw [err$1.ACCESS_REFUSED, `必须在请求头中设置时戳`];
+        throw [err$2.ACCESS_REFUSED, `必须在请求头中设置时戳`];
       }
 
       let timestamp = parseInt(req.headers.timestamp);
       let currentTime = new Date().valueOf();
-      let maxTimeDiff = apiUtil$1.isDebugMode(req) ? 7 * 24 * 3600 : apiUtil$1.isTestMode(req) ? 4 * 3600 : 100; // 100
+      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$1.ACCESS_REFUSED, `时戳(${timestamp})无效，当前时戳：${currentTime},时差 ${(currentTime - timestamp) / 1000}秒`];
+        throw [err$2.ACCESS_REFUSED, `时戳(${timestamp})无效，当前时戳：${currentTime},时差 ${(currentTime - timestamp) / 1000}秒`];
       }
 
       let signature = req.headers.signature;
 
       if (!signature) {
-        throw [err$1.ACCESS_REFUSED, `必须在请求头中提供签名`];
+        throw [err$2.ACCESS_REFUSED, `必须在请求头中提供签名`];
       }
 
-      let signData = apiUtil$1.extractToken(req, null, true) || tokenData.apiKey;
+      let signData = apiUtil$2.extractToken(req, null, true) || tokenData.apiKey;
       signData += timestamp;
 
-      if (apiUtil$1.isDebugMode(req) || apiUtil$1.isTestMode(req)) {
+      if (apiUtil$2.isDebugMode(req) || apiUtil$2.isTestMode(req)) {
         let publicKey = req.headers.publickey || req.body.publicKey || req.query.publicKey;
 
         if (publicKey) {
@@ -839,16 +841,16 @@ class apiUtil$1 {
         return await verifyResult;
       }
 
-      return apiUtil$1.getCompanyCertificate(tokenData.apiKey).then(info => {
+      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$1.extractToken(req, null, true);
+        let token = apiUtil$2.extractToken(req, null, true);
 
         if (token) {
-          apiUtil$1.storeToken(apiUtil$1.apiTokenStoreKey(token), tokenData, tokenData.apiKey, req);
+          apiUtil$2.storeToken(apiUtil$2.apiTokenStoreKey(token), tokenData, tokenData.apiKey, req);
         }
       }).then(() => {
         return doVerify(signData, signature, tokenData.certPublicKey);
@@ -873,7 +875,7 @@ class apiUtil$1 {
 
         if (!tokenData.certPublicKeySpare) {
           throw {
-            eo: err$1.ACCESS_REFUSED,
+            eo: err$2.ACCESS_REFUSED,
             msgArgv: "签名验证异常",
             data: e
           };
@@ -910,10 +912,10 @@ class apiUtil$1 {
               delete tokenData.certLivingId;
               delete tokenData.certSpareId;
               delete tokenData.certPublicKeySpare;
-              let token = apiUtil$1.extractToken(req);
+              let token = apiUtil$2.extractToken(req);
 
               if (token) {
-                apiUtil$1.storeToken(apiTokenStoreKey(token), tokenData, tokenData.apiKey, req);
+                apiUtil$2.storeToken(apiTokenStoreKey(token), tokenData, tokenData.apiKey, req);
               }
 
               console.log(`公司(${tokenData.apiKey})备用证书成功转换为正式证书`);
@@ -922,7 +924,7 @@ class apiUtil$1 {
         } catch (e) {
           console.log("SPO服务签名验证异常(备用证书), ", e);
           throw {
-            eo: err$1.ACCESS_REFUSED,
+            eo: err$2.ACCESS_REFUSED,
             msgArgv: "签名验证异常(spare)",
             data: e
           };
@@ -931,7 +933,7 @@ class apiUtil$1 {
 
       if (!verifyOK) {
         console.log("SPO服务签名验证失败, tokenData: ", tokenData);
-        throw [err$1.ACCESS_REFUSED, "签名验证未通过"];
+        throw [err$2.ACCESS_REFUSED, "签名验证未通过"];
       }
 
       return verifyOK;
@@ -947,32 +949,32 @@ class apiUtil$1 {
 
   static async checkApiCallValid(tokenData, req) {
     if (!tokenData.companyInfo) {
-      tokenData.companyInfo = await apiUtil$1.queryCompanyInfo(tokenData.apiKey, true).catch(e => {
+      tokenData.companyInfo = await apiUtil$2.queryCompanyInfo(tokenData.apiKey, true).catch(e => {
         console.log("执行企业信息查询发生异常", e);
-        throw [err$1.API_KEY_INVALID, "执行企业信息查询发生异常：" + e.message || ""];
+        throw [err$2.API_KEY_INVALID, "执行企业信息查询发生异常：" + e.message || ""];
       });
     }
 
     const companyInfo = tokenData.companyInfo;
 
     if (companyInfo != null) {
-      let secret = apiUtil$1._getApiSecret(tokenData.apiKey);
+      let secret = apiUtil$2._getApiSecret(tokenData.apiKey);
 
-      if (secret !== tokenData.apiSecret) throw err$1.API_SCREPT_INVALID; // 不再检查 IP 白名单，改为验证证书签名
+      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$1.signatureVerified()) return companyInfo;
-      return apiUtil$1.verifyApiSignature(tokenData, req).then(x => {
+      if (apiUtil$2.signatureVerified()) return companyInfo;
+      return apiUtil$2.verifyApiSignature(tokenData, req).then(x => {
         return companyInfo;
       }, e => {
         throw e;
       });
     }
 
-    throw [err$1.API_KEY_INVALID, tokenData.apiKey];
+    throw [err$2.API_KEY_INVALID, tokenData.apiKey];
   }
   /**
    * 检查令牌数据是否存在
@@ -1023,7 +1025,7 @@ class apiUtil$1 {
         paramExists = typeof params[paramName] != 'undefined' || typeof params[paramName + paramSufix] != 'undefined';
       }
 
-      if (!paramExists) return ppUtil$3.errorPormise(err$1.ERROR(err$1.PARAMETER_NEEDED, paramName));
+      if (!paramExists) return ppUtil$4.errorPormise(err$2.ERROR(err$2.PARAMETER_NEEDED, paramName));
     }
 
     return Promise.resolve(paramSufix);
@@ -1071,8 +1073,8 @@ class apiUtil$1 {
 
 
   static async hostIsMySelf(host, req) {
-    let clientIp = apiUtil$1.getClientIp(req);
-    return ppUtil$3.getMyIp({
+    let clientIp = apiUtil$2.getClientIp(req);
+    return ppUtil$4.getMyIp({
       hosts: [host, clientIp]
     });
   }
@@ -1086,13 +1088,13 @@ class apiUtil$1 {
   static async checkForwardsHost(options) {
     configNeeded();
     const params = options.replacements;
-    const myEnvHosts = apiUtil$1.getEnvHosts(params);
-    const myIp = ppUtil$3.getMyIp();
+    const myEnvHosts = apiUtil$2.getEnvHosts(params);
+    const myIp = ppUtil$4.getMyIp();
     const host = params.host || myIp;
-    if (!myEnvHosts.hosts.contains(host)) throw [err$1.ACCESS_REFUSED, `环境${conf$2.envId}貌似无此主机：${params.host}`];
+    if (!myEnvHosts.hosts.contains(host)) throw [err$2.ACCESS_REFUSED, `环境${conf$3.envId}貌似无此主机：${params.host}`];
 
-    if (!apiUtil$1.hostIsMySelf(host, options._res.req)) {
-      let result = await apiUtil$1.forwardsTo(host, myEnvHosts.port, params, options._res.req, myIp);
+    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);
 
@@ -1128,7 +1130,7 @@ class apiUtil$1 {
 
     if (result.status !== 200) {
       console.log(`访问 ${reqOptions.url} 出错`, result.status, result.res.statusMessage);
-      throw [err$1.EXCEPTION, `[${result.status}] - ${result.res.statusMessage}`];
+      throw [err$2.EXCEPTION, `[${result.status}] - ${result.res.statusMessage}`];
     }
 
     return result.data;
@@ -1144,7 +1146,7 @@ class apiUtil$1 {
     let keys = Array.isArray(keyPath) ? keyPath : keyPath.split(".");
     let parentKey = "";
     let key = "config";
-    let value = conf$2;
+    let value = conf$3;
     let parent = null;
 
     for (let i = 0; i < keys.length; i++) {
@@ -1154,7 +1156,7 @@ class apiUtil$1 {
       value = parent[key];
 
       if (value === undefined) {
-        throw [err$1.INVALID_PARAM, `无此配置项: ${key}`];
+        throw [err$2.INVALID_PARAM, `无此配置项: ${key}`];
       }
     }
 
@@ -1174,10 +1176,10 @@ class apiUtil$1 {
 
   static async $checkToken(req, res, next) {
     try {
-      await apiUtil$1.checkRequestToken(req);
+      await apiUtil$2.checkRequestToken(req);
       await next();
     } catch (e) {
-      res.send(err$1.ERROR(e));
+      res.send(err$2.ERROR(e));
     }
 
     return false;
@@ -1194,7 +1196,7 @@ class apiUtil$1 {
         let token = req.headers["access_token"] || req.headers['x-access-token']; //向后兼容
 
         if (!token) {
-          let params = apiUtil$1.extractParams(req);
+          let params = apiUtil$2.extractParams(req);
           token = params["access_token"];
 
           if (token) {
@@ -1217,15 +1219,15 @@ class apiUtil$1 {
 
     try {
       if (extractToken(req, res)) {
-        await apiUtil$1.restoreTokenData(apiUtil$1.userTokenStoreKey(req.accessToken), apiUtil$1.tokenExpireTime(req)).then(function (data) {
-          req.userInfo = apiUtil$1.setUserIdNo(data, data._idNo);
+        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$1.ERROR(e));
+      res.send(err$2.ERROR(e));
       return false;
     }
   }
@@ -1248,7 +1250,7 @@ class apiUtil$1 {
     req.isMobile = true;
 
     if (!req.signatureVerified) {
-      let params = apiUtil$1.extractParams(req);
+      let params = apiUtil$2.extractParams(req);
       moveProperty(params, req.headers, "access_token");
       moveProperty(params, req.headers, "timestamp");
 
@@ -1269,25 +1271,25 @@ class apiUtil$1 {
 
   static $checkApiKeyOld(req, res, next) {
     //检查post的信息或者url查询参数或者头信息
-    let tokenData = apiUtil$1.extractTokenData(req);
-    let params = apiUtil$1.extractParams(req);
-    apiUtil$1.createApiCallRec(tokenData, req);
+    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$1.spoApiFail(err$1.GET_CLIENTIP_FAIL, req);
+      errResponse = apiUtil$2.spoApiFail(err$2.GET_CLIENTIP_FAIL, req);
     } else if (!tokenData.apiKey) {
-      errResponse = apiUtil$1.spoApiFail([err$1.PARAMETER_NEEDED, "apiKey"], req);
+      errResponse = apiUtil$2.spoApiFail([err$2.PARAMETER_NEEDED, "apiKey"], req);
     } else if (!tokenData.apiSecret) {
-      errResponse = apiUtil$1.spoApiFail([err$1.PARAMETER_NEEDED, "apiSecret"], req);
+      errResponse = apiUtil$2.spoApiFail([err$2.PARAMETER_NEEDED, "apiSecret"], req);
     }
 
     if (errResponse != null) {
-      apiUtil$1._saveApiCallRec(req.apiCallRec, errResponse);
+      apiUtil$2._saveApiCallRec(req.apiCallRec, errResponse);
 
-      apiUtil$1.sendOrRedirect(req, res, errResponse);
+      apiUtil$2.sendOrRedirect(req, res, errResponse);
     } else {
-      apiUtil$1.checkApiCallValid(tokenData, req).then(companyInfo => {
+      apiUtil$2.checkApiCallValid(tokenData, req).then(companyInfo => {
         params.companyId = params.companyId || companyInfo.companyId;
         req.companyInfo = companyInfo;
         next();
@@ -1295,9 +1297,9 @@ class apiUtil$1 {
         console.log('apiCallInvalid:', e);
         let errResponse = spoApiFail(e, req);
 
-        apiUtil$1._saveApiCallRec(req.apiCallRec, errResponse);
+        apiUtil$2._saveApiCallRec(req.apiCallRec, errResponse);
 
-        apiUtil$1.sendOrRedirect(req, res, errResponse);
+        apiUtil$2.sendOrRedirect(req, res, errResponse);
       });
     }
   }
@@ -1312,31 +1314,31 @@ class apiUtil$1 {
       return;
     }
 
-    let accessToken = apiUtil$1.extractToken(req);
+    let accessToken = apiUtil$2.extractToken(req);
 
     if (!accessToken) {
-      res.send(apiUtil$1.spoApiFail(err$1.TOKEN_NEEDED, req)); // apiUtil.sendOrRedirect(req, res, spoApiFail(err.TOKEN_NEEDED, req));
+      res.send(apiUtil$2.spoApiFail(err$2.TOKEN_NEEDED, req)); // apiUtil.sendOrRedirect(req, res, spoApiFail(err.TOKEN_NEEDED, req));
 
       return;
     }
 
-    apiUtil$1.restoreTokenData(apiUtil$1.apiTokenStoreKey(accessToken)).then(p => {
+    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$1.getClientIp(req);
+        req.headers['x-phone-ip'] = apiUtil$2.getClientIp(req);
         req.headers['x-real-ip'] = p.clientIp;
       } else {
-        p.clientIp = apiUtil$1.getClientIp(req);
+        p.clientIp = apiUtil$2.getClientIp(req);
       }
 
       req.isApiCall = true;
       req.tokenData = p;
-      return apiUtil$1.$checkApiKeyOld(req, res, next);
+      return apiUtil$2.$checkApiKeyOld(req, res, next);
     }).catch(e => {
-      apiUtil$1.sendOrRedirect(req, res, apiUtil$1.spoApiFail(err$1.TOKEN_INVALID, req));
+      apiUtil$2.sendOrRedirect(req, res, apiUtil$2.spoApiFail(err$2.TOKEN_INVALID, req));
     });
   }
   /**
@@ -1349,24 +1351,24 @@ class apiUtil$1 {
 
 
   static async $checkTokenOrApiKey(req, res, next) {
-    let accessToken = apiUtil$1.extractToken(req, res);
+    let accessToken = apiUtil$2.extractToken(req, res);
 
     if (accessToken) {
-      let tokenExist = await apiUtil$1.tokenDataExist(apiUtil$1.userTokenStoreKey(accessToken));
+      let tokenExist = await apiUtil$2.tokenDataExist(apiUtil$2.userTokenStoreKey(accessToken));
 
       if (tokenExist) {
-        return await apiUtil$1.$checkToken(req, res, next);
+        return await apiUtil$2.$checkToken(req, res, next);
       }
 
-      tokenExist = await apiUtil$1.tokenDataExist(apiUtil$1.apiTokenStoreKey(accessToken));
+      tokenExist = await apiUtil$2.tokenDataExist(apiUtil$2.apiTokenStoreKey(accessToken));
 
       if (tokenExist) {
-        return apiUtil$1.$checkApiKey(req, res, next);
+        return apiUtil$2.$checkApiKey(req, res, next);
       } // 如果给定的token不存在，看看是不是平台内部调用
 
 
-      return await apiUtil$1.checkInternalToken(req).catch(e => {
-        res.send(apiUtil$1.apiFail(e, req));
+      return await apiUtil$2.checkInternalToken(req).catch(e => {
+        res.send(apiUtil$2.apiFail(e, req));
         return false;
       });
     }
@@ -1386,10 +1388,10 @@ class apiUtil$1 {
     const params = options.replacements;
     let item = params.item;
     delete params.item;
-    if (await apiUtil$1.checkForwardsHost(options)) return true;
-    let c = apiUtil$1.parseCfgPath(item);
+    if (await apiUtil$2.checkForwardsHost(options)) return true;
+    let c = apiUtil$2.parseCfgPath(item);
     delete c.parent;
-    c.host = ppUtil$3.getMyIp();
+    c.host = ppUtil$4.getMyIp();
     return c;
   }
   /**
@@ -1406,18 +1408,18 @@ class apiUtil$1 {
     delete params.item; // if (await checkForwardsHost(options))
     //     return true;
 
-    await apiUtil$1.parametersOK(params, "value");
-    let c = apiUtil$1.parseCfgPath(item);
+    await apiUtil$2.parametersOK(params, "value");
+    let c = apiUtil$2.parseCfgPath(item);
 
     if (typeof c.value === "object") {
-      throw [err$1.ACCESS_REFUSED, `暂不支持修改复杂配置`];
+      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$3.getMyIp();
+    c.host = ppUtil$4.getMyIp();
     return c; // 应用层自行处理多机同步
   } //#endregion
 
@@ -1425,21 +1427,21 @@ class apiUtil$1 {
 }
 
 function configNeeded() {
-  if (!conf$2 || !err$1) {
-    ppUtil$3.configNeeded();
-    conf$2 = ppUtil$3.appConfig;
-    appSetting$1 = conf$2.appSetting;
-    err$1 = ppUtil$3.appErrCfg;
+  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$1;
+var ppUtilApi = apiUtil$2;
 
 const fs = require$$0__default$1["default"];
 const path = require$$1__default$1["default"];
-const ppUtil$2 = require$$1__default["default"].ppUtil;
+const ppUtil$3 = require$$1__default["default"].ppUtil;
 const redisUtil = require$$2__default["default"].redisUtil;
-let conf$1, err; // const dbCheck = require('../dbupdate/dd-version');
+let conf$2, err$1; // const dbCheck = require('../dbupdate/dd-version');
 
 /**
  * API服务启动时前置条件检查
@@ -1458,10 +1460,10 @@ class preconditions$1 {
   static checkPromises = [];
 
   static setAppName(aName) {
-    ppUtil$2.configNeeded();
-    conf$1 = ppUtil$2.appConfig;
-    err = ppUtil$2.appErrCfg;
-    preconditions$1.appName = aName || conf$1.thisApp;
+    ppUtil$3.configNeeded();
+    conf$2 = ppUtil$3.appConfig;
+    err$1 = ppUtil$3.appErrCfg;
+    preconditions$1.appName = aName || conf$2.thisApp;
     return preconditions$1;
   }
 
@@ -1540,22 +1542,22 @@ class preconditions$1 {
 
 async function createEnvSettingFile(fileName) {
   try {
-    const cfgText = await ppUtil$2.doCreateEnvSettingFile(fileName);
+    const cfgText = await ppUtil$3.doCreateEnvSettingFile(fileName);
 
-    if (cfgText.indexOf(`cfgVersion: "${conf$1._envSetting.cfgVersion}"`) > 0) {
+    if (cfgText.indexOf(`cfgVersion: "${conf$2._envSetting.cfgVersion}"`) > 0) {
       console.log(`\n*** 已創建新的本機環境配置文件\n${fileName}\n请檢查各項內容是否正确(此项更新服务可正常运行)\n\n`);
       return "";
     }
 
-    return `已創建新的本機環境配置文件\n${fileName}\n请檢查並正確設置各項內容，然後將配置版本號修改為${conf$1._envSettings.default.cfgVersion}`;
+    return `已創建新的本機環境配置文件\n${fileName}\n请檢查並正確設置各項內容，然後將配置版本號修改為${conf$2._envSettings.default.cfgVersion}`;
   } catch (e) {
-    return `創建本機環境配置文件失敗\n《${fileName}》\n${err.ERROR(e).message}`;
+    return `創建本機環境配置文件失敗\n《${fileName}》\n${err$1.ERROR(e).message}`;
   }
 }
 
 async function checkExEnvSetting(loadjs) {
-  if (!conf$1._envSetting.localSettingImported) {
-    let fileName = conf$1.getEnvSettingFileName();
+  if (!conf$2._envSetting.localSettingImported) {
+    let fileName = conf$2.getEnvSettingFileName();
 
     if (!fs.existsSync(fileName)) {
       return await createEnvSettingFile(fileName);
@@ -1563,7 +1565,7 @@ async function checkExEnvSetting(loadjs) {
 
     let envSettingEx = loadjs(fileName);
 
-    if (envSettingEx.cfgVersion !== conf$1._envSettings.default.cfgVersion) {
+    if (envSettingEx.cfgVersion !== conf$2._envSettings.default.cfgVersion) {
       if (envSettingEx.cfgVersion !== "0.0") {
         let fp = path.parse(fileName);
         let newFileName = path.join(fp.dir, fp.name + envSettingEx.cfgVersion + fp.ext);
@@ -1582,10 +1584,10 @@ async function checkExEnvSetting(loadjs) {
 
 
 async function checkRedis() {
-  if (!conf$1.redis.enabled) return "";
+  if (!conf$2.redis.enabled) return "";
   const redis = redisUtil.newClient("io"); // console.log(`checkRedis begin：`);
 
-  await ppUtil$2.wait(15 * 1000, param => {
+  await ppUtil$3.wait(15 * 1000, param => {
     if (redis.ready && redis.connected || redis.error) {
       return true;
     }
@@ -1607,39 +1609,39 @@ var ppPrecond = preconditions$1;
 // 若 redis 不可用，则将消息转发到其它主机
 
 const {
-  ppUtil: ppUtil$1
+  ppUtil: ppUtil$2
 } = require$$1__default["default"];
 const RedisMessenger = require$$1__default$2["default"];
 const {
   netUtil
 } = require$$3__default["default"];
-let conf;
+let conf$1;
 
-class commonMessenger$1 {
+class commonMessenger$2 {
   static myMsgAddr = "";
   static redisMessenger = null;
   static onMessage = [];
 
   static initMessenger(appConfig, appErrCfg, msgChannel) {
-    conf = appConfig;
-    this.redisMessenger = conf.redis.enabled ? new RedisMessenger(appConfig, appErrCfg, msgChannel).subscribe(msgChannel) : null;
-    this.myMsgAddr = commonMessenger$1.getMyMsgAddr();
+    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.myMsgAddr) {
-      conf.pm_id = process.env.pm_id || "0";
-      let myIp = ppUtil$1.getMyIp();
+    if (!conf$1.myMsgAddr) {
+      conf$1.pm_id = process.env.pm_id || "0";
+      let myIp = ppUtil$2.getMyIp();
 
       if (this.redisMessenger) {
-        myIp = `${conf.pm_id}@${myIp}`;
+        myIp = `${conf$1.pm_id}@${myIp}`;
       }
 
-      conf.myMsgAddr = myIp;
-      console.log(`myMsgAddr: `, conf.myMsgAddr);
+      conf$1.myMsgAddr = myIp;
+      console.log(`myMsgAddr: `, conf$1.myMsgAddr);
     }
 
-    return conf.myMsgAddr;
+    return conf$1.myMsgAddr;
   }
 
   static setMessageHandle(messageHandle) {
@@ -1647,11 +1649,11 @@ class commonMessenger$1 {
       return this.redisMessenger.setMessageHandle(messageHandle, msgChannel);
     }
 
-    if (commonMessenger$1.onMessage.indexOf(messageHandle) < 0) {
-      commonMessenger$1.onMessage.push(messageHandle);
+    if (commonMessenger$2.onMessage.indexOf(messageHandle) < 0) {
+      commonMessenger$2.onMessage.push(messageHandle);
     }
 
-    return commonMessenger$1;
+    return commonMessenger$2;
   }
 
   static async publishMessage(message) {
@@ -1662,10 +1664,10 @@ class commonMessenger$1 {
       if (message.destAddr) {
         await forwardMessage(message);
       } else {
-        for (let i = 0; i < conf.appSetting.serverHosts.length; i++) {
-          message.destAddr = conf.appSetting.serverHosts[i];
+        for (let i = 0; i < conf$1.appSetting.serverHosts.length; i++) {
+          message.destAddr = conf$1.appSetting.serverHosts[i];
 
-          if (message.destAddr !== conf.myMsgAddr) {
+          if (message.destAddr !== conf$1.myMsgAddr) {
             await forwardMessage(message);
           }
         }
@@ -1676,8 +1678,8 @@ class commonMessenger$1 {
   static async handleInternalMessage(options) {
     const message = options.replacements;
 
-    for (let i = 0; i < commonMessenger$1.onMessage.length; i++) {
-      const appMsgHandle = commonMessenger$1.onMessage[i];
+    for (let i = 0; i < commonMessenger$2.onMessage.length; i++) {
+      const appMsgHandle = commonMessenger$2.onMessage[i];
 
       try {
         await appMsgHandle(message);
@@ -1702,15 +1704,294 @@ async function forwardMessage(message) {
   return res.data;
 }
 
-var ppMessengerEx = commonMessenger$1;
+var ppMessengerEx = commonMessenger$2;
+
+/**
+ * CSCA 自动任务
+ * ==============
+ */
+const CRON = require$$0__default$2["default"];
+const {
+  ppUtil: ppUtil$1
+} = require$$1__default["default"];
+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];
+  }
+  /**
+   * 确定当前进程环境是否启用自动任务
+   * @returns {Promise<void>}
+   */
+
+
+  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
+  commonMessenger,
+  schedule
 };
 
 module.exports = ppUtil;