abler-api 0.1.25 → 0.1.28

package/dist/es/pp-util.js

@@ -1,18 +1,20 @@
-import require$$0$1 from 'crypto';
+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$$0$2 from 'fs';
+import require$$0$1 from 'fs';
 import require$$1$1 from 'path';
+import require$$1$2 from 'abler-messenger';
+import require$$0$2 from 'node-cron';
 
-const crypto = require$$0$1;
+const crypto = require$$0;
 const ppUtil$4 = require$$1.ppUtil;
 const {
   dbUtil,
   kvStorage
 } = require$$2;
 const netUtil$1 = require$$3;
-let conf$2, appSetting$1, err$1, dbSql;
+let conf$3, appSetting$1, err$2, dbSql;
 const pnToken = "access_token",
       hnToken = pnToken,
       pnApiKey = "apiKey",
@@ -23,7 +25,7 @@ pnApiSecret = "apiSecret",
 const MD5 = ppUtil$4.MD5,
       moveProperty = ppUtil$4.moveProperty;
 
-class apiUtil$1 {
+class apiUtil$2 {
   static debugFlag = ppUtil$4.newGuid(); //应用必须设置，否则谁也不知道是啥
 
   static testFlag = ppUtil$4.newGuid();
@@ -31,11 +33,11 @@ class apiUtil$1 {
 
   static config(appConfig, appErrCfg, appDbSql) {
     ppUtil$4.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;
+    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 ===== 需要应用系统重写的方法
 
   /**
@@ -123,7 +125,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;
@@ -134,11 +136,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;
   }
@@ -155,7 +157,7 @@ class apiUtil$1 {
       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;
@@ -225,7 +227,7 @@ class apiUtil$1 {
 
   static apiFail(error, req) {
     configNeeded();
-    let response = err$1.ERROR(error, err$1.errorLangParamFlag + ppUtil$4.getMsgLang(req));
+    let response = err$2.ERROR(error, err$2.errorLangParamFlag + ppUtil$4.getMsgLang(req));
     response.datetime = new Date();
 
     if (req && req.headers) {
@@ -247,8 +249,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失败返回结果
@@ -259,8 +261,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 服务结束，发送响应
@@ -297,10 +299,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));
     });
   }
   /**
@@ -312,16 +314,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);
     });
@@ -338,7 +340,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') {
@@ -370,7 +372,7 @@ class apiUtil$1 {
     // }
 
     options.userInfo = req.userInfo;
-    return apiUtil$1.setOptionsPropFuncions(options, res);
+    return apiUtil$2.setOptionsPropFuncions(options, res);
   }
   /**
    * 为API请求 options 设置属性
@@ -435,7 +437,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) {
@@ -446,12 +448,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;
           }
         }
       }
@@ -470,8 +472,8 @@ 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$4.idNumDisturbing)) {
       //todo: 检查IP
@@ -494,7 +496,7 @@ class apiUtil$1 {
       return true;
     } else {
       // console.log('token error.', req.accessToken);
-      throw err$1.TOKEN_INVALID;
+      throw err$2.TOKEN_INVALID;
     }
   }
   /**
@@ -505,16 +507,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);
     });
   }
   /**
@@ -526,7 +528,7 @@ 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;
@@ -548,11 +550,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;
@@ -569,7 +571,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;
   }
   /**
    * 获取用户令牌保存键
@@ -612,7 +614,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;
@@ -629,7 +631,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;
@@ -777,7 +779,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}`];
     });
   }
   /**
@@ -791,27 +793,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) {
@@ -826,16 +828,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);
@@ -860,7 +862,7 @@ class apiUtil$1 {
 
         if (!tokenData.certPublicKeySpare) {
           throw {
-            eo: err$1.ACCESS_REFUSED,
+            eo: err$2.ACCESS_REFUSED,
             msgArgv: "签名验证异常",
             data: e
           };
@@ -897,10 +899,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})备用证书成功转换为正式证书`);
@@ -909,7 +911,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
           };
@@ -918,7 +920,7 @@ class apiUtil$1 {
 
       if (!verifyOK) {
         console.log("SPO服务签名验证失败, tokenData: ", tokenData);
-        throw [err$1.ACCESS_REFUSED, "签名验证未通过"];
+        throw [err$2.ACCESS_REFUSED, "签名验证未通过"];
       }
 
       return verifyOK;
@@ -934,32 +936,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];
   }
   /**
    * 检查令牌数据是否存在
@@ -1010,7 +1012,7 @@ class apiUtil$1 {
         paramExists = typeof params[paramName] != 'undefined' || typeof params[paramName + paramSufix] != 'undefined';
       }
 
-      if (!paramExists) return ppUtil$4.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);
@@ -1058,7 +1060,7 @@ class apiUtil$1 {
 
 
   static async hostIsMySelf(host, req) {
-    let clientIp = apiUtil$1.getClientIp(req);
+    let clientIp = apiUtil$2.getClientIp(req);
     return ppUtil$4.getMyIp({
       hosts: [host, clientIp]
     });
@@ -1073,13 +1075,13 @@ class apiUtil$1 {
   static async checkForwardsHost(options) {
     configNeeded();
     const params = options.replacements;
-    const myEnvHosts = apiUtil$1.getEnvHosts(params);
+    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);
 
@@ -1115,7 +1117,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;
@@ -1131,7 +1133,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++) {
@@ -1141,7 +1143,7 @@ class apiUtil$1 {
       value = parent[key];
 
       if (value === undefined) {
-        throw [err$1.INVALID_PARAM, `无此配置项: ${key}`];
+        throw [err$2.INVALID_PARAM, `无此配置项: ${key}`];
       }
     }
 
@@ -1161,10 +1163,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;
@@ -1181,7 +1183,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) {
@@ -1204,15 +1206,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;
     }
   }
@@ -1235,7 +1237,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");
 
@@ -1256,25 +1258,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();
@@ -1282,9 +1284,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);
       });
     }
   }
@@ -1299,31 +1301,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));
     });
   }
   /**
@@ -1336,24 +1338,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;
       });
     }
@@ -1373,8 +1375,8 @@ 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$4.getMyIp();
     return c;
@@ -1393,11 +1395,11 @@ 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;
 
 
@@ -1412,21 +1414,21 @@ class apiUtil$1 {
 }
 
 function configNeeded() {
-  if (!conf$2 || !err$1) {
+  if (!conf$3 || !err$2) {
     ppUtil$4.configNeeded();
-    conf$2 = ppUtil$4.appConfig;
-    appSetting$1 = conf$2.appSetting;
-    err$1 = ppUtil$4.appErrCfg;
+    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$2;
+const fs = require$$0$1;
 const path = require$$1$1;
 const ppUtil$3 = require$$1.ppUtil;
 const redisUtil = require$$2.redisUtil;
-let conf$1, err; // const dbCheck = require('../dbupdate/dd-version');
+let conf$2, err$1; // const dbCheck = require('../dbupdate/dd-version');
 
 /**
  * API服务启动时前置条件检查
@@ -1446,9 +1448,9 @@ class preconditions$1 {
 
   static setAppName(aName) {
     ppUtil$3.configNeeded();
-    conf$1 = ppUtil$3.appConfig;
-    err = ppUtil$3.appErrCfg;
-    preconditions$1.appName = aName || conf$1.thisApp;
+    conf$2 = ppUtil$3.appConfig;
+    err$1 = ppUtil$3.appErrCfg;
+    preconditions$1.appName = aName || conf$2.thisApp;
     return preconditions$1;
   }
 
@@ -1529,20 +1531,20 @@ async function createEnvSettingFile(fileName) {
   try {
     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);
@@ -1550,7 +1552,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);
@@ -1569,7 +1571,7 @@ 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$3.wait(15 * 1000, param => {
@@ -1590,209 +1592,393 @@ async function checkRedis() {
 
 var ppPrecond = preconditions$1;
 
-var require$$0 = require$$2;
+// 若 redis 可用，则使用基于 redis 的消息订阅发布系统
+// 若 redis 不可用，则将消息转发到其它主机
 
-function _interopDefaultLegacy(e) {
-  return e && typeof e === 'object' && 'default' in e ? e : {
-    'default': e
-  };
-}
+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 = [];
 
-var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0); // const logger = require("log4js").getLogger();
+  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();
 
-const redis = require$$0__default["default"].redisUtil;
+      if (this.redisMessenger) {
+        myIp = `${conf$1.pm_id}@${myIp}`;
+      }
 
-class Messenger {
-  constructor(appConfig, appErrCfg) {
-    if (appConfig) {
-      redis.config(appConfig, appErrCfg);
+      conf$1.myMsgAddr = myIp;
+      console.log(`myMsgAddr: `, conf$1.myMsgAddr);
     }
 
-    this.channel = "ecs_messenger"; //default channel
-
-    this.publisher = redis.newClient("publisher");
-    this.subscriber = redis.newClient("subscriber");
-    this.subscriber.on("subscribe", function (channel, count) {
-      console.log("chanel subscribed :", channel, count);
-    });
-    this.subscriber.on("message", this.handleMessage);
+    return conf$1.myMsgAddr;
   }
 
-  setMessageHandle(handle, channel) {
-    channel = channel || this.channel;
-    Messenger.onmessage = Messenger.onmessage || {};
-    Messenger.onmessage[channel] = Messenger.onmessage[channel] || [];
-    const appMsgHandles = Messenger.onmessage[channel];
+  static setMessageHandle(messageHandle) {
+    if (this.redisMessenger) {
+      return this.redisMessenger.setMessageHandle(messageHandle, msgChannel);
+    }
 
-    for (let i = 0; i < appMsgHandles.length; i++) {
-      if (appMsgHandles[i] === handle) return this;
+    if (commonMessenger$2.onMessage.indexOf(messageHandle) < 0) {
+      commonMessenger$2.onMessage.push(messageHandle);
     }
 
-    appMsgHandles.push(handle);
-    return this;
+    return commonMessenger$2;
   }
 
-  subscribe(channel) {
-    channel = channel || this.channel;
-    this.subscriber.subscribe(channel);
-    return this;
+  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);
+          }
+        }
+      }
+    }
   }
 
-  async handleMessage(channel, message) {
-    console.log(`通道[${channel}]收到订阅消息：`, message);
-    let appMsgHandles = Messenger.onmessage[channel] || [];
+  static async handleInternalMessage(options) {
+    const message = options.replacements;
 
-    for (let i = 0; i < appMsgHandles.length; i++) {
-      const appMsgHandle = appMsgHandles[i];
+    for (let i = 0; i < commonMessenger$2.onMessage.length; i++) {
+      const appMsgHandle = commonMessenger$2.onMessage[i];
 
       try {
-        let msgObj = JSON.parse(message); // await appMsgHandle(msgObj);
-
-        appMsgHandle(msgObj);
+        await appMsgHandle(message);
       } catch (e) {
         console.log(e);
       }
     }
   }
 
-  async publish(message, channel) {
-    channel = channel || this.channel;
-    let msgStr = typeof message === "object" ? JSON.stringify(message) : message.toString();
-    console.log(`通道[${channel}]发布消息：`, message);
-    await this.publisher.publish(channel, msgStr);
-    return this;
-  }
-
 }
 
-var ppMessenger$1 = Messenger;
-const ppMessenger = ppMessenger$1;
-var ppUtil$2 = ppMessenger;
-var ppUtil_1 = ppUtil$2;
+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;
+}
 
-// 若 redis 可用，则使用基于 redis 的消息订阅发布系统
-// 若 redis 不可用，则将消息转发到其它主机
+var ppMessengerEx = commonMessenger$2;
 
-const RedisMessenger = ppUtil_1;
+/**
+ * CSCA 自动任务
+ * ==============
+ */
+const CRON = require$$0$2;
 const {
-  netUtil
-} = require$$3;
-let conf;
+  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>}
+   */
 
-class noneRedisMessenger {
-  static onMessage = [];
+  static async registerTask(taskName, taskCaption, cronExp, taskFunc, autoStart) {
+    if (!conf) {
+      ppUtil$1.configNeeded();
+      conf = ppUtil$1.appConfig;
+      err = ppUtil$1.appErrCfg;
+    }
 
-  static async publishMessage(message) {
-    //没有消息处理器，则将消息转发到目标地址（不支持pm2多进程）
-    if (message.destAddr) {
-      await forwardMessage(message);
-    } else {
-      for (let i = 0; i < conf.appSetting.serverHosts.length; i++) {
-        message.destAddr = conf.appSetting.serverHosts[i];
+    if (!this.envAllowed()) return {};
+    let task = this.findTask(taskName);
+
+    if (task) {
+      if (task.cronExp !== cronExp || task.taskFunc !== taskFunc) {
+        this.stop(taskName);
+        task = null;
+      }
+    }
 
-        if (message.destAddr !== conf.myMsgAddr) {
-          await forwardMessage(message);
+    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 setMessageHandle(messageHandle) {
-    if (noneRedisMessenger.onMessage.indexOf(messageHandle) < 0) {
-      noneRedisMessenger.onMessage.push(messageHandle);
+  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;
     }
 
-    return noneRedisMessenger;
+    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 handleInternalMessage(options) {
-    const message = options.replacements;
 
-    for (let i = 0; i < noneRedisMessenger.onMessage.length; i++) {
-      const appMsgHandle = noneRedisMessenger.onMessage[i];
+  static async stop(taskOrName) {
+    if (!this.envAllowed()) return {};
+    let task = taskOrName;
 
-      try {
-        // await appMsgHandle(message);
-        appMsgHandle(message);
-      } catch (e) {
-        console.log(e);
-      }
+    if (typeof task === "string") {
+      task = this.findTask(taskOrName);
     }
-  }
 
-}
+    if (!task) throw [err.INVALID_PARAM, `任务${taskOrName}不存在`];
 
-class commonMessenger$1 {
-  static myMsgAddr = "";
-  static redisMessenger = null;
+    if (task.schedule) {
+      task.schedule.stop();
+      task.schedule = null;
+      return this.getTaskInfo(task, "任务已停止。");
+    }
 
-  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();
+    return this.getTaskInfo(task, "任务未启动，无需停止。");
   }
+  /**
+   * 获取或设置当前状态（来自远程的API调用）
+   * @param options
+   * @returns {Promise<unknown>}
+   */
 
-  static getMyMsgAddr() {
-    if (!conf.myMsgAddr) {
-      conf.pm_id = process.env.pm_id || "0";
-      let myIp = ppUtil.getMyIp();
 
-      if (this.redisMessenger) {
-        myIp = `${conf.pm_id}@${myIp}`;
+  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;
+          }
 
-      conf.myMsgAddr = myIp;
-      console.log(`myMsgAddr: `, conf.myMsgAddr);
+          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 conf.myMsgAddr;
+    return {
+      _message_: "此环境无自动任务"
+    };
   }
 
-  static setMessageHandle(messageHandle) {
-    if (this.redisMessenger) {
-      return this.redisMessenger.setMessageHandle(messageHandle, msgChannel);
+  static async _state(params) {
+    let apiResult = {};
+    let task;
+
+    if (params.taskName) {
+      task = this.findTask(params.taskName);
+      if (!task) throw [err.INVALID_PARAM, `任务${params.taskName}不存在`];
     }
 
-    return noneRedisMessenger.setMessageHandle(messageHandle);
-  }
+    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`];
+      }
 
-  static async publishMessage(message) {
-    if (this.redisMessenger) {
-      return this.redisMessenger.publish(message, msgChannel);
-    } else {
-      return noneRedisMessenger.publishMessage(message);
+      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 async handleInternalMessage(options) {
-    return await noneRedisMessenger.handleInternalMessage(options);
+  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;
+  }
 
-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$1;
+var ppSchedule = schedule$1;
 
 const apiUtil = ppUtilApi;
 const preconditions = ppPrecond;
 const commonMessenger = ppMessengerEx;
-var ppUtil$1 = {
+const schedule = ppSchedule;
+var ppUtil = {
   apiUtil,
   preconditions,
-  commonMessenger
+  commonMessenger,
+  schedule
 };
 
-export { ppUtil$1 as default };
+export { ppUtil as default };