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

package/dist/models/AsyncTaskModel.d.ts

@@ -4,14 +4,14 @@ export interface SysAsyncTaskEntity {
     task_name: string;
     task_description: string | null;
     task_type: string;
-    task_status: TaskStatus;
+    task_status: SysAsyncTaskStatus;
     input_params: any;
     output_result: any | null;
     input_file_path: string | null;
-    input_file_format: FileFormat | null;
+    input_file_format: SysAsyncFileFormat | null;
     input_file_size: number | null;
     output_file_path: string | null;
-    output_file_format: FileFormat | null;
+    output_file_format: SysAsyncFileFormat | null;
     output_file_size: number | null;
     input_total_records: number | null;
     output_total_records: number | null;
@@ -26,11 +26,12 @@ export interface SysAsyncTaskEntity {
     parent_task_id: number | null;
     created_at: Date;
     started_at: Date | null;
-    completed_at: Date | null;
     updated_at: Date;
     expired_at: Date | null;
+    completed_at: Date | null;
+    created_user_session: string;
 }
-export declare enum TaskStatus {
+export declare enum SysAsyncTaskStatus {
     PENDING = "PENDING",
     RUNNING = "RUNNING",
     SUCCEEDED = "SUCCEEDED",
@@ -38,7 +39,7 @@ export declare enum TaskStatus {
     CANCELLED = "CANCELLED",
     PAUSED = "PAUSED"
 }
-export declare enum FileFormat {
+export declare enum SysAsyncFileFormat {
     XLSX = "xlsx",
     CSV = "csv",
     JSON = "json",
@@ -50,15 +51,16 @@ export declare enum FileFormat {
     PNG = "png",
     JPG = "jpg"
 }
-export interface ITaskHandler {
-    execute(ctx: TaskContext): Promise<void>;
+export interface ISysAsyncTaskHandler {
+    execute(asyncTaskContext: SysAsyncTaskContext): Promise<void>;
 }
-export interface TaskContext {
+export interface SysAsyncTaskContext {
     task: SysAsyncTaskEntity;
+    updateTaskStatus: () => any;
 }
-export interface TaskHandlerConfig {
+export interface SysAsyncTaskHandlerConfig {
     taskType: string;
-    handler: ITaskHandler;
+    handler: ISysAsyncTaskHandler;
     maxRetries?: number;
     priority?: number;
     expireSeconds?: number;

package/dist/models/AsyncTaskModel.js

@@ -1,25 +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 = {}));
+exports.SysAsyncFileFormat = exports.SysAsyncTaskStatus = void 0;
+var SysAsyncTaskStatus;
+(function (SysAsyncTaskStatus) {
+    SysAsyncTaskStatus["PENDING"] = "PENDING";
+    SysAsyncTaskStatus["RUNNING"] = "RUNNING";
+    SysAsyncTaskStatus["SUCCEEDED"] = "SUCCEEDED";
+    SysAsyncTaskStatus["FAILED"] = "FAILED";
+    SysAsyncTaskStatus["CANCELLED"] = "CANCELLED";
+    SysAsyncTaskStatus["PAUSED"] = "PAUSED";
+})(SysAsyncTaskStatus = exports.SysAsyncTaskStatus || (exports.SysAsyncTaskStatus = {}));
+var SysAsyncFileFormat;
+(function (SysAsyncFileFormat) {
+    SysAsyncFileFormat["XLSX"] = "xlsx";
+    SysAsyncFileFormat["CSV"] = "csv";
+    SysAsyncFileFormat["JSON"] = "json";
+    SysAsyncFileFormat["PDF"] = "pdf";
+    SysAsyncFileFormat["TXT"] = "txt";
+    SysAsyncFileFormat["XML"] = "xml";
+    SysAsyncFileFormat["ZIP"] = "zip";
+    SysAsyncFileFormat["HTML"] = "html";
+    SysAsyncFileFormat["PNG"] = "png";
+    SysAsyncFileFormat["JPG"] = "jpg";
+})(SysAsyncFileFormat = exports.SysAsyncFileFormat || (exports.SysAsyncFileFormat = {}));

package/dist/schedule/anonymousContext.d.ts

@@ -0,0 +1,13 @@
+import * as koa from '@midwayjs/koa';
+export declare type RunServiceAtAnonymousContextRunner = (ctx: koa.IMidwayKoaContext) => any;
+declare class AnonymousContext {
+    private app;
+    setApp(app: koa.Application): void;
+    getApp(): koa.IMidwayKoaApplication;
+    runServiceAtAnonymousContext(runner: RunServiceAtAnonymousContextRunner): Promise<{
+        result: any;
+        error: any;
+    }>;
+}
+declare const ANONYMOUS_CONTEXT: AnonymousContext;
+export { ANONYMOUS_CONTEXT };

package/dist/schedule/anonymousContext.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANONYMOUS_CONTEXT = void 0;
+const contextLogger_1 = require("../models/contextLogger");
+const Transaction_1 = require("../libs/crud-pro/models/Transaction");
+const userSession_1 = require("../models/userSession");
+const anonymousUserInfo = {
+    nickName: 'anonymous_user',
+    avatar: '',
+    roleCodes: [],
+    functionCodes: [],
+    loginName: 'anonymous_user',
+    sessionId: '',
+    accountId: '',
+    workbenchCode: '',
+    accountType: userSession_1.SYS_ACCOUNT_TYPE,
+};
+const anonymousWorkbenchInfo = {
+    id: 0,
+    workbench_code: 'anonymous_workbench',
+    workbench_name: 'anonymous_workbench',
+    workbench_domain: 'anonymous_workbench',
+    workbench_desc: 'anonymous_workbench',
+    html_content: 'anonymous_workbench',
+    status: 1,
+    workbench_type: 0,
+};
+class AnonymousContext {
+    setApp(app) {
+        this.app = app;
+    }
+    getApp() {
+        return this.app;
+    }
+    async runServiceAtAnonymousContext(runner) {
+        const app = this.app;
+        const ctx = app.createAnonymousContext();
+        ctx.app = app;
+        ctx.contextLogger = new contextLogger_1.ContextLogger(ctx);
+        ctx.transaction = new Transaction_1.Transaction();
+        ctx.userSession = new userSession_1.UserSessionInfo(anonymousUserInfo, true);
+        ctx.workbenchInfo = anonymousWorkbenchInfo;
+        let result = null;
+        let error = null;
+        try {
+            result = await runner(ctx);
+        }
+        catch (e) {
+            error = e;
+            ctx.logger.error(`runServiceAtAnonymousContext error `, e);
+        }
+        finally {
+            await ctx.transaction.releaseTx();
+        }
+        return { result: result, error: error };
+    }
+}
+const ANONYMOUS_CONTEXT = new AnonymousContext();
+exports.ANONYMOUS_CONTEXT = ANONYMOUS_CONTEXT;

package/dist/schedule/index.d.ts

@@ -1,4 +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, runSchedule };
+import { startScheduleLoop, runScheduleTaskOnce } from './runSchedule';
+import { ANONYMOUS_CONTEXT } from './anonymousContext';
+import { ALL_SCHEDULE_NAMES, SCHEDULE_NAMES } from './scheduleNames';
+export { ALL_SCHEDULE_NAMES, SCHEDULE_NAMES, ANONYMOUS_CONTEXT, startScheduleLoop, runScheduleTaskOnce };

package/dist/schedule/index.js

@@ -1,70 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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");
-const scheduleUserInfo = {
-    nickName: 'schedule_user',
-    avatar: '',
-    roleCodes: [],
-    functionCodes: [],
-    loginName: 'schedule_user',
-    sessionId: '',
-    accountId: '',
-    workbenchCode: '',
-    accountType: userSession_1.SYS_ACCOUNT_TYPE,
-};
-const scheduleWorkbenchInfo = {
-    id: 0,
-    workbench_code: 'schedule_workbench',
-    workbench_name: 'schedule_workbench',
-    workbench_domain: 'schedule_workbench',
-    workbench_desc: 'schedule_workbench',
-    html_content: 'schedule_workbench',
-    status: 1,
-    workbench_type: 0,
-};
-async function runScheduleService(app, serviceName) {
-    const ctx = app.createAnonymousContext();
-    ctx.app = app;
-    ctx.contextLogger = new contextLogger_1.ContextLogger(ctx);
-    ctx.transaction = new Transaction_1.Transaction();
-    ctx.userSession = new userSession_1.UserSessionInfo(scheduleUserInfo, true);
-    ctx.workbenchInfo = scheduleWorkbenchInfo;
-    try {
-        const serviceObject = await ctx.requestContext.getAsync(serviceName);
-        if (serviceObject && serviceObject.runBySchedule) {
-            await serviceObject.runBySchedule();
-        }
-        else {
-            ctx.logger.error(`runSchedule error , serviceName = ${serviceName}, 没有找到服务`);
-        }
-    }
-    catch (e) {
-        ctx.logger.error(`runSchedule error , serviceName = ${serviceName}`, e);
-    }
-    finally {
-        await ctx.transaction.releaseTx();
-    }
-}
-async function runSchedule(app, serviceList) {
-    for (let i = 0; i < serviceList.length; i++) {
-        const serviceName = serviceList[i];
-        try {
-            await runScheduleService(app, serviceName);
-        }
-        catch (e) {
-            const ctx = app.createAnonymousContext();
-            ctx.logger.error(`runSchedule error , serviceName = ${serviceName}`, e);
-        }
-    }
-}
-exports.runSchedule = runSchedule;
-async function startSchedule(app, serviceList) {
-    await runSchedule(app, serviceList);
-    setInterval(() => {
-        runSchedule(app, serviceList);
-    }, 2 * 60 * 1000);
-}
-exports.startSchedule = startSchedule;
+exports.runScheduleTaskOnce = exports.startScheduleLoop = exports.ANONYMOUS_CONTEXT = exports.SCHEDULE_NAMES = exports.ALL_SCHEDULE_NAMES = void 0;
+const runSchedule_1 = require("./runSchedule");
+Object.defineProperty(exports, "startScheduleLoop", { enumerable: true, get: function () { return runSchedule_1.startScheduleLoop; } });
+Object.defineProperty(exports, "runScheduleTaskOnce", { enumerable: true, get: function () { return runSchedule_1.runScheduleTaskOnce; } });
+const anonymousContext_1 = require("./anonymousContext");
+Object.defineProperty(exports, "ANONYMOUS_CONTEXT", { enumerable: true, get: function () { return anonymousContext_1.ANONYMOUS_CONTEXT; } });
+const scheduleNames_1 = require("./scheduleNames");
+Object.defineProperty(exports, "ALL_SCHEDULE_NAMES", { enumerable: true, get: function () { return scheduleNames_1.ALL_SCHEDULE_NAMES; } });
+Object.defineProperty(exports, "SCHEDULE_NAMES", { enumerable: true, get: function () { return scheduleNames_1.SCHEDULE_NAMES; } });

package/dist/schedule/runSchedule.d.ts

@@ -0,0 +1,6 @@
+declare function runScheduleTaskOnce(serviceName: string): Promise<{
+    result: any;
+    error: any;
+}>;
+declare function startScheduleLoop(serviceList: string[]): Promise<void>;
+export { startScheduleLoop, runScheduleTaskOnce };

package/dist/schedule/runSchedule.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScheduleTaskOnce = exports.startScheduleLoop = void 0;
+const anonymousContext_1 = require("./anonymousContext");
+async function runScheduleTaskOnce(serviceName) {
+    return await anonymousContext_1.ANONYMOUS_CONTEXT.runServiceAtAnonymousContext(async (ctx) => {
+        const serviceObject = await ctx.requestContext.getAsync(serviceName);
+        if (serviceObject && serviceObject.runBySchedule) {
+            await serviceObject.runBySchedule();
+        }
+        else {
+            ctx.logger.error(`runSchedule error , serviceName = ${serviceName}, 没有找到服务`);
+        }
+    });
+}
+exports.runScheduleTaskOnce = runScheduleTaskOnce;
+async function runScheduleServiceList(serviceList) {
+    for (let i = 0; i < serviceList.length; i++) {
+        const serviceName = serviceList[i];
+        try {
+            await runScheduleTaskOnce(serviceName);
+        }
+        catch (e) {
+            anonymousContext_1.ANONYMOUS_CONTEXT.getApp().getCoreLogger().error(`runSchedule error , serviceName = ${serviceName}`, e);
+        }
+    }
+}
+async function startScheduleLoop(serviceList) {
+    await runScheduleServiceList(serviceList);
+    setInterval(() => {
+        runScheduleServiceList(serviceList);
+    }, 2 * 60 * 1000);
+}
+exports.startScheduleLoop = startScheduleLoop;

package/dist/schedule/scheduleNames.d.ts

@@ -0,0 +1,8 @@
+declare const SCHEDULE_NAMES: {
+    proxyApiLoadService: string;
+    workbenchService: string;
+    visitStatService: string;
+    asyncTaskRunnerService: string;
+};
+declare const ALL_SCHEDULE_NAMES: string[];
+export { ALL_SCHEDULE_NAMES, SCHEDULE_NAMES, };

package/dist/schedule/scheduleNames.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEDULE_NAMES = exports.ALL_SCHEDULE_NAMES = void 0;
+const SCHEDULE_NAMES = {
+    proxyApiLoadService: 'proxyApiLoadService',
+    workbenchService: 'workbenchService',
+    visitStatService: 'visitStatService',
+    asyncTaskRunnerService: 'asyncTaskRunnerService',
+};
+exports.SCHEDULE_NAMES = SCHEDULE_NAMES;
+const ALL_SCHEDULE_NAMES = [
+    SCHEDULE_NAMES.proxyApiLoadService,
+    SCHEDULE_NAMES.workbenchService,
+    SCHEDULE_NAMES.visitStatService,
+    SCHEDULE_NAMES.asyncTaskRunnerService
+];
+exports.ALL_SCHEDULE_NAMES = ALL_SCHEDULE_NAMES;

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

@@ -1,8 +1,22 @@
 import { Context } from '@midwayjs/koa';
 import { BaseService } from "../../service/base/BaseService";
 import { IScheduleService } from "../../interface";
+import { ISysAsyncTaskHandler, SysAsyncTaskEntity } from "../../models/AsyncTaskModel";
+declare class AsyncTaskRunner {
+    isBusy: boolean;
+    taskHandlerMap: Map<string, ISysAsyncTaskHandler>;
+    executeTaskList(taskList: SysAsyncTaskEntity[]): Promise<void>;
+    private executeTask;
+    private updateTaskStatus;
+}
+/**
+ * 业务可以扩展
+ */
+export declare const ASYNC_TASK_RUNNER: AsyncTaskRunner;
 export declare class AsyncTaskRunnerService extends BaseService implements IScheduleService {
     protected ctx: Context;
     private curdProService;
+    fetchPendingTasks(): Promise<void>;
     runBySchedule(): Promise<void>;
 }
+export {};

package/dist/service/asyncTask/AsyncTaskRunnerService.js

@@ -9,7 +9,7 @@ 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;
+exports.AsyncTaskRunnerService = exports.ASYNC_TASK_RUNNER = void 0;
 const core_1 = require("@midwayjs/core");
 const BaseService_1 = require("../../service/base/BaseService");
 const CurdProService_1 = require("../../service/curd/CurdProService");
@@ -18,6 +18,7 @@ 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");
+const schedule_1 = require("../../schedule");
 class AsyncTaskRunner {
     constructor() {
         this.isBusy = false;
@@ -31,14 +32,21 @@ class AsyncTaskRunner {
         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.task_status = AsyncTaskModel_1.SysAsyncTaskStatus.FAILED;
                 taskElement.error_message = (0, errorToString_1.errorToString)(error);
             }
+            try {
+                await this.updateTaskStatus(taskElement);
+            }
+            catch (error) {
+                schedule_1.ANONYMOUS_CONTEXT.getApp().getCoreLogger().error("executeTaskList error", error);
+            }
         }
+        this.isBusy = false;
     }
     async executeTask(taskElement) {
         const taskType = taskElement.task_type;
@@ -46,25 +54,47 @@ class AsyncTaskRunner {
         if (!taskHandler) {
             throw new Error('TaskHandler not found , taskType = ' + taskType);
         }
-        await taskHandler.execute({ task: taskElement });
+        const updateTaskStatus = () => {
+            return this.updateTaskStatus(taskElement);
+        };
+        await taskHandler.execute({ task: taskElement, updateTaskStatus });
+    }
+    async updateTaskStatus(taskElement) {
+        return await schedule_1.ANONYMOUS_CONTEXT.runServiceAtAnonymousContext(async (ctx) => {
+            const curdProService = await ctx.requestContext.getAsync("curdProService");
+            const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+            const { id, ...otherTaskProps } = taskElement;
+            const res = await curdProService.executeCrudByCfg({
+                condition: {
+                    id: id
+                },
+                data: otherTaskProps
+            }, {
+                sqlTable: SystemTables_1.SystemTables.sys_async_tasks,
+                sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE,
+                sqlDatabase: SystemDbName,
+                sqlDbType: SystemDbType,
+            });
+            return res.getResModel().affected;
+        });
     }
 }
-const ASYNC_TASK_RUNNER = new AsyncTaskRunner();
+/**
+ * 业务可以扩展
+ */
+exports.ASYNC_TASK_RUNNER = new AsyncTaskRunner();
+/**
+ * Redis锁
+ */
 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();
-        }
+    async fetchPendingTasks() {
         const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         const queryRes = await this.curdProService.executeCrudByCfg({
             condition: {
-                task_status: AsyncTaskModel_1.TaskStatus.PENDING
+                task_status: AsyncTaskModel_1.SysAsyncTaskStatus.PENDING
             },
+            orderBy: 'id+',
             limit: 10
         }, {
             sqlTable: SystemTables_1.SystemTables.sys_async_tasks,
@@ -84,7 +114,7 @@ let AsyncTaskRunnerService = class AsyncTaskRunnerService extends BaseService_1.
                 }
             },
             data: {
-                task_status: AsyncTaskModel_1.TaskStatus.RUNNING
+                task_status: AsyncTaskModel_1.SysAsyncTaskStatus.RUNNING
             }
         }, {
             sqlTable: SystemTables_1.SystemTables.sys_async_tasks,
@@ -92,7 +122,27 @@ let AsyncTaskRunnerService = class AsyncTaskRunnerService extends BaseService_1.
             sqlDatabase: SystemDbName,
             sqlDbType: SystemDbType,
         });
-        ASYNC_TASK_RUNNER.executeTaskList(taskList);
+        exports.ASYNC_TASK_RUNNER.executeTaskList(taskList).then(() => {
+            console.log("ASYNC_TASK_RUNNER finished taskIds ==> " + JSON.stringify(taskIds));
+        });
+    }
+    async runBySchedule() {
+        if (exports.ASYNC_TASK_RUNNER.isBusy) {
+            return Promise.resolve();
+        }
+        // 这里的过期时间1分钟即可。fetchPendingTasks函数不可能超过一分钟。
+        // 因为这里只是从数据库中获取一批任务，放到自己的任务队列里。还没触发执行。
+        const lock = await this.redisService.set(LOCK_KEY_ASYNC_TASK_RUNNER, 1, "EX", 60, "NX");
+        if (lock !== 'OK') {
+            return Promise.resolve();
+        }
+        try {
+            await this.fetchPendingTasks();
+        }
+        catch (e) {
+            console.error("fetchPendingTasks error", (0, errorToString_1.errorToString)(e));
+        }
+        await this.redisService.del(LOCK_KEY_ASYNC_TASK_RUNNER);
         return Promise.resolve();
     }
 };

package/dist/service/asyncTask/AsyncTaskService.js

@@ -13,9 +13,10 @@ exports.AsyncTaskService = void 0;
 const core_1 = require("@midwayjs/core");
 const BaseService_1 = require("../../service/base/BaseService");
 const schedule_1 = require("../../schedule");
+const scheduleNames_1 = require("../../schedule/scheduleNames");
 let AsyncTaskService = class AsyncTaskService extends BaseService_1.BaseService {
     async startTask() {
-        (0, schedule_1.runSchedule)(this.app, ['asyncTaskRunnerService']).then(schedule => {
+        (0, schedule_1.runScheduleTaskOnce)(scheduleNames_1.SCHEDULE_NAMES.asyncTaskRunnerService).then(schedule => {
             console.log(schedule);
         });
     }

package/dist/service/crudstd/CrudStdService.d.ts

@@ -47,4 +47,5 @@ export declare class CrudStdService extends ApiBaseService {
      */
     getParsedCrudStdAppInfo(appCode: string): Promise<ICrudStdAppInfo>;
     private hasOperationPerm;
+    private fixDataFieldTypeBySqlTableField;
 }

package/dist/service/crudstd/CrudStdService.js

@@ -22,6 +22,7 @@ const _ = require("lodash");
 const ApiBaseService_1 = require("../base/ApiBaseService");
 const DatabaseName_1 = require("../../libs/crud-pro/utils/DatabaseName");
 const global_config_1 = require("../../libs/global-config/global-config");
+const MixinUtils_1 = require("../../libs/crud-pro/utils/MixinUtils");
 exports.SPECIAL_SETTING_KEY = {
     QUERY_LIST: 'QUERY_LIST',
     QUERY_ONE: 'QUERY_ONE',
@@ -54,6 +55,8 @@ let CrudStdService = class CrudStdService extends ApiBaseService_1.ApiBaseServic
         }
         // 根据用户配置，设置关联查询的数据信息。
         await this.crudStdRelationService.addCfgModelColumnsRelation(cfgModel, appInfo);
+        // 根据表结构的数据类型，修正数据类型
+        await this.fixDataFieldTypeBySqlTableField(params, cfgModel, appInfo, { dbType, dbName });
         // 业务系统自定义的修改cfgModel
         await global_config_1.GLOBAL_STATIC_CONFIG.getConfig().bizUpdateCfgModelForCrudStd(params, cfgModel, appInfo, this.ctx);
         return await this.curdMixService.executeCrudByCfg(params, cfgModel);
@@ -163,6 +166,30 @@ let CrudStdService = class CrudStdService extends ApiBaseService_1.ApiBaseServic
         }
         return true; // 无需鉴权
     }
+    async fixDataFieldTypeBySqlTableField(params, cfgModel, appInfo, arg3) {
+        const tableFields = _.get(appInfo, 'stdCrudCfgObj.tableFields');
+        const tableFieldMap = MixinUtils_1.MixinUtils.toMap(tableFields, (e) => {
+            return e.fieldIndex;
+        });
+        if (arg3.dbType === keys_1.SqlDbType.postgres) {
+            if (cfgModel.sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_INSERT || cfgModel.sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE) {
+                const data = params.data || {};
+                const dataKeys = Object.keys(data);
+                for (let index = 0; index < dataKeys.length; index++) {
+                    const dataKey = dataKeys[index];
+                    const dataValue = data[dataKey];
+                    const fieldInfo = tableFieldMap[dataKey];
+                    const fieldType = ('' + _.get(fieldInfo, 'type')).toUpperCase();
+                    if (fieldType === 'ARRAY') {
+                        const dataValueArray = (0, functions_1.parseJsonObject)(dataValue);
+                        if (Array.isArray(dataValueArray)) {
+                            data[dataKey] = `{${dataValueArray.map(v => `"${v}"`).join(',')}}`;
+                        }
+                    }
+                }
+            }
+        }
+    }
 };
 __decorate([
     (0, core_1.Inject)(),

package/dist/service/curd/CrudProQuick.d.ts

@@ -0,0 +1,24 @@
+import { SqlDbType } from "../../libs/crud-pro/models/keys";
+import { IRequestModel } from "../../libs/crud-pro/interfaces";
+import { IRequestCfgModel2 } from "../../models/bizmodels";
+import { CrudPro } from "../../libs/crud-pro/CrudPro";
+import { ResModelAffected, ResModelStandard } from "../../libs/crud-pro/models/ResModel";
+export declare class CrudProQuick {
+    private readonly curdPro;
+    private readonly sqlDbType;
+    private readonly sqlDatabase;
+    private readonly sqlTable?;
+    private baseCfgModel;
+    constructor(curdPro: CrudPro, sqlDatabase: string, sqlDbType: SqlDbType, sqlTable?: string);
+    setBaseCfgModel(baseCfgModel: IRequestCfgModel2): void;
+    private executeCrudByCfg;
+    getOne(reqJson: IRequestModel, sqlTable?: string): Promise<any>;
+    getList(reqJson: IRequestModel, sqlTable?: string): Promise<any[]>;
+    getListPage(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelStandard>;
+    getTotalCount(reqJson: IRequestModel, sqlTable?: string): Promise<number>;
+    insertObject(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelAffected>;
+    updateObject(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelAffected>;
+    insertOrUpdate(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelStandard>;
+    deleteObject(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelAffected>;
+    executeSQL(executeSql: string, args?: any[]): Promise<any>;
+}