@ruiapp/rapid-core 0.8.4 → 0.8.6

package/dist/dataAccess/entityValidator.d.ts

@@ -0,0 +1,3 @@
+import { IRpdServer } from "../core/server";
+import { RpdDataModel } from "../types";
+export declare function validateEntity(server: IRpdServer, model: RpdDataModel, entity: any): Promise<any>;

package/dist/helpers/metaHelper.d.ts

@@ -5,6 +5,13 @@ export declare function isOneRelationProperty(property: RpdDataModelProperty): b
 export declare function isManyRelationProperty(property: RpdDataModelProperty): boolean;
 export declare function getEntityProperties(server: IRpdServer, model: RpdDataModel, predicate?: (item: RpdDataModelProperty) => boolean): RpdDataModelProperty[];
 export declare function getEntityPropertiesIncludingBase(server: IRpdServer, model: RpdDataModel, predicate?: (item: RpdDataModelProperty) => boolean): RpdDataModelProperty[];
+/**
+ * 根据 code 获取实体属性信息。如实体为派生实体，可能会返回基础实体中的属性信息。
+ * @param server
+ * @param model
+ * @param propertyCode
+ * @returns
+ */
 export declare function getEntityPropertyByCode(server: IRpdServer, model: RpdDataModel, propertyCode: string): RpdDataModelProperty | undefined;
 export declare function getEntityProperty(server: IRpdServer, model: RpdDataModel, predicate: (item: RpdDataModelProperty) => boolean): RpdDataModelProperty | undefined;
 export declare function getEntityOwnPropertyByCode(model: RpdDataModel, propertyCode: string): RpdDataModelProperty | undefined;

package/dist/index.js

@@ -19,24 +19,6 @@ var xstate = require('xstate');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
 var Router__default = /*#__PURE__*/_interopDefaultLegacy(Router);
 var qs__default = /*#__PURE__*/_interopDefaultLegacy(qs);
 var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
@@ -45,7 +27,6 @@ var bcrypt__default = /*#__PURE__*/_interopDefaultLegacy(bcrypt);
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 var nodemailer__default = /*#__PURE__*/_interopDefaultLegacy(nodemailer);
-var cron__namespace = /*#__PURE__*/_interopNamespace(cron);
 
 function fixBigIntJSONSerialize() {
     BigInt.prototype.toJSON = function () {
@@ -2444,6 +2425,13 @@ function getEntityPropertiesIncludingBase(server, model, predicate) {
     }
     return [...baseProperties, ...properties];
 }
+/**
+ * 根据 code 获取实体属性信息。如实体为派生实体，可能会返回基础实体中的属性信息。
+ * @param server
+ * @param model
+ * @param propertyCode
+ * @returns
+ */
 function getEntityPropertyByCode(server, model, propertyCode) {
     return getEntityProperty(server, model, (e) => e.code === propertyCode);
 }
@@ -2482,6 +2470,16 @@ function getEntityPropertyByFieldName(server, model, fieldName) {
     return property;
 }
 
+function getNowString() {
+    return dayjs__default["default"]().format("YYYY-MM-DD HH:mm:ss.SSS");
+}
+function getNowStringWithTimezone() {
+    return dayjs__default["default"]().format("YYYY-MM-DD HH:mm:ss.SSSZ");
+}
+function getDateString(timeString) {
+    return dayjs__default["default"](timeString).format("YYYY-MM-DD");
+}
+
 // TODO Generate mapper and cache it.
 function mapDbRowToEntity(server, model, row, keepNonPropertyFields) {
     if (!row) {
@@ -2524,8 +2522,16 @@ function mapDbRowToEntity(server, model, row, keepNonPropertyFields) {
             }
         }
         else {
+            let fieldValue = row[columnName];
+            if (property) {
+                if (property.type === "date") {
+                    if (fieldValue) {
+                        fieldValue = getDateString(fieldValue);
+                    }
+                }
+            }
             if (!result[propertyName]) {
-                result[propertyName] = row[columnName];
+                result[propertyName] = fieldValue;
             }
         }
     });
@@ -2661,11 +2667,23 @@ function getEntityPartChanges(server, model, before, after) {
     return null;
 }
 
-function getNowString() {
-    return dayjs__default["default"]().format("YYYY-MM-DD HH:mm:ss.SSS");
-}
-function getNowStringWithTimezone() {
-    return dayjs__default["default"]().format("YYYY-MM-DD HH:mm:ss.SSSZ");
+async function validateEntity(server, model, entity) {
+    for (const propCode in entity) {
+        let prop = getEntityPropertyByCode(server, model, propCode);
+        if (!prop) {
+            getEntityPropertyByFieldName(server, model, propCode);
+        }
+        if (!prop) {
+            continue;
+        }
+        if (prop.type === "date") {
+            const originValue = entity[propCode];
+            if (originValue) {
+                entity[propCode] = getDateString(originValue);
+            }
+        }
+    }
+    return entity;
 }
 
 function convertEntityOrderByToRowOrderBy(server, model, baseModel, orderByList) {
@@ -3305,7 +3323,9 @@ async function createEntity(server, dataAccessor, options, plugin) {
     if (model.derivedTypePropertyCode) {
         throw newEntityOperationError("Create base entity directly is not allowed.");
     }
-    const { entity, routeContext } = options;
+    let { entity } = options;
+    entity = await validateEntity(server, model, entity);
+    const { routeContext } = options;
     const userId = options.routeContext?.state?.userId;
     if (userId) {
         const createdByProperty = getEntityPropertyByCode(server, model, "createdBy");
@@ -3556,6 +3576,8 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
     if (!id) {
         throw new Error("Id is required when updating an entity.");
     }
+    let { entityToSave } = options;
+    entityToSave = await validateEntity(server, model, entityToSave);
     const entity = await findById(server, dataAccessor, {
         routeContext,
         id,
@@ -3564,7 +3586,6 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
     if (!entity) {
         throw new Error(`${model.namespace}.${model.singularCode}  with id "${id}" was not found.`);
     }
-    let { entityToSave } = options;
     let changes = getEntityPartChanges(server, model, entity, entityToSave);
     if (!changes && !options.operation) {
         return entity;
@@ -8486,11 +8507,20 @@ async function handler$1(plugin, ctx, options) {
     if (!input.code) {
         throw new Error(`Cron job code is required.`);
     }
-    const job = plugin.getJobConfigurationByCode(input.code);
+    const cronJobService = server.getService("cronJobService");
+    const job = cronJobService.getJobConfigurationByCode(input.code);
     if (!job) {
         throw new Error(`Cron job with code '${input.code}' was not found.`);
     }
-    await plugin.executeJob(server, job);
+    let jobExecutionContext = {
+        logger: server.getLogger(),
+        routerContext,
+        next: null,
+        server,
+        applicationConfig: null,
+        input: input.input,
+    };
+    await cronJobService.executeJob(jobExecutionContext, job);
     response.json({});
 }
 
@@ -8518,8 +8548,98 @@ var runCronJob = {
 
 var pluginRoutes$1 = [runCronJob];
 
+class CronJobService {
+    #server;
+    #jobInstances;
+    constructor(server) {
+        this.#server = server;
+    }
+    /**
+     * 根据编号获取定时任务配置信息
+     * @param code
+     * @returns
+     */
+    getJobConfigurationByCode(code) {
+        return lodash.find(this.#server.listCronJobs(), (job) => job.code === code);
+    }
+    /**
+     * 重新加载定时任务
+     */
+    reloadJobs() {
+        const server = this.#server;
+        if (this.#jobInstances) {
+            for (const job of this.#jobInstances) {
+                job.instance.stop();
+            }
+        }
+        this.#jobInstances = [];
+        const cronJobs = server.listCronJobs();
+        for (const job of cronJobs) {
+            if (job.disabled) {
+                continue;
+            }
+            const jobInstance = cron.CronJob.from({
+                ...(job.jobOptions || {}),
+                cronTime: job.cronTime,
+                onTick: async () => {
+                    await this.tryExecuteJob(job);
+                },
+            });
+            jobInstance.start();
+            this.#jobInstances.push({
+                code: job.code,
+                instance: jobInstance,
+            });
+        }
+    }
+    async tryExecuteJob(job) {
+        const server = this.#server;
+        const logger = server.getLogger();
+        logger.info(`Executing cron job '${job.code}'...`);
+        let handlerContext = {
+            logger,
+            routerContext: RouteContext.newSystemOperationContext(server),
+            next: null,
+            server,
+            applicationConfig: null,
+            input: null,
+        };
+        try {
+            await this.executeJob(handlerContext, job);
+            logger.info(`Completed cron job '${job.code}'...`);
+        }
+        catch (ex) {
+            logger.error('Cron job "%s" execution error: %s', job.code, ex.message);
+            if (job.onError) {
+                try {
+                    await job.onError(handlerContext, ex);
+                }
+                catch (ex) {
+                    logger.error('Error handler of cron job "%s" execution failed: %s', job.code, ex.message);
+                }
+            }
+        }
+    }
+    /**
+     * 执行指定任务
+     * @param job
+     */
+    async executeJob(handlerContext, job) {
+        const server = this.#server;
+        validateLicense(server);
+        if (job.actionHandlerCode) {
+            const actionHandler = server.getActionHandlerByCode(job.code);
+            await actionHandler(handlerContext, job.handleOptions);
+        }
+        else {
+            await job.handler(handlerContext, job.handleOptions);
+        }
+    }
+}
+
 class CronJobPlugin {
     #server;
+    #cronJobService;
     constructor() { }
     get code() {
         return "cronJob";
@@ -8551,55 +8671,16 @@ class CronJobPlugin {
     async onLoadingApplication(server, applicationConfig) { }
     async configureModels(server, applicationConfig) { }
     async configureModelProperties(server, applicationConfig) { }
+    async configureServices(server, applicationConfig) {
+        this.#cronJobService = new CronJobService(server);
+        server.registerService("cronJobService", this.#cronJobService);
+    }
     async configureRoutes(server, applicationConfig) {
         server.appendApplicationConfig({ routes: pluginRoutes$1 });
     }
     async onApplicationLoaded(server, applicationConfig) { }
     async onApplicationReady(server, applicationConfig) {
-        const cronJobs = server.listCronJobs();
-        for (const job of cronJobs) {
-            const jobInstance = cron__namespace.CronJob.from({
-                ...(job.jobOptions || {}),
-                cronTime: job.cronTime,
-                onTick: async () => {
-                    await this.tryExecuteJob(server, job);
-                },
-            });
-            jobInstance.start();
-        }
-    }
-    getJobConfigurationByCode(code) {
-        return lodash.find(this.#server.listCronJobs(), (job) => job.code === code);
-    }
-    async tryExecuteJob(server, job) {
-        const logger = server.getLogger();
-        logger.info(`Executing cron job '${job.code}'...`);
-        try {
-            await this.executeJob(server, job);
-            logger.info(`Completed cron job '${job.code}'...`);
-        }
-        catch (ex) {
-            logger.error('Cron job "%s" execution error: %s', job.code, ex.message, { cronJobCode: job.code });
-        }
-    }
-    async executeJob(server, job) {
-        const logger = server.getLogger();
-        validateLicense(server);
-        let handlerContext = {
-            logger,
-            routerContext: RouteContext.newSystemOperationContext(server),
-            next: null,
-            server,
-            applicationConfig: null,
-            input: null,
-        };
-        if (job.actionHandlerCode) {
-            const actionHandler = server.getActionHandlerByCode(job.code);
-            await actionHandler(handlerContext, job.handleOptions);
-        }
-        else {
-            await job.handler(handlerContext, job.handleOptions);
-        }
+        this.#cronJobService.reloadJobs();
     }
 }
 
@@ -9016,6 +9097,7 @@ exports.decodeJwt = decodeJwt;
 exports.deleteCookie = deleteCookie;
 exports.generateJwtSecretKey = generateJwtSecretKey;
 exports.getCookies = getCookies;
+exports.getDateString = getDateString;
 exports.getEntityRelationTargetId = getEntityRelationTargetId;
 exports.getNowString = getNowString;
 exports.getNowStringWithTimezone = getNowStringWithTimezone;

package/dist/plugins/cronJob/CronJobPlugin.d.ts

@@ -1,5 +1,4 @@
 import type { RpdApplicationConfig } from "../../types";
-import { CronJobConfiguration } from "../../types/cron-job-types";
 import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "../../core/server";
 declare class CronJobPlugin implements RapidPlugin {
     #private;
@@ -18,11 +17,9 @@ declare class CronJobPlugin implements RapidPlugin {
     onLoadingApplication(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
     configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
     configureModelProperties(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
+    configureServices(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
     configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
     onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
     onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
-    getJobConfigurationByCode(code: string): CronJobConfiguration;
-    tryExecuteJob(server: IRpdServer, job: CronJobConfiguration): Promise<void>;
-    executeJob(server: IRpdServer, job: CronJobConfiguration): Promise<void>;
 }
 export default CronJobPlugin;

package/dist/plugins/cronJob/CronJobPluginTypes.d.ts

@@ -1,6 +1,12 @@
+import { CronJob } from "cron";
 export type RunCronJobActionHandlerOptions = {
     code?: string;
 };
 export type RunCronJobInput = {
     code?: string;
+    input?: any;
+};
+export type NamedCronJobInstance = {
+    code: string;
+    instance: CronJob;
 };

package/dist/plugins/cronJob/services/CronJobService.d.ts

@@ -0,0 +1,23 @@
+import { IRpdServer } from "../../../core/server";
+import { CronJobConfiguration } from "../../../types/cron-job-types";
+import { ActionHandlerContext } from "../../../core/actionHandler";
+export default class CronJobService {
+    #private;
+    constructor(server: IRpdServer);
+    /**
+     * 根据编号获取定时任务配置信息
+     * @param code
+     * @returns
+     */
+    getJobConfigurationByCode(code: string): CronJobConfiguration;
+    /**
+     * 重新加载定时任务
+     */
+    reloadJobs(): void;
+    tryExecuteJob(job: CronJobConfiguration): Promise<void>;
+    /**
+     * 执行指定任务
+     * @param job
+     */
+    executeJob(handlerContext: ActionHandlerContext, job: CronJobConfiguration): Promise<void>;
+}

package/dist/types/cron-job-types.d.ts

@@ -8,6 +8,10 @@ export interface CronJobConfiguration {
      * 定时任务描述
      */
     description?: string;
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
     /**
      * crontab 表达式
      */
@@ -31,6 +35,13 @@ export interface CronJobConfiguration {
      * 处理定时任务时的设置选项
      */
     handleOptions?: any;
+    /**
+     * 定时任务执行失败时的处理
+     * @param ctx
+     * @param error
+     * @returns
+     */
+    onError?: (ctx: ActionHandlerContext, error: any) => Promise<void>;
 }
 export interface CronJobOptions {
     /**

package/dist/utilities/timeUtility.d.ts

@@ -1,2 +1,3 @@
 export declare function getNowString(): string;
 export declare function getNowStringWithTimezone(): string;
+export declare function getDateString(timeString: any): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/core/actionHandler.ts

@@ -2,6 +2,7 @@ import { RpdApplicationConfig } from "~/types";
 import { IRpdServer, RapidPlugin } from "./server";
 import { Next, RouteContext } from "./routeContext";
 import { Logger } from "~/facilities/log/LogFacility";
+import { CronJobConfiguration } from "~/types/cron-job-types";
 
 export interface ActionHandlerContext {
   logger: Logger;

package/src/dataAccess/entityManager.ts

@@ -58,6 +58,7 @@ import { ColumnSelectOptions, CountRowOptions, FindRowOptions, FindRowOrderByOpt
 import { newEntityOperationError } from "~/utilities/errorUtility";
 import { getNowStringWithTimezone } from "~/utilities/timeUtility";
 import { RouteContext } from "~/core/routeContext";
+import { validateEntity } from "./entityValidator";
 
 export type FindOneRelationEntitiesOptions = {
   server: IRpdServer;
@@ -777,8 +778,10 @@ async function createEntity(server: IRpdServer, dataAccessor: IRpdDataAccessor,
     throw newEntityOperationError("Create base entity directly is not allowed.");
   }
 
-  const { entity, routeContext } = options;
+  let { entity } = options;
+  entity = await validateEntity(server, model, entity);
 
+  const { routeContext } = options;
   const userId = options.routeContext?.state?.userId;
   if (userId) {
     const createdByProperty = getEntityPropertyByCode(server, model, "createdBy");
@@ -1051,6 +1054,9 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
     throw new Error("Id is required when updating an entity.");
   }
 
+  let { entityToSave } = options;
+  entityToSave = await validateEntity(server, model, entityToSave);
+
   const entity = await findById(server, dataAccessor, {
     routeContext,
     id,
@@ -1060,7 +1066,6 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
     throw new Error(`${model.namespace}.${model.singularCode}  with id "${id}" was not found.`);
   }
 
-  let { entityToSave } = options;
   let changes = getEntityPartChanges(server, model, entity, entityToSave);
   if (!changes && !options.operation) {
     return entity;

package/src/dataAccess/entityMapper.ts

@@ -1,6 +1,7 @@
 import type { IRpdServer } from "~/core/server";
 import { RpdDataModel } from "~/types";
 import { getEntityProperty, getEntityPropertyByCode, isRelationProperty } from "../helpers/metaHelper";
+import { getDateString } from "~/utilities/timeUtility";
 
 // TODO Generate mapper and cache it.
 
@@ -45,8 +46,18 @@ export function mapDbRowToEntity(server: IRpdServer, model: RpdDataModel, row: a
         result[columnName] = row[columnName];
       }
     } else {
+      let fieldValue = row[columnName];
+
+      if (property) {
+        if (property.type === "date") {
+          if (fieldValue) {
+            fieldValue = getDateString(fieldValue);
+          }
+        }
+      }
+
       if (!result[propertyName]) {
-        result[propertyName] = row[columnName];
+        result[propertyName] = fieldValue;
       }
     }
   });

package/src/dataAccess/entityValidator.ts

@@ -0,0 +1,26 @@
+import { IRpdServer } from "~/core/server";
+import { getEntityPropertyByCode, getEntityPropertyByFieldName } from "~/helpers/metaHelper";
+import { RpdDataModel } from "~/types";
+import { getDateString } from "~/utilities/timeUtility";
+
+export async function validateEntity(server: IRpdServer, model: RpdDataModel, entity: any) {
+  for (const propCode in entity) {
+    let prop = getEntityPropertyByCode(server, model, propCode);
+    if (!prop) {
+      getEntityPropertyByFieldName(server, model, propCode);
+    }
+
+    if (!prop) {
+      continue;
+    }
+
+    if (prop.type === "date") {
+      const originValue = entity[propCode];
+      if (originValue) {
+        entity[propCode] = getDateString(originValue);
+      }
+    }
+  }
+
+  return entity;
+}

package/src/helpers/metaHelper.ts

@@ -53,6 +53,13 @@ export function getEntityPropertiesIncludingBase(server: IRpdServer, model: RpdD
   return [...baseProperties, ...properties];
 }
 
+/**
+ * 根据 code 获取实体属性信息。如实体为派生实体，可能会返回基础实体中的属性信息。
+ * @param server
+ * @param model
+ * @param propertyCode
+ * @returns
+ */
 export function getEntityPropertyByCode(server: IRpdServer, model: RpdDataModel, propertyCode: string): RpdDataModelProperty | undefined {
   return getEntityProperty(server, model, (e) => e.code === propertyCode);
 }

package/src/plugins/cronJob/CronJobPlugin.ts

@@ -1,8 +1,6 @@
-import * as cron from "cron";
 import type { RpdApplicationConfig } from "~/types";
 import pluginActionHandlers from "./actionHandlers";
 import pluginRoutes from "./routes";
-import { CronJobConfiguration } from "~/types/cron-job-types";
 import {
   IRpdServer,
   RapidPlugin,
@@ -10,13 +8,11 @@ import {
   RpdServerPluginConfigurableTargetOptions,
   RpdServerPluginExtendingAbilities,
 } from "~/core/server";
-import { ActionHandlerContext } from "~/core/actionHandler";
-import { find } from "lodash";
-import { validateLicense } from "~/helpers/licenseHelper";
-import { RouteContext } from "~/core/routeContext";
+import CronJobService from "./services/CronJobService";
 
 class CronJobPlugin implements RapidPlugin {
   #server: IRpdServer;
+  #cronJobService!: CronJobService;
 
   constructor() {}
 
@@ -64,6 +60,11 @@ class CronJobPlugin implements RapidPlugin {
 
   async configureModelProperties(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
 
+  async configureServices(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+    this.#cronJobService = new CronJobService(server);
+    server.registerService("cronJobService", this.#cronJobService);
+  }
+
   async configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
     server.appendApplicationConfig({ routes: pluginRoutes });
   }
@@ -71,54 +72,7 @@ class CronJobPlugin implements RapidPlugin {
   async onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
 
   async onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-    const cronJobs = server.listCronJobs();
-    for (const job of cronJobs) {
-      const jobInstance = cron.CronJob.from({
-        ...(job.jobOptions || {}),
-        cronTime: job.cronTime,
-        onTick: async () => {
-          await this.tryExecuteJob(server, job);
-        },
-      });
-      jobInstance.start();
-    }
-  }
-
-  getJobConfigurationByCode(code: string) {
-    return find(this.#server.listCronJobs(), (job) => job.code === code);
-  }
-
-  async tryExecuteJob(server: IRpdServer, job: CronJobConfiguration) {
-    const logger = server.getLogger();
-    logger.info(`Executing cron job '${job.code}'...`);
-
-    try {
-      await this.executeJob(server, job);
-      logger.info(`Completed cron job '${job.code}'...`);
-    } catch (ex: any) {
-      logger.error('Cron job "%s" execution error: %s', job.code, ex.message, { cronJobCode: job.code });
-    }
-  }
-
-  async executeJob(server: IRpdServer, job: CronJobConfiguration) {
-    const logger = server.getLogger();
-    validateLicense(server);
-
-    let handlerContext: ActionHandlerContext = {
-      logger,
-      routerContext: RouteContext.newSystemOperationContext(server),
-      next: null,
-      server,
-      applicationConfig: null,
-      input: null,
-    };
-
-    if (job.actionHandlerCode) {
-      const actionHandler = server.getActionHandlerByCode(job.code);
-      await actionHandler(handlerContext, job.handleOptions);
-    } else {
-      await job.handler(handlerContext, job.handleOptions);
-    }
+    this.#cronJobService.reloadJobs();
   }
 }
 

package/src/plugins/cronJob/CronJobPluginTypes.ts

@@ -1,7 +1,15 @@
+import { CronJob } from "cron";
+
 export type RunCronJobActionHandlerOptions = {
   code?: string;
 };
 
 export type RunCronJobInput = {
   code?: string;
+  input?: any;
+};
+
+export type NamedCronJobInstance = {
+  code: string;
+  instance: CronJob;
 };

package/src/plugins/cronJob/actionHandlers/runCronJob.ts

@@ -1,6 +1,7 @@
 import { ActionHandlerContext } from "~/core/actionHandler";
 import { RunCronJobActionHandlerOptions, RunCronJobInput } from "../CronJobPluginTypes";
 import type CronJobPlugin from "../CronJobPlugin";
+import CronJobService from "../services/CronJobService";
 
 export const code = "runCronJob";
 
@@ -18,12 +19,21 @@ export async function handler(plugin: CronJobPlugin, ctx: ActionHandlerContext,
     throw new Error(`Cron job code is required.`);
   }
 
-  const job = plugin.getJobConfigurationByCode(input.code);
+  const cronJobService = server.getService<CronJobService>("cronJobService");
+  const job = cronJobService.getJobConfigurationByCode(input.code);
   if (!job) {
     throw new Error(`Cron job with code '${input.code}' was not found.`);
   }
 
-  await plugin.executeJob(server, job);
+  let jobExecutionContext: ActionHandlerContext = {
+    logger: server.getLogger(),
+    routerContext,
+    next: null,
+    server,
+    applicationConfig: null,
+    input: input.input,
+  };
+  await cronJobService.executeJob(jobExecutionContext, job);
 
   response.json({});
 }

package/src/plugins/cronJob/services/CronJobService.ts

@@ -0,0 +1,108 @@
+import { CronJob } from "cron";
+import { IRpdServer } from "~/core/server";
+import { find } from "lodash";
+import { RouteContext } from "~/core/routeContext";
+import { validateLicense } from "~/helpers/licenseHelper";
+import { NamedCronJobInstance } from "../CronJobPluginTypes";
+import { CronJobConfiguration } from "~/types/cron-job-types";
+import { ActionHandlerContext } from "~/core/actionHandler";
+
+export default class CronJobService {
+  #server: IRpdServer;
+  #jobInstances: NamedCronJobInstance[];
+
+  constructor(server: IRpdServer) {
+    this.#server = server;
+  }
+
+  /**
+   * 根据编号获取定时任务配置信息
+   * @param code
+   * @returns
+   */
+  getJobConfigurationByCode(code: string) {
+    return find(this.#server.listCronJobs(), (job) => job.code === code);
+  }
+
+  /**
+   * 重新加载定时任务
+   */
+  reloadJobs() {
+    const server = this.#server;
+
+    if (this.#jobInstances) {
+      for (const job of this.#jobInstances) {
+        job.instance.stop();
+      }
+    }
+
+    this.#jobInstances = [];
+
+    const cronJobs = server.listCronJobs();
+    for (const job of cronJobs) {
+      if (job.disabled) {
+        continue;
+      }
+
+      const jobInstance = CronJob.from({
+        ...(job.jobOptions || {}),
+        cronTime: job.cronTime,
+        onTick: async () => {
+          await this.tryExecuteJob(job);
+        },
+      });
+      jobInstance.start();
+
+      this.#jobInstances.push({
+        code: job.code,
+        instance: jobInstance,
+      });
+    }
+  }
+
+  async tryExecuteJob(job: CronJobConfiguration) {
+    const server = this.#server;
+    const logger = server.getLogger();
+    logger.info(`Executing cron job '${job.code}'...`);
+
+    let handlerContext: ActionHandlerContext = {
+      logger,
+      routerContext: RouteContext.newSystemOperationContext(server),
+      next: null,
+      server,
+      applicationConfig: null,
+      input: null,
+    };
+
+    try {
+      await this.executeJob(handlerContext, job);
+      logger.info(`Completed cron job '${job.code}'...`);
+    } catch (ex: any) {
+      logger.error('Cron job "%s" execution error: %s', job.code, ex.message);
+
+      if (job.onError) {
+        try {
+          await job.onError(handlerContext, ex);
+        } catch (ex) {
+          logger.error('Error handler of cron job "%s" execution failed: %s', job.code, ex.message);
+        }
+      }
+    }
+  }
+
+  /**
+   * 执行指定任务
+   * @param job
+   */
+  async executeJob(handlerContext: ActionHandlerContext, job: CronJobConfiguration) {
+    const server = this.#server;
+    validateLicense(server);
+
+    if (job.actionHandlerCode) {
+      const actionHandler = server.getActionHandlerByCode(job.code);
+      await actionHandler(handlerContext, job.handleOptions);
+    } else {
+      await job.handler(handlerContext, job.handleOptions);
+    }
+  }
+}

package/src/types/cron-job-types.ts

@@ -11,6 +11,11 @@ export interface CronJobConfiguration {
    */
   description?: string;
 
+  /**
+   * 是否禁用
+   */
+  disabled?: boolean;
+
   /**
    * crontab 表达式
    */
@@ -38,6 +43,14 @@ export interface CronJobConfiguration {
    * 处理定时任务时的设置选项
    */
   handleOptions?: any;
+
+  /**
+   * 定时任务执行失败时的处理
+   * @param ctx
+   * @param error
+   * @returns
+   */
+  onError?: (ctx: ActionHandlerContext, error: any) => Promise<void>;
 }
 
 export interface CronJobOptions {

package/src/utilities/timeUtility.ts

@@ -7,3 +7,7 @@ export function getNowString() {
 export function getNowStringWithTimezone() {
   return dayjs().format("YYYY-MM-DD HH:mm:ss.SSSZ");
 }
+
+export function getDateString(timeString) {
+  return dayjs(timeString).format("YYYY-MM-DD");
+}