midway-fatcms 0.0.1-beta.12 → 0.0.1-beta.13

package/.eslintrc.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./node_modules/mwts/",
+  "ignorePatterns": ["node_modules", "dist", "test", "jest.config.js", "typings"],
+  "env": {
+    "jest": true
+  },
+  "rules": {
+    "max-len":"off"
+  }
+}

package/.prettierrc.js

@@ -0,0 +1,4 @@
+module.exports = {
+  ...require('mwts/.prettierrc.json'),
+  printWidth: 500, // 与ESLint的max-len保持一致
+}

package/dist/configuration.js

@@ -54,7 +54,7 @@ let ContainerLifeCycle = class ContainerLifeCycle {
         const config = this.app.getConfig();
         if (config.fatcmsScheduleService) {
             // 启动定时任务
-            const scheduleServiceList = ['proxyApiLoadService', 'workbenchService', 'visitStatService'];
+            const scheduleServiceList = ['proxyApiLoadService', 'workbenchService', 'visitStatService', 'asyncTaskRunnerService'];
             await (0, schedule_1.startSchedule)(this.app, scheduleServiceList);
             logger.info('ContainerLifeCycle ==> onReady 启动定时任务 ');
         }
@@ -71,6 +71,7 @@ __decorate([
 ], ContainerLifeCycle.prototype, "app", void 0);
 ContainerLifeCycle = __decorate([
     (0, core_1.Configuration)({
+        // namespace: 'fatcms',
         imports: [
             koa,
             validate,

package/dist/controller/gateway/AsyncTaskController.d.ts

@@ -0,0 +1,14 @@
+import { Context } from '@midwayjs/koa';
+import { BaseApiController } from '../base/BaseApiController';
+/**
+ * 异步任务框架
+ */
+export declare class AsyncTaskController extends BaseApiController {
+    protected ctx: Context;
+    private asyncTaskService;
+    getMyTasks(): Promise<import("../../libs/crud-pro/models/ExecuteContext").ExecuteContext>;
+    createTask(): Promise<import("../../libs/crud-pro/models/ExecuteContext").ExecuteContext>;
+    cancelTask(id: number): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/controller/gateway/AsyncTaskController.js

@@ -0,0 +1,97 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncTaskController = void 0;
+const core_1 = require("@midwayjs/core");
+const BaseApiController_1 = require("../base/BaseApiController");
+const AsyncTaskService_1 = require("../../service/asyncTask/AsyncTaskService");
+const AsyncTaskModel_1 = require("../../models/AsyncTaskModel");
+const keys_1 = require("../../libs/crud-pro/models/keys");
+const SystemTables_1 = require("../../models/SystemTables");
+const exceptions_1 = require("../../libs/crud-pro/exceptions");
+function fixCancelBodyData(body, id) {
+    if (!body.data || !body.condition) {
+        throw new exceptions_1.CommonException("参数不正确");
+    }
+    // fix condition
+    const conditionObj = (body.condition || {});
+    conditionObj.id = id;
+    body.condition = conditionObj;
+    // fix data
+    const dataObj = (body.data || {});
+    dataObj.task_status = AsyncTaskModel_1.TaskStatus.CANCELLED;
+    body.data = dataObj;
+}
+function fixCreateBodyData(body) {
+    if (!body.data) {
+        throw new exceptions_1.CommonException("参数不正确");
+    }
+    // fix data
+    const dataObj = (body.data || {});
+    dataObj.task_status = AsyncTaskModel_1.TaskStatus.PENDING;
+}
+/**
+ * 异步任务框架
+ */
+let AsyncTaskController = class AsyncTaskController extends BaseApiController_1.BaseApiController {
+    // 获取任务列表
+    async getMyTasks() {
+        return this.executeSysSimpleSQL(SystemTables_1.SystemTables.sys_async_tasks, keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_PAGE);
+    }
+    // 创建任务
+    async createTask() {
+        fixCreateBodyData(this.ctx.request.body);
+        const res = await this.executeSysSimpleSQL(SystemTables_1.SystemTables.sys_async_tasks, keys_1.KeysOfSimpleSQL.SIMPLE_INSERT);
+        await this.asyncTaskService.startTask();
+        return res;
+    }
+    // 取消任务
+    async cancelTask(id) {
+        fixCancelBodyData(this.ctx.request.body, id);
+        await this.asyncTaskService.cancelTask(id);
+        await this.executeSysSimpleSQL(SystemTables_1.SystemTables.sys_async_tasks, keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE);
+        return { success: true };
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", Object)
+], AsyncTaskController.prototype, "ctx", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", AsyncTaskService_1.AsyncTaskService)
+], AsyncTaskController.prototype, "asyncTaskService", void 0);
+__decorate([
+    (0, core_1.Get)('/getMyTasks'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], AsyncTaskController.prototype, "getMyTasks", null);
+__decorate([
+    (0, core_1.Post)('/createTask'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], AsyncTaskController.prototype, "createTask", null);
+__decorate([
+    (0, core_1.Post)('/cancelTask'),
+    __param(0, (0, core_1.Query)('id')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Promise)
+], AsyncTaskController.prototype, "cancelTask", null);
+AsyncTaskController = __decorate([
+    (0, core_1.Controller)('/ns/gw/AsyncTask')
+], AsyncTaskController);
+exports.AsyncTaskController = AsyncTaskController;

package/dist/libs/utils/errorToString.d.ts

@@ -0,0 +1,2 @@
+declare function errorToString(error: any): string;
+export { errorToString };

package/dist/libs/utils/errorToString.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorToString = void 0;
+function errorToString(error) {
+    var _a;
+    // 处理非错误对象的情况
+    if (typeof error === 'undefined') {
+        return 'Error: undefined was thrown';
+    }
+    if (error === null) {
+        return 'Error: null was thrown';
+    }
+    // 处理原始值类型
+    const primitiveTypes = ['string', 'number', 'boolean', 'symbol'];
+    if (primitiveTypes.includes(typeof error)) {
+        return `Error: A primitive value was thrown\nValue: ${String(error)}`;
+    }
+    // 处理 Error 对象
+    if (error instanceof Error) {
+        const errorDetails = [];
+        errorDetails.push(`Error: ${error.name || 'Error'}`);
+        errorDetails.push(`Message: ${error.message || 'No error message'}`);
+        if (error.stack) {
+            errorDetails.push('Stack Trace:');
+            errorDetails.push(error.stack);
+        }
+        const extraProperties = ['code', 'fileName', 'lineNumber', 'columnNumber'];
+        extraProperties.forEach(prop => {
+            if (error[prop] !== undefined) {
+                errorDetails.push(`${prop}: ${error[prop]}`);
+            }
+        });
+        const customProps = Object.keys(error).filter(key => !['name', 'message', 'stack', ...extraProperties].includes(key));
+        if (customProps.length > 0) {
+            errorDetails.push('Custom Properties:');
+            customProps.forEach(prop => {
+                try {
+                    const value = JSON.stringify(error[prop], null, 2) || String(error[prop]);
+                    errorDetails.push(`  ${prop}: ${value}`);
+                }
+                catch (e) {
+                    errorDetails.push(`  ${prop}: [Object cannot be serialized]`);
+                }
+            });
+        }
+        return errorDetails.join('\n');
+    }
+    // 处理普通对象
+    try {
+        const objectDetails = JSON.stringify(error, null, 2);
+        return `Error: A plain object was thrown\nObject: ${objectDetails}`;
+    }
+    catch (e) {
+        return `Error: An object was thrown but could not be serialized\nType: ${((_a = error.constructor) === null || _a === void 0 ? void 0 : _a.name) || 'Unknown'}`;
+    }
+}
+exports.errorToString = errorToString;

package/dist/middleware/global.middleware.js

@@ -186,13 +186,23 @@ async function trackRequest(ctx) {
         console.error('trackRequestError', e);
     }
 }
+const excludePathPrefix = [
+    '/ns/static/',
+    '/ns/api/helpers'
+];
 /**
  * 全局中间件
  */
 let GlobalMiddleware = class GlobalMiddleware {
     match(ctx) {
         const path = ctx.path;
-        return !(path.startsWith('/ns/static/'));
+        for (let i = 0; i < excludePathPrefix.length; i++) {
+            const excludePathPrefix1 = excludePathPrefix[i];
+            if (path.startsWith(excludePathPrefix1)) {
+                return false;
+            }
+        }
+        return true;
     }
     resolve() {
         return async (ctx, next) => {

package/dist/models/AsyncTaskModel.d.ts

@@ -0,0 +1,65 @@
+export interface SysAsyncTaskEntity {
+    id: number;
+    task_uuid: string;
+    task_name: string;
+    task_description: string | null;
+    task_type: string;
+    task_status: TaskStatus;
+    input_params: any;
+    output_result: any | null;
+    input_file_path: string | null;
+    input_file_format: FileFormat | null;
+    input_file_size: number | null;
+    output_file_path: string | null;
+    output_file_format: FileFormat | null;
+    output_file_size: number | null;
+    input_total_records: number | null;
+    output_total_records: number | null;
+    processed_records: number;
+    progress: number;
+    error_message: string | null;
+    error_records: any | null;
+    created_by: string | null;
+    priority: number;
+    retry_count: number;
+    max_retries: number;
+    parent_task_id: number | null;
+    created_at: Date;
+    started_at: Date | null;
+    completed_at: Date | null;
+    updated_at: Date;
+    expired_at: Date | null;
+}
+export declare enum TaskStatus {
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    SUCCEEDED = "SUCCEEDED",
+    FAILED = "FAILED",
+    CANCELLED = "CANCELLED",
+    PAUSED = "PAUSED"
+}
+export declare enum FileFormat {
+    XLSX = "xlsx",
+    CSV = "csv",
+    JSON = "json",
+    PDF = "pdf",
+    TXT = "txt",
+    XML = "xml",
+    ZIP = "zip",
+    HTML = "html",
+    PNG = "png",
+    JPG = "jpg"
+}
+export interface ITaskHandler {
+    execute(ctx: TaskContext): Promise<void>;
+}
+export interface TaskContext {
+    task: SysAsyncTaskEntity;
+}
+export interface TaskHandlerConfig {
+    taskType: string;
+    handler: ITaskHandler;
+    maxRetries?: number;
+    priority?: number;
+    expireSeconds?: number;
+}

package/dist/models/AsyncTaskModel.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileFormat = exports.TaskStatus = void 0;
+var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus["PENDING"] = "PENDING";
+    TaskStatus["RUNNING"] = "RUNNING";
+    TaskStatus["SUCCEEDED"] = "SUCCEEDED";
+    TaskStatus["FAILED"] = "FAILED";
+    TaskStatus["CANCELLED"] = "CANCELLED";
+    TaskStatus["PAUSED"] = "PAUSED";
+})(TaskStatus = exports.TaskStatus || (exports.TaskStatus = {}));
+var FileFormat;
+(function (FileFormat) {
+    FileFormat["XLSX"] = "xlsx";
+    FileFormat["CSV"] = "csv";
+    FileFormat["JSON"] = "json";
+    FileFormat["PDF"] = "pdf";
+    FileFormat["TXT"] = "txt";
+    FileFormat["XML"] = "xml";
+    FileFormat["ZIP"] = "zip";
+    FileFormat["HTML"] = "html";
+    FileFormat["PNG"] = "png";
+    FileFormat["JPG"] = "jpg";
+})(FileFormat = exports.FileFormat || (exports.FileFormat = {}));

package/dist/models/SystemTables.d.ts

@@ -20,5 +20,6 @@ export declare const SystemTables: {
     sys_anyapi: string;
     sys_proxyapi: string;
     sys_visit_stats: string;
+    sys_async_tasks: string;
 };
 export declare const SystemDevOpsWorkbench = "devops";

package/dist/models/SystemTables.js

@@ -23,5 +23,6 @@ exports.SystemTables = {
     sys_anyapi: 'sys_anyapi',
     sys_proxyapi: 'sys_proxyapi',
     sys_visit_stats: 'sys_visit_stats',
+    sys_async_tasks: 'sys_async_tasks',
 };
 exports.SystemDevOpsWorkbench = 'devops';

package/dist/schedule/index.d.ts

@@ -1,3 +1,4 @@
 import * as koa from '@midwayjs/koa';
+declare function runSchedule(app: koa.Application, serviceList: string[]): Promise<void>;
 declare function startSchedule(app: koa.Application, serviceList: string[]): Promise<void>;
-export { startSchedule };
+export { startSchedule, runSchedule };

package/dist/schedule/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startSchedule = void 0;
+exports.runSchedule = exports.startSchedule = void 0;
 const contextLogger_1 = require("../models/contextLogger");
 const Transaction_1 = require("../libs/crud-pro/models/Transaction");
 const userSession_1 = require("../models/userSession");
@@ -60,6 +60,7 @@ async function runSchedule(app, serviceList) {
         }
     }
 }
+exports.runSchedule = runSchedule;
 async function startSchedule(app, serviceList) {
     await runSchedule(app, serviceList);
     setInterval(() => {

package/dist/service/asyncTask/AsyncTaskRunnerService.d.ts

@@ -0,0 +1,8 @@
+import { Context } from '@midwayjs/koa';
+import { BaseService } from "../../service/base/BaseService";
+import { IScheduleService } from "../../interface";
+export declare class AsyncTaskRunnerService extends BaseService implements IScheduleService {
+    protected ctx: Context;
+    private curdProService;
+    runBySchedule(): Promise<void>;
+}

package/dist/service/asyncTask/AsyncTaskRunnerService.js

@@ -0,0 +1,110 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncTaskRunnerService = void 0;
+const core_1 = require("@midwayjs/core");
+const BaseService_1 = require("../../service/base/BaseService");
+const CurdProService_1 = require("../../service/curd/CurdProService");
+const AsyncTaskModel_1 = require("../../models/AsyncTaskModel");
+const global_config_1 = require("../../libs/global-config/global-config");
+const SystemTables_1 = require("../../models/SystemTables");
+const keys_1 = require("../../libs/crud-pro/models/keys");
+const errorToString_1 = require("../../libs/utils/errorToString");
+class AsyncTaskRunner {
+    constructor() {
+        this.isBusy = false;
+        this.taskHandlerMap = new Map();
+    }
+    async executeTaskList(taskList) {
+        if (!taskList || taskList.length === 0) {
+            return;
+        }
+        this.isBusy = true;
+        for (let i = 0; i < taskList.length; i++) {
+            const taskElement = taskList[i];
+            try {
+                await this.executeTask(taskElement);
+                taskElement.task_status = AsyncTaskModel_1.TaskStatus.SUCCEEDED;
+            }
+            catch (error) {
+                taskElement.task_status = AsyncTaskModel_1.TaskStatus.FAILED;
+                taskElement.error_message = (0, errorToString_1.errorToString)(error);
+            }
+        }
+    }
+    async executeTask(taskElement) {
+        const taskType = taskElement.task_type;
+        const taskHandler = this.taskHandlerMap.get(taskType);
+        if (!taskHandler) {
+            throw new Error('TaskHandler not found , taskType = ' + taskType);
+        }
+        await taskHandler.execute({ task: taskElement });
+    }
+}
+const ASYNC_TASK_RUNNER = new AsyncTaskRunner();
+const LOCK_KEY_ASYNC_TASK_RUNNER = "LOCK_KEY_ASYNC_TASK_RUNNER";
+let AsyncTaskRunnerService = class AsyncTaskRunnerService extends BaseService_1.BaseService {
+    async runBySchedule() {
+        if (ASYNC_TASK_RUNNER.isBusy) {
+            return Promise.resolve();
+        }
+        const lock = await this.redisService.set(LOCK_KEY_ASYNC_TASK_RUNNER, 1, "EX", 3600, "NX");
+        if (lock !== 'OK') {
+            return Promise.resolve();
+        }
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        const queryRes = await this.curdProService.executeCrudByCfg({
+            condition: {
+                task_status: AsyncTaskModel_1.TaskStatus.PENDING
+            },
+            limit: 10
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_async_tasks,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_PAGE,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+        });
+        const taskList = queryRes.getResRows();
+        if (taskList.length === 0) {
+            return Promise.resolve();
+        }
+        const taskIds = taskList.map(elem => elem.id).filter(Boolean);
+        await this.curdProService.executeCrudByCfg({
+            condition: {
+                id: {
+                    "$in": taskIds
+                }
+            },
+            data: {
+                task_status: AsyncTaskModel_1.TaskStatus.RUNNING
+            }
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_async_tasks,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+        });
+        ASYNC_TASK_RUNNER.executeTaskList(taskList);
+        return Promise.resolve();
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", Object)
+], AsyncTaskRunnerService.prototype, "ctx", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdProService_1.CurdProService)
+], AsyncTaskRunnerService.prototype, "curdProService", void 0);
+AsyncTaskRunnerService = __decorate([
+    (0, core_1.Provide)()
+], AsyncTaskRunnerService);
+exports.AsyncTaskRunnerService = AsyncTaskRunnerService;

package/dist/service/asyncTask/AsyncTaskService.d.ts

@@ -0,0 +1,7 @@
+import { Context } from '@midwayjs/koa';
+import { BaseService } from "../../service/base/BaseService";
+export declare class AsyncTaskService extends BaseService {
+    protected ctx: Context;
+    startTask(): Promise<void>;
+    cancelTask(id: number): Promise<void>;
+}

package/dist/service/asyncTask/AsyncTaskService.js

@@ -0,0 +1,32 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncTaskService = void 0;
+const core_1 = require("@midwayjs/core");
+const BaseService_1 = require("../../service/base/BaseService");
+const schedule_1 = require("../../schedule");
+let AsyncTaskService = class AsyncTaskService extends BaseService_1.BaseService {
+    async startTask() {
+        (0, schedule_1.runSchedule)(this.app, ['asyncTaskRunnerService']).then(schedule => {
+            console.log(schedule);
+        });
+    }
+    async cancelTask(id) {
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", Object)
+], AsyncTaskService.prototype, "ctx", void 0);
+AsyncTaskService = __decorate([
+    (0, core_1.Provide)()
+], AsyncTaskService);
+exports.AsyncTaskService = AsyncTaskService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "midway-fatcms",
-  "version": "0.0.1-beta.12",
+  "version": "0.0.1-beta.13",
   "description": "This is a midway component sample",
   "main": "dist/index.js",
   "typings": "index.d.ts",
@@ -23,7 +23,10 @@
     "src/**/*.txt",
     "src/**/*.html",
     "src/**/*.ico",
-    "index.d.ts"
+    "index.d.ts",
+    "tsconfig.json",
+    ".prettierrc.js",
+    ".eslintrc.json"
   ],
   "license": "MIT",
   "devDependencies": {

package/src/configuration.ts

@@ -17,6 +17,7 @@ import { startSchedule } from './schedule';
 import { privateAES } from './libs/utils/crypto-utils';
 
 @Configuration({
+  // namespace: 'fatcms',
   imports: [
     koa,
     validate,
@@ -67,7 +68,7 @@ export class ContainerLifeCycle {
 
     if (config.fatcmsScheduleService) {
       // 启动定时任务
-      const scheduleServiceList = ['proxyApiLoadService', 'workbenchService', 'visitStatService'];
+      const scheduleServiceList = ['proxyApiLoadService', 'workbenchService', 'visitStatService', 'asyncTaskRunnerService'];
       await startSchedule(this.app, scheduleServiceList);
       logger.info('ContainerLifeCycle ==> onReady 启动定时任务 ' );
     }

package/src/controller/gateway/AsyncTaskController.ts

@@ -0,0 +1,75 @@
+import { Controller, Inject, Get, Post, Query } from '@midwayjs/core';
+
+import { Context } from '@midwayjs/koa';
+import { BaseApiController } from '../base/BaseApiController';
+import {AsyncTaskService} from "@/service/asyncTask/AsyncTaskService";
+import {SysAsyncTaskEntity, TaskStatus} from "@/models/AsyncTaskModel";
+import {KeysOfSimpleSQL} from "@/libs/crud-pro/models/keys";
+import {SystemTables} from "@/models/SystemTables";
+import {CommonException} from "@/libs/crud-pro/exceptions";
+
+
+function fixCancelBodyData(body:any, id: number) {
+  if(!body.data || !body.condition) {
+    throw new CommonException("参数不正确");
+  }
+
+  // fix condition
+  const conditionObj: SysAsyncTaskEntity = (body.condition || {}) as any;
+  conditionObj.id = id;
+  body.condition =  conditionObj;
+
+  // fix data
+  const dataObj: SysAsyncTaskEntity = (body.data || {}) as any;
+  dataObj.task_status = TaskStatus.CANCELLED;
+  body.data = dataObj;
+}
+
+
+function fixCreateBodyData(body:any) {
+  if(!body.data) {
+    throw new CommonException("参数不正确");
+  }
+
+  // fix data
+  const dataObj: SysAsyncTaskEntity = (body.data || {}) as any;
+  dataObj.task_status = TaskStatus.PENDING;
+}
+
+
+/**
+ * 异步任务框架
+ */
+@Controller('/ns/gw/AsyncTask')
+export class AsyncTaskController extends BaseApiController {
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  private asyncTaskService: AsyncTaskService;
+
+  // 获取任务列表
+  @Get('/getMyTasks')
+  async getMyTasks() {
+    return this.executeSysSimpleSQL(SystemTables.sys_async_tasks, KeysOfSimpleSQL.SIMPLE_QUERY_PAGE);
+  }
+
+  // 创建任务
+  @Post('/createTask')
+  async createTask() {
+    fixCreateBodyData(this.ctx.request.body);
+    const res = await this.executeSysSimpleSQL(SystemTables.sys_async_tasks, KeysOfSimpleSQL.SIMPLE_INSERT);
+    await this.asyncTaskService.startTask();
+    return res;
+  }
+
+  // 取消任务
+  @Post('/cancelTask')
+  async cancelTask(@Query('id') id: number) {
+    fixCancelBodyData(this.ctx.request.body, id);
+    await this.asyncTaskService.cancelTask(id);
+    await this.executeSysSimpleSQL(SystemTables.sys_async_tasks, KeysOfSimpleSQL.SIMPLE_UPDATE);
+    return { success: true };
+  }
+
+}

package/src/controller/gateway/StaticController.ts

@@ -6,7 +6,7 @@ import * as fs from 'fs/promises';
 import * as fs2 from 'fs';
 import * as path from 'path';
 import * as https from 'https';
-import { parseJsonObject } from '../../libs/utils/functions';
+import { parseJsonObject } from '@/libs/utils/functions';
 
 
 interface HttpGetRes {

package/src/controller/manage/AnyApiMangeApi.ts

@@ -1,13 +1,13 @@
 import { Controller, Inject, Post } from '@midwayjs/core';
 import { Context } from '@midwayjs/koa';
-import { KeysOfSimpleSQL, KeysOfValidators } from '../../libs/crud-pro/models/keys';
+import { KeysOfSimpleSQL, KeysOfValidators } from '@/libs/crud-pro/models/keys';
 import { BaseApiController } from '../base/BaseApiController';
-import { checkPermission } from '../../middleware/permission.middleware';
-import { SystemFuncCode } from '../../models/SystemPerm';
-import { SystemTables } from '../../models/SystemTables';
-import { ISysAnyApiEntity } from '../../models/SystemEntities';
+import { checkPermission } from '@/middleware/permission.middleware';
+import { SystemFuncCode } from '@/models/SystemPerm';
+import { SystemTables } from '@/models/SystemTables';
+import { ISysAnyApiEntity } from '@/models/SystemEntities';
 import * as md5 from 'md5';
-import {parseJsonObject} from "../../libs/utils/functions";
+import {parseJsonObject} from "@/libs/utils/functions";
 
 function fixBodyData(body: any) {
   const dataObj: any = (body.data || {}) as ISysAnyApiEntity;

package/src/libs/utils/errorToString.ts

@@ -0,0 +1,66 @@
+function errorToString(error:any): string {
+  // 处理非错误对象的情况
+  if (typeof error === 'undefined') {
+    return 'Error: undefined was thrown';
+  }
+
+  if (error === null) {
+    return 'Error: null was thrown';
+  }
+
+  // 处理原始值类型
+  const primitiveTypes = ['string', 'number', 'boolean', 'symbol'];
+  if (primitiveTypes.includes(typeof error)) {
+    return `Error: A primitive value was thrown\nValue: ${String(error)}`;
+  }
+
+  // 处理 Error 对象
+  if (error instanceof Error) {
+    const errorDetails = [];
+    errorDetails.push(`Error: ${error.name || 'Error'}`);
+    errorDetails.push(`Message: ${error.message || 'No error message'}`);
+
+    if (error.stack) {
+      errorDetails.push('Stack Trace:');
+      errorDetails.push(error.stack);
+    }
+
+    const extraProperties = ['code', 'fileName', 'lineNumber', 'columnNumber'];
+    extraProperties.forEach(prop => {
+      if (error[prop] !== undefined) {
+        errorDetails.push(`${prop}: ${error[prop]}`);
+      }
+    });
+
+    const customProps = Object.keys(error).filter(
+      key => !['name', 'message', 'stack', ...extraProperties].includes(key)
+    );
+
+    if (customProps.length > 0) {
+      errorDetails.push('Custom Properties:');
+      customProps.forEach(prop => {
+        try {
+          const value = JSON.stringify(error[prop], null, 2) || String(error[prop]);
+          errorDetails.push(`  ${prop}: ${value}`);
+        } catch (e) {
+          errorDetails.push(`  ${prop}: [Object cannot be serialized]`);
+        }
+      });
+    }
+
+    return errorDetails.join('\n');
+  }
+
+  // 处理普通对象
+  try {
+    const objectDetails = JSON.stringify(error, null, 2);
+    return `Error: A plain object was thrown\nObject: ${objectDetails}`;
+  } catch (e) {
+    return `Error: An object was thrown but could not be serialized\nType: ${error.constructor?.name || 'Unknown'}`;
+  }
+}
+
+
+export {
+  errorToString
+}

package/src/middleware/global.middleware.ts

@@ -209,6 +209,13 @@ async function trackRequest(ctx: Context) {
   }
 }
 
+
+const excludePathPrefix = [
+  '/ns/static/',
+  '/ns/api/helpers'
+];
+
+
 /**
  * 全局中间件
  */
@@ -217,7 +224,13 @@ export class GlobalMiddleware implements IMiddleware<Context, NextFunction> {
 
   match(ctx: Context): boolean {
     const path: string = ctx.path;
-    return !(path.startsWith('/ns/static/'));
+    for (let i = 0; i < excludePathPrefix.length; i++) {
+      const excludePathPrefix1 = excludePathPrefix[i];
+      if (path.startsWith(excludePathPrefix1)) {
+        return false;
+      }
+    }
+    return true;
   }
 
   resolve() {

package/src/models/AsyncTaskModel.ts

@@ -0,0 +1,74 @@
+export interface SysAsyncTaskEntity {
+  id: number;
+  task_uuid: string;
+  task_name: string;
+  task_description: string | null;
+  task_type: string;
+  task_status: TaskStatus;
+  input_params: any;
+  output_result: any | null;
+
+  input_file_path: string | null;
+  input_file_format: FileFormat | null;
+  input_file_size: number | null;
+
+  output_file_path: string | null;
+  output_file_format: FileFormat | null;
+  output_file_size: number | null;
+
+  input_total_records: number | null;
+  output_total_records: number | null;
+  processed_records: number;
+  progress: number;
+  error_message: string | null;
+  error_records: any | null;
+  created_by: string | null;
+  priority: number;
+  retry_count: number;
+  max_retries: number;
+  parent_task_id: number | null;
+  created_at: Date;
+  started_at: Date | null;
+  completed_at: Date | null;
+  updated_at: Date;
+  expired_at: Date | null;
+}
+
+export enum TaskStatus {
+  PENDING = 'PENDING', // 等待中，还未进入排队
+  RUNNING = 'RUNNING', // 运行中
+  SUCCEEDED = 'SUCCEEDED',
+  FAILED = 'FAILED',
+  CANCELLED = 'CANCELLED', // 取消
+  PAUSED = 'PAUSED', // 暂停
+}
+
+export enum FileFormat {
+  XLSX = 'xlsx',
+  CSV = 'csv',
+  JSON = 'json',
+  PDF = 'pdf',
+  TXT = 'txt',
+  XML = 'xml',
+  ZIP = 'zip',
+  HTML = 'html',
+  PNG = 'png',
+  JPG = 'jpg',
+}
+
+
+export interface ITaskHandler {
+  execute(ctx: TaskContext): Promise<void>;
+}
+
+export interface TaskContext {
+  task: SysAsyncTaskEntity;
+}
+
+export interface TaskHandlerConfig {
+  taskType: string;
+  handler: ITaskHandler;
+  maxRetries?: number;
+  priority?: number;
+  expireSeconds?: number;
+}

package/src/models/SystemTables.ts

@@ -20,6 +20,7 @@ export const SystemTables = {
   sys_anyapi: 'sys_anyapi',
   sys_proxyapi: 'sys_proxyapi',
   sys_visit_stats: 'sys_visit_stats',
+  sys_async_tasks: 'sys_async_tasks',
 };
 
 

package/src/schedule/index.ts

@@ -70,4 +70,4 @@ async function startSchedule(app: koa.Application, serviceList: string[]) {
   }, 2 * 60 * 1000);
 }
 
-export { startSchedule };
+export { startSchedule, runSchedule };

package/src/service/asyncTask/AsyncTaskRunnerService.ts

@@ -0,0 +1,114 @@
+import {Inject, Provide} from '@midwayjs/core';
+import {Context} from '@midwayjs/koa';
+import {BaseService} from "@/service/base/BaseService";
+import {IScheduleService} from "@/interface";
+import {CurdProService} from "@/service/curd/CurdProService";
+import {ITaskHandler, SysAsyncTaskEntity, TaskStatus} from "@/models/AsyncTaskModel";
+import {GLOBAL_STATIC_CONFIG} from "@/libs/global-config/global-config";
+import {SystemTables} from "@/models/SystemTables";
+import {KeysOfSimpleSQL} from "@/libs/crud-pro/models/keys";
+import {errorToString} from "@/libs/utils/errorToString";
+
+
+class AsyncTaskRunner  {
+  isBusy: boolean = false;
+  taskHandlerMap: Map<string, ITaskHandler> = new Map();
+
+  async executeTaskList(taskList: SysAsyncTaskEntity[]) {
+    if (!taskList || taskList.length === 0) {
+      return;
+    }
+    this.isBusy = true;
+
+    for (let i = 0; i < taskList.length; i++) {
+      const taskElement = taskList[i];
+      try {
+        await this.executeTask(taskElement);
+        taskElement.task_status = TaskStatus.SUCCEEDED;
+      } catch (error) {
+        taskElement.task_status = TaskStatus.FAILED;
+        taskElement.error_message = errorToString(error)
+      }
+    }
+
+  }
+
+  private async executeTask(taskElement: SysAsyncTaskEntity) {
+    const taskType = taskElement.task_type;
+    const taskHandler = this.taskHandlerMap.get(taskType);
+    if (!taskHandler) {
+      throw new Error('TaskHandler not found , taskType = ' + taskType);
+    }
+    await taskHandler.execute({task: taskElement});
+  }
+}
+
+
+const ASYNC_TASK_RUNNER = new AsyncTaskRunner();
+
+
+const LOCK_KEY_ASYNC_TASK_RUNNER = "LOCK_KEY_ASYNC_TASK_RUNNER"
+
+@Provide()
+export class AsyncTaskRunnerService extends BaseService implements IScheduleService{
+
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  private curdProService: CurdProService;
+
+  async runBySchedule () {
+    if (ASYNC_TASK_RUNNER.isBusy) {
+      return Promise.resolve();
+    }
+
+    const lock = await this.redisService.set(LOCK_KEY_ASYNC_TASK_RUNNER, 1,"EX", 3600, "NX");
+    if (lock !== 'OK') {
+      return Promise.resolve();
+    }
+
+
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+
+    const queryRes = await this.curdProService.executeCrudByCfg({
+      condition: {
+        task_status: TaskStatus.PENDING
+      },
+      limit: 10
+    },{
+      sqlTable: SystemTables.sys_async_tasks,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_PAGE,
+      sqlDatabase: SystemDbName,
+      sqlDbType: SystemDbType,
+    });
+
+    const taskList = queryRes.getResRows();
+
+    if (taskList.length === 0) {
+      return Promise.resolve();
+    }
+
+    const taskIds = taskList.map(elem => elem.id).filter(Boolean)
+
+    await this.curdProService.executeCrudByCfg({
+      condition: {
+        id: {
+          "$in": taskIds
+        }
+      },
+      data: {
+        task_status: TaskStatus.RUNNING
+      }
+    },{
+      sqlTable: SystemTables.sys_async_tasks,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_UPDATE,
+      sqlDatabase: SystemDbName,
+      sqlDbType: SystemDbType,
+    });
+
+
+    ASYNC_TASK_RUNNER.executeTaskList(taskList);
+    return Promise.resolve();
+  }
+}

package/src/service/asyncTask/AsyncTaskService.ts

@@ -0,0 +1,20 @@
+import {Inject, Provide} from '@midwayjs/core';
+import {Context} from '@midwayjs/koa';
+import {BaseService} from "@/service/base/BaseService";
+import {runSchedule} from "@/schedule";
+
+@Provide()
+export class AsyncTaskService extends BaseService {
+  @Inject()
+  protected ctx: Context;
+
+  async startTask() {
+    runSchedule(this.app, ['asyncTaskRunnerService']).then(schedule => {
+      console.log(schedule);
+    })
+  }
+
+  async cancelTask(id: number) {
+
+  }
+}

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compileOnSave": true,
+  "compilerOptions": {
+    "target": "es2018",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "inlineSourceMap":false,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "stripInternal": true,
+    "skipLibCheck": true,
+    "noImplicitReturns": false,
+    "pretty": true,
+    "declaration": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "baseUrl": ".", 
+    "paths": {
+      "@/*": ["src/*"] 
+    }
+  },
+  "exclude": [
+    "*.js",
+    "*.ts",
+    "dist",
+    "node_modules",
+    "test"
+  ]
+}