@ruiapp/rapid-core 0.8.10 → 0.8.12

package/dist/index.js

@@ -2498,6 +2498,9 @@ function getNowStringWithTimezone() {
 }
 function getDateString(timeString) {
     return dayjs__default["default"](timeString).format("YYYY-MM-DD");
+}
+function formatDateTimeWithTimezone(source) {
+    return dayjs__default["default"](source).format("YYYY-MM-DD HH:mm:ss.SSSZ");
 }
 
 // TODO Generate mapper and cache it.
@@ -6260,7 +6263,7 @@ var SequenceAutoIncrementRecord = {
     ],
 };
 
-var pluginModels$6 = [SequenceRule, SequenceAutoIncrementRecord];
+var pluginModels$7 = [SequenceRule, SequenceAutoIncrementRecord];
 
 var generateSn = {
     namespace: "svc",
@@ -6499,7 +6502,7 @@ class SequencePlugin$1 {
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$6 });
+        server.appendApplicationConfig({ models: pluginModels$7 });
     }
     async configureServices(server, applicationConfig) {
         this.#sequenceService = new SequenceService(server);
@@ -6983,7 +6986,7 @@ var AccessToken = {
     ],
 };
 
-var pluginModels$5 = [AccessToken];
+var pluginModels$6 = [AccessToken];
 
 var changePassword = {
     namespace: "auth",
@@ -7103,7 +7106,7 @@ class AuthPlugin {
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$5 });
+        server.appendApplicationConfig({ models: pluginModels$6 });
     }
     async configureServices(server, applicationConfig) {
         this.#authService = new AuthService(server, server.config.jwtKey);
@@ -7378,7 +7381,7 @@ var getLicense$1 = /*#__PURE__*/Object.freeze({
 
 var pluginActionHandlers$6 = [getLicense$1];
 
-var pluginModels$4 = [];
+var pluginModels$5 = [];
 
 var getLicense = {
     namespace: "svc",
@@ -7549,7 +7552,7 @@ class LicensePlugin {
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$4 });
+        server.appendApplicationConfig({ models: pluginModels$5 });
     }
     async configureServices(server, applicationConfig) {
         this.#licenseService = new LicenseService(server, this.#encryptionKey);
@@ -7565,7 +7568,7 @@ class LicensePlugin {
 
 var pluginActionHandlers$5 = [];
 
-var pluginModels$3 = [];
+var pluginModels$4 = [];
 
 var pluginRoutes$4 = [];
 
@@ -7631,7 +7634,7 @@ class MailPlugin {
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$3 });
+        server.appendApplicationConfig({ models: pluginModels$4 });
     }
     async configureServices(server, applicationConfig) {
         this.#mailService = new MailService(server, this.#config.smtpServer);
@@ -7704,7 +7707,7 @@ var Notification = {
     ],
 };
 
-var pluginModels$2 = [Notification];
+var pluginModels$3 = [Notification];
 
 var pluginRoutes$3 = [];
 
@@ -7756,7 +7759,7 @@ class SequencePlugin {
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$2 });
+        server.appendApplicationConfig({ models: pluginModels$3 });
     }
     async configureServices(server, applicationConfig) {
         this.#notificationService = new NotificationService(server);
@@ -8274,7 +8277,7 @@ var UserSettingItemSetting = {
     ],
 };
 
-var pluginModels$1 = [SystemSettingGroupSetting, SystemSettingItem, SystemSettingItemSetting, UserSettingGroupSetting, UserSettingItem, UserSettingItemSetting];
+var pluginModels$2 = [SystemSettingGroupSetting, SystemSettingItem, SystemSettingItemSetting, UserSettingGroupSetting, UserSettingItem, UserSettingItemSetting];
 
 var getUserSettingValues = {
     namespace: "svc",
@@ -8529,7 +8532,7 @@ class SettingPlugin {
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$1 });
+        server.appendApplicationConfig({ models: pluginModels$2 });
     }
     async configureServices(server, applicationConfig) {
         this.#settingService = new SettingService(server);
@@ -8541,31 +8544,154 @@ class SettingPlugin {
     async onApplicationLoaded(server, applicationConfig) { }
 }
 
+var CronJob = {
+    maintainedBy: "cronJob",
+    namespace: "sys",
+    name: "sys_cron_job",
+    singularCode: "sys_cron_job",
+    pluralCode: "sys_cron_jobs",
+    schema: "public",
+    tableName: "sys_cron_jobs",
+    properties: [
+        {
+            name: "id",
+            code: "id",
+            columnName: "id",
+            type: "integer",
+            required: true,
+            autoIncrement: true,
+        },
+        {
+            name: "code",
+            code: "code",
+            columnName: "code",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "description",
+            code: "description",
+            columnName: "description",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "cronTime",
+            code: "cronTime",
+            columnName: "cron_time",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "disabled",
+            code: "disabled",
+            columnName: "disabled",
+            type: "boolean",
+            required: true,
+            defaultValue: "false",
+        },
+        {
+            name: "jobOptions",
+            code: "jobOptions",
+            columnName: "job_options",
+            type: "json",
+            required: false,
+        },
+        {
+            name: "isRunning",
+            code: "isRunning",
+            columnName: "is_running",
+            type: "boolean",
+            required: true,
+            defaultValue: "false",
+        },
+        {
+            name: "nextRunningTime",
+            code: "nextRunningTime",
+            columnName: "next_running_time",
+            type: "datetime",
+            required: false,
+        },
+        {
+            name: "lastRunningTime",
+            code: "lastRunningTime",
+            columnName: "last_running_time",
+            type: "datetime",
+            required: false,
+        },
+        // success, failed, error
+        {
+            name: "lastRunningResult",
+            code: "lastRunningResult",
+            columnName: "last_running_result",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "lastErrorMessage",
+            code: "lastErrorMessage",
+            columnName: "last_error_message",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "lastErrorStack",
+            code: "lastErrorStack",
+            columnName: "last_error_stack",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "actionHandlerCode",
+            code: "actionHandlerCode",
+            columnName: "action_handler_code",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "handler",
+            code: "handler",
+            columnName: "handler",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "handleOptions",
+            code: "handleOptions",
+            columnName: "handle_options",
+            type: "json",
+            required: false,
+        },
+        {
+            name: "onError",
+            code: "onError",
+            columnName: "on_error",
+            type: "text",
+            required: false,
+        },
+    ],
+};
+
+var pluginModels$1 = [CronJob];
+
 const code$1 = "runCronJob";
 async function handler$1(plugin, ctx, options) {
-    const { server, routerContext } = ctx;
-    const { response } = routerContext;
+    const { server, routerContext: routeContext } = ctx;
+    const { response } = routeContext;
     const input = ctx.input;
-    if (options.code) {
+    if (options?.code) {
         input.code = options.code;
     }
     if (!input.code) {
         throw new Error(`Cron job code is required.`);
     }
     const cronJobService = server.getService("cronJobService");
-    const job = cronJobService.getJobConfigurationByCode(input.code);
-    if (!job) {
+    const jobConfig = cronJobService.getJobConfigurationByCode(input.code);
+    if (!jobConfig) {
         throw new Error(`Cron job with code '${input.code}' was not found.`);
     }
-    let jobExecutionContext = {
-        logger: server.getLogger(),
-        routerContext,
-        next: null,
-        server,
-        applicationConfig: null,
-        input: input.input,
-    };
-    await cronJobService.executeJob(jobExecutionContext, job);
+    // running job in background.
+    cronJobService.executeJob(jobConfig, input.input);
     response.json({});
 }
 
@@ -8593,9 +8719,30 @@ var runCronJob = {
 
 var pluginRoutes$1 = [runCronJob];
 
+var cronJobEntityWatchers = [
+    {
+        eventName: "entity.update",
+        modelSingularCode: "sys_cron_job",
+        handler: async (ctx) => {
+            const { server, payload, routerContext: routeContext } = ctx;
+            const cronJobService = server.getService("cronJobService");
+            const changes = payload.changes;
+            const after = payload.after;
+            await cronJobService.updateJobConfig(routeContext, {
+                code: after.code,
+                cronTime: changes.cronTime,
+                disabled: changes.disabled,
+                jobOptions: changes.jobOptions,
+            });
+        },
+    },
+];
+
+var pluginEntityWatchers = [...cronJobEntityWatchers];
+
 class CronJobService {
     #server;
-    #jobInstances;
+    #namedJobInstances;
     constructor(server) {
         this.#server = server;
     }
@@ -8607,79 +8754,207 @@ class CronJobService {
     getJobConfigurationByCode(code) {
         return lodash.find(this.#server.listCronJobs(), (job) => job.code === code);
     }
+    #createJobInstance(job) {
+        return cron.CronJob.from({
+            ...(job.jobOptions || {}),
+            cronTime: job.cronTime,
+            onTick: async () => {
+                await this.executeJob(job);
+            },
+        });
+    }
+    async #startJobInstance(routeContext, jobConfiguration, jobInstance) {
+        const server = this.#server;
+        const jobCode = jobConfiguration.code;
+        const cronJobManager = server.getEntityManager("sys_cron_job");
+        const cronJobInDb = await cronJobManager.findEntity({
+            routeContext,
+            filters: [{ operator: "eq", field: "code", value: jobCode }],
+        });
+        if (cronJobInDb) {
+            let nextRunningTime;
+            nextRunningTime = formatDateTimeWithTimezone(jobInstance.nextDate().toISO());
+            await cronJobManager.updateEntityById({
+                routeContext,
+                id: cronJobInDb.id,
+                entityToSave: {
+                    nextRunningTime,
+                },
+            });
+        }
+        jobInstance.start();
+    }
+    async #setJobNextRunningTime(routeContext, jobCode, nextRunningTime) {
+        const server = this.#server;
+        const cronJobManager = server.getEntityManager("sys_cron_job");
+        const cronJobInDb = await cronJobManager.findEntity({
+            routeContext,
+            filters: [{ operator: "eq", field: "code", value: jobCode }],
+        });
+        await cronJobManager.updateEntityById({
+            routeContext,
+            id: cronJobInDb.id,
+            entityToSave: {
+                nextRunningTime,
+            },
+        });
+    }
     /**
      * 重新加载定时任务
      */
-    reloadJobs() {
+    async reloadJobs() {
         const server = this.#server;
-        if (this.#jobInstances) {
-            for (const job of this.#jobInstances) {
+        const routeContext = RouteContext.newSystemOperationContext(server);
+        if (this.#namedJobInstances) {
+            for (const job of this.#namedJobInstances) {
                 job.instance.stop();
             }
         }
-        this.#jobInstances = [];
-        const cronJobs = server.listCronJobs();
-        for (const job of cronJobs) {
-            if (job.disabled) {
+        this.#namedJobInstances = [];
+        const cronJobManager = server.getEntityManager("sys_cron_job");
+        const cronJobConfigurationsInDb = await cronJobManager.findEntities({ routeContext });
+        const cronJobConfigurations = server.listCronJobs();
+        for (const cronJobConfig of cronJobConfigurations) {
+            const jobCode = cronJobConfig.code;
+            const jobConfigInDb = lodash.find(cronJobConfigurationsInDb, { code: jobCode });
+            if (jobConfigInDb) {
+                overrideJobConfig(cronJobConfig, jobConfigInDb);
+            }
+            if (cronJobConfig.disabled) {
+                await this.#setJobNextRunningTime(routeContext, jobCode, null);
                 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,
+            const jobInstance = this.#createJobInstance(cronJobConfig);
+            await this.#startJobInstance(routeContext, cronJobConfig, jobInstance);
+            this.#namedJobInstances.push({
+                code: jobCode,
                 instance: jobInstance,
             });
         }
     }
-    async tryExecuteJob(job) {
+    /**
+     * 执行指定任务
+     * @param job
+     * @param input
+     */
+    async executeJob(job, input) {
         const server = this.#server;
         const logger = server.getLogger();
-        logger.info(`Executing cron job '${job.code}'...`);
+        const jobCode = job.code;
+        logger.info(`Executing cron job '${jobCode}'...`);
         let handlerContext = {
             logger,
             routerContext: RouteContext.newSystemOperationContext(server),
             next: null,
             server,
             applicationConfig: null,
-            input: null,
+            input,
         };
+        let result;
+        let lastErrorMessage;
+        let lastErrorStack;
         try {
-            await this.executeJob(handlerContext, job);
-            logger.info(`Completed cron job '${job.code}'...`);
+            validateLicense(server);
+            if (job.actionHandlerCode) {
+                const actionHandler = server.getActionHandlerByCode(job.code);
+                await actionHandler(handlerContext, job.handleOptions);
+            }
+            else {
+                await job.handler(handlerContext, job.handleOptions);
+            }
+            result = "success";
+            logger.info(`Completed cron job '${jobCode}'...`);
         }
         catch (ex) {
-            logger.error('Cron job "%s" execution error: %s', job.code, ex.message);
+            logger.error('Cron job "%s" execution error: %s', jobCode, ex.message);
+            if (lodash.isString(ex)) {
+                lastErrorMessage = ex;
+            }
+            else {
+                lastErrorMessage = ex.message;
+                lastErrorStack = ex.stack;
+            }
+            result = "failed";
             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);
+                    logger.error('Error handler of cron job "%s" execution failed: %s', jobCode, ex.message);
+                }
+            }
+        }
+        try {
+            const cronJobManager = server.getEntityManager("sys_cron_job");
+            const cronJobInDb = await cronJobManager.findEntity({
+                filters: [{ operator: "eq", field: "code", value: jobCode }],
+            });
+            if (cronJobInDb) {
+                let nextRunningTime;
+                const namedJobInstance = lodash.find(this.#namedJobInstances, { code: jobCode });
+                if (namedJobInstance && namedJobInstance.instance) {
+                    nextRunningTime = formatDateTimeWithTimezone(namedJobInstance.instance.nextDate().toISO());
                 }
+                await cronJobManager.updateEntityById({
+                    id: cronJobInDb.id,
+                    entityToSave: {
+                        nextRunningTime,
+                        lastRunningResult: result,
+                        lastRunningTime: getNowStringWithTimezone(),
+                        lastErrorMessage,
+                        lastErrorStack,
+                    },
+                });
             }
         }
+        catch (ex) {
+            logger.error("Failed to saving cron job running result. job code: %s, error: %s", jobCode, ex.message);
+        }
     }
-    /**
-     * 执行指定任务
-     * @param job
-     */
-    async executeJob(handlerContext, job) {
+    async updateJobConfig(routeContext, options) {
         const server = this.#server;
-        validateLicense(server);
-        if (job.actionHandlerCode) {
-            const actionHandler = server.getActionHandlerByCode(job.code);
-            await actionHandler(handlerContext, job.handleOptions);
+        const cronJobs = server.listCronJobs();
+        const jobCode = options.code;
+        if (!jobCode) {
+            throw new Error(`options.code is required.`);
+        }
+        const cronJobConfig = lodash.find(cronJobs, { code: jobCode });
+        if (!cronJobConfig) {
+            throw new Error(`Cron job with code "${jobCode}" not found.`);
+        }
+        if (!["cronTime", "disabled", "jobOptions"].some((field) => !lodash.isNil(options[field]))) {
+            return;
+        }
+        overrideJobConfig(cronJobConfig, options);
+        const namedJobInstance = lodash.find(this.#namedJobInstances, { code: jobCode });
+        if (namedJobInstance && namedJobInstance.instance) {
+            namedJobInstance.instance.stop();
+            namedJobInstance.instance = null;
+        }
+        if (cronJobConfig.disabled) {
+            await this.#setJobNextRunningTime(routeContext, jobCode, null);
         }
         else {
-            await job.handler(handlerContext, job.handleOptions);
+            const jobInstance = this.#createJobInstance(cronJobConfig);
+            await this.#startJobInstance(routeContext, cronJobConfig, jobInstance);
+            if (namedJobInstance) {
+                namedJobInstance.instance = jobInstance;
+            }
+            else {
+                this.#namedJobInstances.push({
+                    code: cronJobConfig.code,
+                    instance: jobInstance,
+                });
+            }
         }
     }
+}
+function overrideJobConfig(original, overrides) {
+    ["cronTime", "disabled", "jobOptions"].forEach((field) => {
+        if (!lodash.isNil(overrides[field])) {
+            original[field] = overrides[field];
+        }
+    });
 }
 
 class CronJobPlugin {
@@ -8710,11 +8985,16 @@ class CronJobPlugin {
             server.registerActionHandler(this, actionHandler);
         }
     }
-    async registerEventHandlers(server) { }
+    async registerEventHandlers(server) {
+        for (const entityWatcher of pluginEntityWatchers)
+            server.registerEntityWatcher(entityWatcher);
+    }
     async registerMessageHandlers(server) { }
     async registerTaskProcessors(server) { }
     async onLoadingApplication(server, applicationConfig) { }
-    async configureModels(server, applicationConfig) { }
+    async configureModels(server, applicationConfig) {
+        server.appendApplicationConfig({ models: pluginModels$1 });
+    }
     async configureModelProperties(server, applicationConfig) { }
     async configureServices(server, applicationConfig) {
         this.#cronJobService = new CronJobService(server);
@@ -8723,9 +9003,24 @@ class CronJobPlugin {
     async configureRoutes(server, applicationConfig) {
         server.appendApplicationConfig({ routes: pluginRoutes$1 });
     }
-    async onApplicationLoaded(server, applicationConfig) { }
+    async onApplicationLoaded(server, applicationConfig) {
+        await saveCronJobsToDatabase(server);
+    }
     async onApplicationReady(server, applicationConfig) {
-        this.#cronJobService.reloadJobs();
+        await this.#cronJobService.reloadJobs();
+    }
+}
+async function saveCronJobsToDatabase(server) {
+    const cronJobManager = server.getEntityManager("sys_cron_job");
+    for (const cronJobToSave of server.listCronJobs()) {
+        const currentCronJob = await cronJobManager.findEntity({
+            filters: [{ operator: "eq", field: "code", value: cronJobToSave.code }],
+        });
+        if (!currentCronJob) {
+            await cronJobManager.createEntity({
+                entity: lodash.pick(cronJobToSave, ["code", "description", "cronTime", "disabled"]),
+            });
+        }
     }
 }
 
@@ -9141,6 +9436,7 @@ exports.createJwt = createJwt;
 exports.decodeJwt = decodeJwt;
 exports.deleteCookie = deleteCookie;
 exports.detectChangedFieldsOfEntity = detectChangedFieldsOfEntity;
+exports.formatDateTimeWithTimezone = formatDateTimeWithTimezone;
 exports.generateJwtSecretKey = generateJwtSecretKey;
 exports.getCookies = getCookies;
 exports.getDateString = getDateString;

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

@@ -1,4 +1,5 @@
 import { CronJob } from "cron";
+import { CronJobConfiguration } from "../../types/cron-job-types";
 export type RunCronJobActionHandlerOptions = {
     code?: string;
 };
@@ -10,3 +11,28 @@ export type NamedCronJobInstance = {
     code: string;
     instance: CronJob;
 };
+export type JobRunningResult = "success" | "failed" | "error";
+export type SysCronJob = {
+    id: number;
+    code: string;
+    description: string;
+    cronTime: string;
+    disabled: boolean;
+    jobOptions: CronJobConfiguration["jobOptions"];
+    isRunning: boolean;
+    nextRunningTime: string;
+    lastRunningTime: string;
+    lastRunningResult?: JobRunningResult;
+    lastErrorMessage?: string;
+    lastErrorStack?: string;
+    actionHandlerCode?: string;
+    handler?: string;
+    handleOptions?: Record<string, any>;
+    onError?: string;
+};
+export type UpdateJobConfigOptions = {
+    code: string;
+    cronTime?: string;
+    disabled?: boolean;
+    jobOptions?: CronJobConfiguration["jobOptions"];
+};

package/dist/plugins/cronJob/entityWatchers/cronJobEntityWatchers.d.ts

@@ -0,0 +1,7 @@
+import type { EntityWatchHandlerContext } from "../../../types";
+declare const _default: {
+    eventName: string;
+    modelSingularCode: string;
+    handler: (ctx: EntityWatchHandlerContext<"entity.update">) => Promise<void>;
+}[];
+export default _default;

package/dist/plugins/cronJob/entityWatchers/index.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    eventName: string;
+    modelSingularCode: string;
+    handler: (ctx: import("../../../types").EntityWatchHandlerContext<"entity.update">) => Promise<void>;
+}[];
+export default _default;

package/dist/plugins/cronJob/models/CronJob.d.ts

@@ -0,0 +1,3 @@
+import { RpdDataModel } from "../../../types";
+declare const _default: RpdDataModel;
+export default _default;

package/dist/plugins/cronJob/models/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../..").RpdDataModel[];
+export default _default;

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

@@ -1,6 +1,7 @@
 import { IRpdServer } from "../../../core/server";
+import { RouteContext } from "../../../core/routeContext";
+import { UpdateJobConfigOptions } from "../CronJobPluginTypes";
 import { CronJobConfiguration } from "../../../types/cron-job-types";
-import { ActionHandlerContext } from "../../../core/actionHandler";
 export default class CronJobService {
     #private;
     constructor(server: IRpdServer);
@@ -13,11 +14,12 @@ export default class CronJobService {
     /**
      * 重新加载定时任务
      */
-    reloadJobs(): void;
-    tryExecuteJob(job: CronJobConfiguration): Promise<void>;
+    reloadJobs(): Promise<void>;
     /**
      * 执行指定任务
      * @param job
+     * @param input
      */
-    executeJob(handlerContext: ActionHandlerContext, job: CronJobConfiguration): Promise<void>;
+    executeJob(job: CronJobConfiguration, input?: any): Promise<void>;
+    updateJobConfig(routeContext: RouteContext, options: UpdateJobConfigOptions): Promise<void>;
 }

package/dist/utilities/timeUtility.d.ts

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

package/package.json

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

package/src/plugins/cronJob/CronJobPlugin.ts

@@ -1,6 +1,8 @@
 import type { RpdApplicationConfig } from "~/types";
+import pluginModels from "./models";
 import pluginActionHandlers from "./actionHandlers";
 import pluginRoutes from "./routes";
+import pluginEntityWatchers from "./entityWatchers";
 import {
   IRpdServer,
   RapidPlugin,
@@ -9,6 +11,8 @@ import {
   RpdServerPluginExtendingAbilities,
 } from "~/core/server";
 import CronJobService from "./services/CronJobService";
+import { SysCronJob } from "./CronJobPluginTypes";
+import { pick } from "lodash";
 
 class CronJobPlugin implements RapidPlugin {
   #server: IRpdServer;
@@ -48,15 +52,18 @@ class CronJobPlugin implements RapidPlugin {
     }
   }
 
-  async registerEventHandlers(server: IRpdServer): Promise<any> {}
-
+  async registerEventHandlers(server: IRpdServer): Promise<any> {
+    for (const entityWatcher of pluginEntityWatchers) server.registerEntityWatcher(entityWatcher);
+  }
   async registerMessageHandlers(server: IRpdServer): Promise<any> {}
 
   async registerTaskProcessors(server: IRpdServer): Promise<any> {}
 
   async onLoadingApplication(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
 
-  async configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
+  async configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+    server.appendApplicationConfig({ models: pluginModels });
+  }
 
   async configureModelProperties(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
 
@@ -69,11 +76,29 @@ class CronJobPlugin implements RapidPlugin {
     server.appendApplicationConfig({ routes: pluginRoutes });
   }
 
-  async onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
+  async onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+    await saveCronJobsToDatabase(server);
+  }
 
   async onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-    this.#cronJobService.reloadJobs();
+    await this.#cronJobService.reloadJobs();
   }
 }
 
 export default CronJobPlugin;
+
+async function saveCronJobsToDatabase(server: IRpdServer) {
+  const cronJobManager = server.getEntityManager<SysCronJob>("sys_cron_job");
+
+  for (const cronJobToSave of server.listCronJobs()) {
+    const currentCronJob = await cronJobManager.findEntity({
+      filters: [{ operator: "eq", field: "code", value: cronJobToSave.code }],
+    });
+
+    if (!currentCronJob) {
+      await cronJobManager.createEntity({
+        entity: pick(cronJobToSave, ["code", "description", "cronTime", "disabled"]),
+      });
+    }
+  }
+}

package/src/plugins/cronJob/CronJobPluginTypes.ts

@@ -1,4 +1,5 @@
 import { CronJob } from "cron";
+import { CronJobConfiguration } from "~/types/cron-job-types";
 
 export type RunCronJobActionHandlerOptions = {
   code?: string;
@@ -13,3 +14,31 @@ export type NamedCronJobInstance = {
   code: string;
   instance: CronJob;
 };
+
+export type JobRunningResult = "success" | "failed" | "error";
+
+export type SysCronJob = {
+  id: number;
+  code: string;
+  description: string;
+  cronTime: string;
+  disabled: boolean;
+  jobOptions: CronJobConfiguration["jobOptions"];
+  isRunning: boolean;
+  nextRunningTime: string;
+  lastRunningTime: string;
+  lastRunningResult?: JobRunningResult;
+  lastErrorMessage?: string;
+  lastErrorStack?: string;
+  actionHandlerCode?: string;
+  handler?: string;
+  handleOptions?: Record<string, any>;
+  onError?: string;
+};
+
+export type UpdateJobConfigOptions = {
+  code: string;
+  cronTime?: string;
+  disabled?: boolean;
+  jobOptions?: CronJobConfiguration["jobOptions"];
+};

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

@@ -6,12 +6,12 @@ import CronJobService from "../services/CronJobService";
 export const code = "runCronJob";
 
 export async function handler(plugin: CronJobPlugin, ctx: ActionHandlerContext, options: RunCronJobActionHandlerOptions) {
-  const { server, routerContext } = ctx;
-  const { response } = routerContext;
+  const { server, routerContext: routeContext } = ctx;
+  const { response } = routeContext;
 
   const input: RunCronJobInput = ctx.input;
 
-  if (options.code) {
+  if (options?.code) {
     input.code = options.code;
   }
 
@@ -20,20 +20,13 @@ export async function handler(plugin: CronJobPlugin, ctx: ActionHandlerContext,
   }
 
   const cronJobService = server.getService<CronJobService>("cronJobService");
-  const job = cronJobService.getJobConfigurationByCode(input.code);
-  if (!job) {
+  const jobConfig = cronJobService.getJobConfigurationByCode(input.code);
+  if (!jobConfig) {
     throw new Error(`Cron job with code '${input.code}' was not found.`);
   }
 
-  let jobExecutionContext: ActionHandlerContext = {
-    logger: server.getLogger(),
-    routerContext,
-    next: null,
-    server,
-    applicationConfig: null,
-    input: input.input,
-  };
-  await cronJobService.executeJob(jobExecutionContext, job);
+  // running job in background.
+  cronJobService.executeJob(jobConfig, input.input);
 
   response.json({});
 }

package/src/plugins/cronJob/entityWatchers/cronJobEntityWatchers.ts

@@ -0,0 +1,24 @@
+import type { EntityWatcher, EntityWatchHandlerContext } from "~/types";
+import CronJobService from "../services/CronJobService";
+import { SysCronJob } from "../CronJobPluginTypes";
+
+export default [
+  {
+    eventName: "entity.update",
+    modelSingularCode: "sys_cron_job",
+    handler: async (ctx: EntityWatchHandlerContext<"entity.update">) => {
+      const { server, payload, routerContext: routeContext } = ctx;
+
+      const cronJobService = server.getService<CronJobService>("cronJobService");
+
+      const changes: Partial<SysCronJob> = payload.changes;
+      const after: SysCronJob = payload.after;
+      await cronJobService.updateJobConfig(routeContext, {
+        code: after.code,
+        cronTime: changes.cronTime,
+        disabled: changes.disabled,
+        jobOptions: changes.jobOptions,
+      });
+    },
+  },
+] satisfies EntityWatcher<any>[];

package/src/plugins/cronJob/entityWatchers/index.ts

@@ -0,0 +1,4 @@
+import { EntityWatcher } from "~/types";
+import cronJobEntityWatchers from "./cronJobEntityWatchers";
+
+export default [...cronJobEntityWatchers] satisfies EntityWatcher<any>[];

package/src/plugins/cronJob/models/CronJob.ts

@@ -0,0 +1,129 @@
+import { RpdDataModel } from "~/types";
+
+export default {
+  maintainedBy: "cronJob",
+  namespace: "sys",
+  name: "sys_cron_job",
+  singularCode: "sys_cron_job",
+  pluralCode: "sys_cron_jobs",
+  schema: "public",
+  tableName: "sys_cron_jobs",
+  properties: [
+    {
+      name: "id",
+      code: "id",
+      columnName: "id",
+      type: "integer",
+      required: true,
+      autoIncrement: true,
+    },
+    {
+      name: "code",
+      code: "code",
+      columnName: "code",
+      type: "text",
+      required: true,
+    },
+    {
+      name: "description",
+      code: "description",
+      columnName: "description",
+      type: "text",
+      required: false,
+    },
+    {
+      name: "cronTime",
+      code: "cronTime",
+      columnName: "cron_time",
+      type: "text",
+      required: true,
+    },
+    {
+      name: "disabled",
+      code: "disabled",
+      columnName: "disabled",
+      type: "boolean",
+      required: true,
+      defaultValue: "false",
+    },
+    {
+      name: "jobOptions",
+      code: "jobOptions",
+      columnName: "job_options",
+      type: "json",
+      required: false,
+    },
+    {
+      name: "isRunning",
+      code: "isRunning",
+      columnName: "is_running",
+      type: "boolean",
+      required: true,
+      defaultValue: "false",
+    },
+    {
+      name: "nextRunningTime",
+      code: "nextRunningTime",
+      columnName: "next_running_time",
+      type: "datetime",
+      required: false,
+    },
+    {
+      name: "lastRunningTime",
+      code: "lastRunningTime",
+      columnName: "last_running_time",
+      type: "datetime",
+      required: false,
+    },
+    // success, failed, error
+    {
+      name: "lastRunningResult",
+      code: "lastRunningResult",
+      columnName: "last_running_result",
+      type: "text",
+      required: false,
+    },
+    {
+      name: "lastErrorMessage",
+      code: "lastErrorMessage",
+      columnName: "last_error_message",
+      type: "text",
+      required: false,
+    },
+    {
+      name: "lastErrorStack",
+      code: "lastErrorStack",
+      columnName: "last_error_stack",
+      type: "text",
+      required: false,
+    },
+    {
+      name: "actionHandlerCode",
+      code: "actionHandlerCode",
+      columnName: "action_handler_code",
+      type: "text",
+      required: false,
+    },
+    {
+      name: "handler",
+      code: "handler",
+      columnName: "handler",
+      type: "text",
+      required: false,
+    },
+    {
+      name: "handleOptions",
+      code: "handleOptions",
+      columnName: "handle_options",
+      type: "json",
+      required: false,
+    },
+    {
+      name: "onError",
+      code: "onError",
+      columnName: "on_error",
+      type: "text",
+      required: false,
+    },
+  ],
+} as RpdDataModel;

package/src/plugins/cronJob/models/index.ts

@@ -0,0 +1,3 @@
+import CronJob from "./CronJob";
+
+export default [CronJob];

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

@@ -1,15 +1,16 @@
 import { CronJob } from "cron";
 import { IRpdServer } from "~/core/server";
-import { find } from "lodash";
+import { find, isNil, isString, Many } from "lodash";
 import { RouteContext } from "~/core/routeContext";
 import { validateLicense } from "~/helpers/licenseHelper";
-import { NamedCronJobInstance } from "../CronJobPluginTypes";
+import { JobRunningResult, NamedCronJobInstance, SysCronJob, UpdateJobConfigOptions } from "../CronJobPluginTypes";
 import { CronJobConfiguration } from "~/types/cron-job-types";
 import { ActionHandlerContext } from "~/core/actionHandler";
+import { formatDateTimeWithTimezone, getNowStringWithTimezone } from "~/utilities/timeUtility";
 
 export default class CronJobService {
   #server: IRpdServer;
-  #jobInstances: NamedCronJobInstance[];
+  #namedJobInstances: NamedCronJobInstance[];
 
   constructor(server: IRpdServer) {
     this.#server = server;
@@ -24,46 +25,109 @@ export default class CronJobService {
     return find(this.#server.listCronJobs(), (job) => job.code === code);
   }
 
+  #createJobInstance(job: CronJobConfiguration) {
+    return CronJob.from({
+      ...(job.jobOptions || {}),
+      cronTime: job.cronTime,
+      onTick: async () => {
+        await this.executeJob(job);
+      },
+    });
+  }
+
+  async #startJobInstance(routeContext: RouteContext, jobConfiguration: CronJobConfiguration, jobInstance: CronJob) {
+    const server = this.#server;
+    const jobCode = jobConfiguration.code;
+    const cronJobManager = server.getEntityManager<SysCronJob>("sys_cron_job");
+    const cronJobInDb = await cronJobManager.findEntity({
+      routeContext,
+      filters: [{ operator: "eq", field: "code", value: jobCode }],
+    });
+
+    if (cronJobInDb) {
+      let nextRunningTime: string | null;
+      nextRunningTime = formatDateTimeWithTimezone(jobInstance.nextDate().toISO());
+
+      await cronJobManager.updateEntityById({
+        routeContext,
+        id: cronJobInDb.id,
+        entityToSave: {
+          nextRunningTime,
+        } as Partial<SysCronJob>,
+      });
+    }
+
+    jobInstance.start();
+  }
+
+  async #setJobNextRunningTime(routeContext: RouteContext, jobCode: string, nextRunningTime: string | null) {
+    const server = this.#server;
+    const cronJobManager = server.getEntityManager<SysCronJob>("sys_cron_job");
+    const cronJobInDb = await cronJobManager.findEntity({
+      routeContext,
+      filters: [{ operator: "eq", field: "code", value: jobCode }],
+    });
+    await cronJobManager.updateEntityById({
+      routeContext,
+      id: cronJobInDb.id,
+      entityToSave: {
+        nextRunningTime,
+      } as Partial<SysCronJob>,
+    });
+  }
+
   /**
    * 重新加载定时任务
    */
-  reloadJobs() {
+  async reloadJobs() {
     const server = this.#server;
+    const routeContext = RouteContext.newSystemOperationContext(server);
 
-    if (this.#jobInstances) {
-      for (const job of this.#jobInstances) {
+    if (this.#namedJobInstances) {
+      for (const job of this.#namedJobInstances) {
         job.instance.stop();
       }
     }
 
-    this.#jobInstances = [];
+    this.#namedJobInstances = [];
 
-    const cronJobs = server.listCronJobs();
-    for (const job of cronJobs) {
-      if (job.disabled) {
+    const cronJobManager = server.getEntityManager<SysCronJob>("sys_cron_job");
+    const cronJobConfigurationsInDb = await cronJobManager.findEntities({ routeContext });
+
+    const cronJobConfigurations = server.listCronJobs();
+    for (const cronJobConfig of cronJobConfigurations) {
+      const jobCode = cronJobConfig.code;
+      const jobConfigInDb = find(cronJobConfigurationsInDb, { code: jobCode });
+      if (jobConfigInDb) {
+        overrideJobConfig(cronJobConfig, jobConfigInDb);
+      }
+
+      if (cronJobConfig.disabled) {
+        await this.#setJobNextRunningTime(routeContext, jobCode, null);
         continue;
       }
 
-      const jobInstance = CronJob.from({
-        ...(job.jobOptions || {}),
-        cronTime: job.cronTime,
-        onTick: async () => {
-          await this.tryExecuteJob(job);
-        },
-      });
-      jobInstance.start();
+      const jobInstance = this.#createJobInstance(cronJobConfig);
+      await this.#startJobInstance(routeContext, cronJobConfig, jobInstance);
 
-      this.#jobInstances.push({
-        code: job.code,
+      this.#namedJobInstances.push({
+        code: jobCode,
         instance: jobInstance,
       });
     }
   }
 
-  async tryExecuteJob(job: CronJobConfiguration) {
+  /**
+   * 执行指定任务
+   * @param job
+   * @param input
+   */
+  async executeJob(job: CronJobConfiguration, input?: any) {
     const server = this.#server;
     const logger = server.getLogger();
-    logger.info(`Executing cron job '${job.code}'...`);
+
+    const jobCode = job.code;
+    logger.info(`Executing cron job '${jobCode}'...`);
 
     let handlerContext: ActionHandlerContext = {
       logger,
@@ -71,38 +135,118 @@ export default class CronJobService {
       next: null,
       server,
       applicationConfig: null,
-      input: null,
+      input,
     };
 
+    let result: JobRunningResult;
+    let lastErrorMessage: string | null;
+    let lastErrorStack: string | null;
     try {
-      await this.executeJob(handlerContext, job);
-      logger.info(`Completed cron job '${job.code}'...`);
+      validateLicense(server);
+
+      if (job.actionHandlerCode) {
+        const actionHandler = server.getActionHandlerByCode(job.code);
+        await actionHandler(handlerContext, job.handleOptions);
+      } else {
+        await job.handler(handlerContext, job.handleOptions);
+      }
+      result = "success";
+      logger.info(`Completed cron job '${jobCode}'...`);
     } catch (ex: any) {
-      logger.error('Cron job "%s" execution error: %s', job.code, ex.message);
+      logger.error('Cron job "%s" execution error: %s', jobCode, ex.message);
+      if (isString(ex)) {
+        lastErrorMessage = ex;
+      } else {
+        lastErrorMessage = ex.message;
+        lastErrorStack = ex.stack;
+      }
+      result = "failed";
 
       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);
+          logger.error('Error handler of cron job "%s" execution failed: %s', jobCode, ex.message);
         }
       }
     }
+
+    try {
+      const cronJobManager = server.getEntityManager<SysCronJob>("sys_cron_job");
+      const cronJobInDb = await cronJobManager.findEntity({
+        filters: [{ operator: "eq", field: "code", value: jobCode }],
+      });
+
+      if (cronJobInDb) {
+        let nextRunningTime: string | null;
+        const namedJobInstance = find(this.#namedJobInstances, { code: jobCode });
+        if (namedJobInstance && namedJobInstance.instance) {
+          nextRunningTime = formatDateTimeWithTimezone(namedJobInstance.instance.nextDate().toISO());
+        }
+
+        await cronJobManager.updateEntityById({
+          id: cronJobInDb.id,
+          entityToSave: {
+            nextRunningTime,
+            lastRunningResult: result,
+            lastRunningTime: getNowStringWithTimezone(),
+            lastErrorMessage,
+            lastErrorStack,
+          } as Partial<SysCronJob>,
+        });
+      }
+    } catch (ex: any) {
+      logger.error("Failed to saving cron job running result. job code: %s, error: %s", jobCode, ex.message);
+    }
   }
 
-  /**
-   * 执行指定任务
-   * @param job
-   */
-  async executeJob(handlerContext: ActionHandlerContext, job: CronJobConfiguration) {
+  async updateJobConfig(routeContext: RouteContext, options: UpdateJobConfigOptions) {
     const server = this.#server;
-    validateLicense(server);
+    const cronJobs = server.listCronJobs();
+    const jobCode = options.code;
+    if (!jobCode) {
+      throw new Error(`options.code is required.`);
+    }
+
+    const cronJobConfig = find(cronJobs, { code: jobCode });
+    if (!cronJobConfig) {
+      throw new Error(`Cron job with code "${jobCode}" not found.`);
+    }
 
-    if (job.actionHandlerCode) {
-      const actionHandler = server.getActionHandlerByCode(job.code);
-      await actionHandler(handlerContext, job.handleOptions);
+    if (!(["cronTime", "disabled", "jobOptions"] as (keyof typeof options)[]).some((field) => !isNil(options[field]))) {
+      return;
+    }
+
+    overrideJobConfig(cronJobConfig, options);
+
+    const namedJobInstance = find(this.#namedJobInstances, { code: jobCode });
+    if (namedJobInstance && namedJobInstance.instance) {
+      namedJobInstance.instance.stop();
+      namedJobInstance.instance = null;
+    }
+
+    if (cronJobConfig.disabled) {
+      await this.#setJobNextRunningTime(routeContext, jobCode, null);
     } else {
-      await job.handler(handlerContext, job.handleOptions);
+      const jobInstance = this.#createJobInstance(cronJobConfig);
+      await this.#startJobInstance(routeContext, cronJobConfig, jobInstance);
+
+      if (namedJobInstance) {
+        namedJobInstance.instance = jobInstance;
+      } else {
+        this.#namedJobInstances.push({
+          code: cronJobConfig.code,
+          instance: jobInstance,
+        });
+      }
     }
   }
 }
+
+function overrideJobConfig(original: Partial<SysCronJob> | CronJobConfiguration, overrides: Partial<SysCronJob>) {
+  (["cronTime", "disabled", "jobOptions"] as (keyof typeof overrides)[]).forEach((field: string) => {
+    if (!isNil(overrides[field])) {
+      original[field] = overrides[field];
+    }
+  });
+}

package/src/utilities/timeUtility.ts

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