midway-fatcms 0.0.1-beta.2 → 0.0.1-beta.22

package/src/service/asyncTask/AsyncTaskRunnerService.ts

@@ -0,0 +1,255 @@
+import { Inject, Provide } from '@midwayjs/core';
+import { Context, IMidwayKoaContext } from '@midwayjs/koa';
+import { BaseService } from '@/service/base/BaseService';
+import { IScheduleService } from '@/interface';
+import { CurdProService } from '@/service/curd/CurdProService';
+import { ISysAsyncTaskHandler, SysAsyncTaskEntity, SysAsyncTaskPartial, SysAsyncTaskStatus } 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';
+import { ANONYMOUS_CONTEXT } from '@/schedule';
+import { RedisKeys } from '@/models/RedisKeys';
+
+const END_STATUS_LIST = [
+  SysAsyncTaskStatus.PART_SUCCEEDED,
+  SysAsyncTaskStatus.SUCCEEDED,
+  SysAsyncTaskStatus.FAILED,
+  SysAsyncTaskStatus.CANCELLED,
+  SysAsyncTaskStatus.PAUSED,
+];
+
+class AsyncTaskRunner {
+  isBusy = false;
+  taskHandlerMap: Map<string, ISysAsyncTaskHandler> = 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];
+      taskElement.task_status = SysAsyncTaskStatus.RUNNING;
+
+      try {
+        // 任务状态的设置在自定义的执行器里面。
+        await this.executeTask(taskElement);
+
+        // 当前不是终止状态，并且没有异常就设置成成功。
+        if (!END_STATUS_LIST.includes(taskElement.task_status)) {
+          taskElement.task_status = SysAsyncTaskStatus.SUCCEEDED;
+        }
+
+      } catch (error) {
+        taskElement.task_status = SysAsyncTaskStatus.FAILED;
+        taskElement.error_message = errorToString(error);
+      }
+
+      try {
+        await this.updateTaskStatus(taskElement, {
+          task_status: taskElement.task_status,
+          error_message: taskElement.error_message,
+        });
+      } catch (error) {
+        ANONYMOUS_CONTEXT.getApp().getCoreLogger().error('executeTaskList error', error);
+      }
+    }
+
+    this.isBusy = false;
+  }
+
+  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);
+    }
+    const updateTaskStatus = (updatePartials: SysAsyncTaskPartial) => {
+      return this.updateTaskStatus(taskElement, updatePartials);
+    };
+    await taskHandler.execute({ task: taskElement, updateTaskStatus });
+  }
+
+  /**
+   * 更新任务状态或任务进度
+   * @param taskElement
+   * @param updatePartials
+   * @private
+   */
+  private async updateTaskStatus(taskElement: SysAsyncTaskEntity, updatePartials: SysAsyncTaskPartial) {
+    if (!updatePartials) {
+      throw new Error('updatePartials not found');
+    }
+    return await ANONYMOUS_CONTEXT.runServiceAtAnonymousContext(async (ctx: IMidwayKoaContext) => {
+      const curdProService: CurdProService = await ctx.requestContext.getAsync('curdProService');
+      const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+
+      const res = await curdProService.executeCrudByCfg(
+        {
+          condition: {
+            id: taskElement.id,
+          },
+          data: updatePartials,
+        },
+        {
+          sqlTable: SystemTables.sys_async_tasks,
+          sqlSimpleName: KeysOfSimpleSQL.SIMPLE_UPDATE,
+          sqlDatabase: SystemDbName,
+          sqlDbType: SystemDbType,
+        }
+      );
+      return res.getResModel().affected;
+    });
+  }
+
+  /**
+   * 获取当前进程可以处理的任务类型。
+   */
+  public getHandlerTaskTypeList(): string[] {
+    const keys = this.taskHandlerMap.keys();
+    return [...keys];
+  }
+}
+
+/**
+ * 业务可以扩展
+ */
+export const ASYNC_TASK_RUNNER = new AsyncTaskRunner();
+
+/**
+ * Redis锁
+ */
+const ASYNC_TASK_LOCK = RedisKeys.ASYNC_TASK_LOCK;
+
+const ASYNC_TASK_RUNTIME_OBJ = {
+  LAST_CHECK_ASYNC_TASK_UPDATE_TIME: 0,
+};
+
+@Provide()
+export class AsyncTaskRunnerService extends BaseService implements IScheduleService {
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  private curdProService: CurdProService;
+
+  async fetchPendingTasks(): Promise<void> {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+
+    // 只获取本进程能够处理的任务类型。
+    const taskTypeList = ASYNC_TASK_RUNNER.getHandlerTaskTypeList();
+    if (taskTypeList.length === 0) {
+      return Promise.resolve();
+    }
+
+    // 查询等待处理的任务。
+    const queryRes = await this.curdProService.executeCrudByCfg(
+      {
+        condition: {
+          task_status: SysAsyncTaskStatus.PENDING,
+          task_type: {
+            $in: taskTypeList,
+          },
+        },
+        orderBy: 'id+',
+        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: SysAsyncTaskStatus.RUNNING,
+        },
+      },
+      {
+        sqlTable: SystemTables.sys_async_tasks,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_UPDATE,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+      }
+    );
+
+    // 开始执行。
+    ASYNC_TASK_RUNNER.executeTaskList(taskList).then(() => {
+      console.log('ASYNC_TASK_RUNNER finished taskIds ==> ' + JSON.stringify(taskIds));
+    });
+  }
+
+  async runBySchedule() {
+    // 1. 当前很忙
+    if (ASYNC_TASK_RUNNER.isBusy) {
+      return Promise.resolve();
+    }
+
+    // 2. 发现了新任务
+    const isExistNewTask = await this.isExistNewTask();
+    if (!isExistNewTask) {
+      return Promise.resolve();
+    }
+
+    // 这里的过期时间1分钟即可。fetchPendingTasks函数不可能超过一分钟。
+    // 因为这里只是从数据库中获取一批任务，放到自己的任务队列里。还没触发执行。
+    const lock = await this.redisService.set(ASYNC_TASK_LOCK, 1, 'EX', 60, 'NX');
+    if (lock !== 'OK') {
+      return Promise.resolve();
+    }
+
+    try {
+      await this.fetchPendingTasks();
+    } catch (e) {
+      console.error('fetchPendingTasks error', errorToString(e));
+    }
+
+    await this.redisService.del(ASYNC_TASK_LOCK);
+
+    return Promise.resolve();
+  }
+
+  /**
+   * 是否存在新任务
+   * @private
+   */
+  private async isExistNewTask(): Promise<boolean> {
+    // 刚启动，没有检查过。
+    if (!ASYNC_TASK_RUNTIME_OBJ.LAST_CHECK_ASYNC_TASK_UPDATE_TIME) {
+      ASYNC_TASK_RUNTIME_OBJ.LAST_CHECK_ASYNC_TASK_UPDATE_TIME = Date.now();
+      return true;
+    }
+
+    //Redis没有任何内容
+    const updateTime = await this.redisService.get(RedisKeys.ASYNC_TASK_UPDATE_TIME);
+    if (!updateTime) {
+      ASYNC_TASK_RUNTIME_OBJ.LAST_CHECK_ASYNC_TASK_UPDATE_TIME = Date.now();
+      return false;
+    }
+
+    const updateTimeNumber = Number.parseInt(updateTime, 10);
+
+    const isExistNewTask: boolean = updateTimeNumber > ASYNC_TASK_RUNTIME_OBJ.LAST_CHECK_ASYNC_TASK_UPDATE_TIME;
+    ASYNC_TASK_RUNTIME_OBJ.LAST_CHECK_ASYNC_TASK_UPDATE_TIME = updateTimeNumber;
+    return isExistNewTask;
+  }
+}

package/src/service/asyncTask/AsyncTaskService.ts

@@ -0,0 +1,21 @@
+import { Inject, Provide } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { BaseService } from '@/service/base/BaseService';
+import { runScheduleTaskOnce } from '@/schedule';
+import { INNER_SCHEDULE_NAMES } from '@/schedule/scheduleNames';
+import { RedisKeys } from '@/models/RedisKeys';
+
+@Provide()
+export class AsyncTaskService extends BaseService {
+  @Inject()
+  protected ctx: Context;
+
+  async startTask() {
+    await this.redisService.set(RedisKeys.ASYNC_TASK_UPDATE_TIME, `${Date.now()}`);
+    runScheduleTaskOnce(INNER_SCHEDULE_NAMES.asyncTaskRunnerService).then(schedule => {
+      console.log(schedule);
+    });
+  }
+
+  async cancelTask(id: number) {}
+}

package/src/service/base/BaseService.ts

@@ -3,8 +3,8 @@ import { Context } from '@midwayjs/koa';
 import { RedisService } from '@midwayjs/redis';
 import { OSSService, OSSServiceFactory } from '@midwayjs/oss';
 import * as koa from '@midwayjs/koa';
-import { consoleLogger, ContextLogger, ILoggerContext } from '../../models/contextLogger';
-import { isEnableDebug, isLocalEnv } from '../../libs/utils/fatcms-request';
+import { consoleLogger, ContextLogger, ILoggerContext } from '@/models/contextLogger';
+import { isEnableDebug, isLocalEnv } from '@/libs/utils/fatcms-request';
 
 
 @Provide()

package/src/service/crudstd/CrudStdService.ts

@@ -2,17 +2,19 @@ import { Inject, Provide } from '@midwayjs/core';
 import { Context } from '@midwayjs/koa';
 import { CurdMixService } from '../curd/CurdMixService';
 import { IRequestCfgModel, IRequestModel } from '../../libs/crud-pro/interfaces';
-import { KeysOfAuthType, KeysOfSimpleSQL } from '../../libs/crud-pro/models/keys';
+import { KeysOfAuthType, KeysOfSimpleSQL, SqlDbType } from '../../libs/crud-pro/models/keys';
 import { parseJsonObject } from '../../libs/utils/functions';
 import { ICrudStdAppInfo, ICrudStdAppInfoForSettingKey } from '../../models/bizmodels';
 import { BizException } from '../../models/devops';
 import { ExecuteContext } from '../../libs/crud-pro/models/ExecuteContext';
-import {SystemDbName, SystemDbType, SystemTables} from '../../models/SystemTables';
+import { SystemTables } from '../../models/SystemTables';
 import { CrudStdActionService } from './CrudStdActionService';
 import { CrudStdRelationService } from './CrudStdRelationService';
 import * as _ from 'lodash';
 import { ApiBaseService } from '../base/ApiBaseService';
-import {parseDatabaseName} from "../../libs/crud-pro/utils/DatabaseName";
+import { parseDatabaseName } from '../../libs/crud-pro/utils/DatabaseName';
+import { GLOBAL_STATIC_CONFIG } from '../../libs/global-config/global-config';
+import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
 
 export const SPECIAL_SETTING_KEY = {
   QUERY_LIST: 'QUERY_LIST',
@@ -44,13 +46,30 @@ export class CrudStdService extends ApiBaseService {
       throw new BizException('应用不存在或已下线：' + appCode);
     }
 
+
+    // 查询列表功能
+    if(settingKey === SPECIAL_SETTING_KEY.QUERY_LIST) {
+      // 正确启用了自定义查询功能
+      const customQueryApi:string = _.get(stdCrudCfgObj, 'othersSetting.values.customQueryApi');
+      if(typeof customQueryApi === 'string') {
+        const customQueryApiArr = customQueryApi.split('.');
+        const serviceName = customQueryApiArr[0] || "";
+        const serviceFunc = customQueryApiArr[1] || "";
+        if(serviceName.endsWith('Service')){
+           const serviceObj = await this.ctx.requestContext.getAsync(serviceName);
+           return serviceObj[serviceFunc](params);
+        }
+      }
+    }
+
+
     const databaseName = stdCrudCfgObj.tableBaseInfo.databaseName;
 
     const { dbType, dbName } = parseDatabaseName(databaseName);
 
     const cfgModel: IRequestCfgModel = {
       sqlDatabase: dbName,
-      sqlDdType: dbType,
+      sqlDbType: dbType,
       sqlTable: stdCrudCfgObj.tableBaseInfo.tableName,
       sqlSimpleName,
     };
@@ -67,6 +86,13 @@ export class CrudStdService extends ApiBaseService {
 
     // 根据用户配置，设置关联查询的数据信息。
     await this.crudStdRelationService.addCfgModelColumnsRelation(cfgModel, appInfo);
+
+    // 根据表结构的数据类型，修正数据类型
+    await this.fixDataFieldTypeBySqlTableField(params, cfgModel, appInfo, { dbType, dbName });
+
+    // 业务系统自定义的修改cfgModel
+    await GLOBAL_STATIC_CONFIG.getConfig().bizUpdateCfgModelForCrudStd(params, cfgModel, appInfo, this.ctx);
+
     return await this.curdMixService.executeCrudByCfg(params, cfgModel);
   }
 
@@ -133,13 +159,15 @@ export class CrudStdService extends ApiBaseService {
    * @private
    */
   private async getCrudStdAppInfo(appCode?: string) {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+
     this.logInfo('getCrudStdAppInfo', appCode);
 
     const ss = {
       sqlTable: SystemTables.sys_app,
       sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
       sqlDatabase: SystemDbName,
-      sqlDdType: SystemDbType,
+      sqlDbType: SystemDbType,
     };
     return await this.curdMixService.executeCrudByCfg({ condition: { app_code: appCode } }, ss);
   }
@@ -185,4 +213,31 @@ export class CrudStdService extends ApiBaseService {
     }
     return true; // 无需鉴权
   }
+
+  private async fixDataFieldTypeBySqlTableField(params: IRequestModel, cfgModel: IRequestCfgModel, appInfo: ICrudStdAppInfoForSettingKey, arg3: { dbType: SqlDbType; dbName: string }) {
+    const tableFields = _.get(appInfo, 'stdCrudCfgObj.tableFields');
+
+    const tableFieldMap = MixinUtils.toMap(tableFields, (e: any) => {
+      return e.fieldIndex;
+    });
+
+    if (arg3.dbType === SqlDbType.postgres) {
+      if (cfgModel.sqlSimpleName === KeysOfSimpleSQL.SIMPLE_INSERT || cfgModel.sqlSimpleName === 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 = parseJsonObject(dataValue);
+            if (Array.isArray(dataValueArray)) {
+              data[dataKey] = `{${dataValueArray.map(v => `"${v}"`).join(',')}}`;
+            }
+          }
+        }
+      }
+    }
+  }
 }

package/src/service/curd/CrudProQuick.ts

@@ -0,0 +1,137 @@
+import { KeysOfSimpleSQL, SqlDbType } from "@/libs/crud-pro/models/keys";
+import { IRequestCfgModel, IRequestModel, ISqlCfgModel } 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 class CrudProQuick {
+  private readonly curdPro: CrudPro;
+  private readonly sqlDbType: SqlDbType;
+  private readonly sqlDatabase: string;
+  private readonly sqlTable?: string;
+  private baseCfgModel: IRequestCfgModel2 = {};
+
+  constructor(curdPro: CrudPro, sqlDatabase: string, sqlDbType: SqlDbType, sqlTable?: string) {
+    this.sqlDatabase = sqlDatabase;
+    this.sqlDbType = sqlDbType;
+    this.curdPro = curdPro;
+    this.sqlTable = sqlTable; // 全局sqlTable为空时，单独调用时就必须传sqlTable参数。
+  }
+
+  public setBaseCfgModel(baseCfgModel: IRequestCfgModel2) {
+    Object.assign(this.baseCfgModel, baseCfgModel);
+  }
+
+  private async executeCrudByCfg(reqJson: IRequestModel, cfgModel2: IRequestCfgModel2) {
+
+    const cfgModel = { ...this.baseCfgModel };
+    Object.assign(cfgModel, cfgModel2);
+
+    cfgModel.method = 'CrudProQuickAnonymous';
+    cfgModel.updateCfg = {};
+    cfgModel.sqlDatabase = this.sqlDatabase;
+    cfgModel.sqlDbType = this.sqlDbType;
+
+    if (!cfgModel.sqlTable) {
+      cfgModel.sqlTable = this.sqlTable;
+    }
+
+    if (!cfgModel.sqlTable) {
+      throw new Error('[CrudProQuick] sqlTable not found');
+    }
+
+    return await this.curdPro.executeCrudByCfg(reqJson, cfgModel);
+  }
+
+
+  public async getOne(reqJson: IRequestModel, sqlTable?: string): Promise<any> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
+    };
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    return res.getOneObj();
+  }
+
+  public async getList(reqJson: IRequestModel, sqlTable?: string): Promise<any[]> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+    };
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    return res.getResRows();
+  }
+
+  public async getListPage(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelStandard> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_PAGE,
+    };
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    return res.getResModel();  // 因为它有2个返回值
+  }
+
+  public async getTotalCount(reqJson: IRequestModel, sqlTable?: string): Promise<number> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_COUNT,
+    };
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    return res.getResModel().total_count;
+  }
+
+  public async insertObject(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelAffected> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_INSERT,
+    };
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    return res.getResModel().affected;
+  }
+
+  public async updateObject(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelAffected> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_UPDATE,
+    };
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    return res.getResModel().affected;
+  }
+
+  public async insertOrUpdate(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelStandard> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE,
+    };
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    return res.getResModel(); // 因为它有三个返回值
+  }
+
+  public async deleteObject(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelAffected> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_DELETE,
+    };
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    return res.getResModel().affected;
+  }
+
+
+  public async executeSQL(executeSql: string, args?: any[]): Promise<any> {
+    const sqlCfgModel: ISqlCfgModel = {
+      executeSql: executeSql,
+      executeSqlArgs: args,
+      sqlDatabase: this.sqlDatabase,
+      sqlDbType: this.sqlDbType,
+    };
+    return await this.curdPro.executeSQL(sqlCfgModel);
+  }
+
+
+
+
+}
+
+

package/src/service/curd/CurdMixByAccountService.ts

@@ -4,10 +4,11 @@ import * as _ from 'lodash';
 import { CurdProService } from './CurdProService';
 import { ExecuteContext, IExecuteContextHandler } from '../../libs/crud-pro/models/ExecuteContext';
 import { CrudMixUtils, RelatedType } from './CurdMixUtils';
-import {SystemDbName, SystemDbType, SystemTables} from '../../models/SystemTables';
+import { SystemTables } from '../../models/SystemTables';
 import { KeysOfSimpleSQL } from '../../libs/crud-pro/models/keys';
 import { ColumnRelation, IRequestCfgModel, IRequestModel } from '../../libs/crud-pro/interfaces';
 import { MixinUtils } from '../../libs/crud-pro/utils/MixinUtils';
+import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
 
 const dictMixUtils = new CrudMixUtils(RelatedType.accountBasic);
 
@@ -22,6 +23,8 @@ export class CurdMixByAccountService implements IExecuteContextHandler {
   protected curdProService: CurdProService;
 
   async handleExecuteContextPrepare(executeContext: ExecuteContext) {
+    const { SystemDbName, SystemDbType, toFatcmsUserAccountId } = GLOBAL_STATIC_CONFIG.getConfig();
+
     const relations = dictMixUtils.pickColumnRelations(executeContext);
     if (!relations || relations.length === 0) {
       return;
@@ -30,10 +33,15 @@ export class CurdMixByAccountService implements IExecuteContextHandler {
     const accountIds = new Set<string>();
     dictMixUtils.forEachRowAndColumnsRelation(executeContext, (row: any, columnRelation: ColumnRelation) => {
       const { sourceColumn } = columnRelation;
-      const accountId = _.get(row, sourceColumn);
-      if (accountId) {
-        accountIds.add(accountId);
+      if (sourceColumn) {
+        const accountId = _.get(row, sourceColumn);
+        if (accountId) {
+          const fatcmsUserAccountId = toFatcmsUserAccountId(accountId);
+          accountIds.add(fatcmsUserAccountId);
+          row['__fatcmsUserAccountId__'] = fatcmsUserAccountId;
+        }
       }
+
     });
 
     if (accountIds.size === 0) {
@@ -45,7 +53,7 @@ export class CurdMixByAccountService implements IExecuteContextHandler {
       sqlTable: SystemTables.sys_user_account,
       sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
       sqlDatabase: SystemDbName,
-      sqlDdType: SystemDbType,
+      sqlDbType: SystemDbType,
     };
 
     const reqJson: IRequestModel = {
@@ -77,7 +85,7 @@ export class CurdMixByAccountService implements IExecuteContextHandler {
           { from: 'avatar', to: `${sourceColumn}_user.avatar` },
         ];
       }
-      dictMixUtils.copyColumnRelationToRowNoRelatedCode(row, userInfoMap, columnRelation);
+      dictMixUtils.copyUserInfoToRowNoRelatedCode(row, userInfoMap, columnRelation);
     });
   }
 }

package/src/service/curd/CurdMixByDictService.ts

@@ -3,12 +3,13 @@ import { Context } from '@midwayjs/koa';
 import { CurdProService } from './CurdProService';
 import { ExecuteContext, IExecuteContextHandler } from '../../libs/crud-pro/models/ExecuteContext';
 import { CrudMixUtils, RelatedType } from './CurdMixUtils';
-import {SystemDbName, SystemDbType, SystemTables} from '../../models/SystemTables';
+import { SystemTables} from '../../models/SystemTables';
 import { KeysOfSimpleSQL } from '../../libs/crud-pro/models/keys';
 import { MultiKeyMap } from '../../libs/crud-pro/utils/MultiKeyMap';
 import { ColumnRelation } from '../../libs/crud-pro/interfaces';
 import * as _ from 'lodash';
 import {RedisCacheService} from "../base/RedisCacheService";
+import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
 
 const TMP_CTX_KEY = _.uniqueId('CurdMixByDictService');
 
@@ -46,6 +47,11 @@ export class CurdMixByDictService implements IExecuteContextHandler {
   }
 
   private async getDictItemRows(codes: string[]) {
+
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+
+
+
     const noCacheCodes: string[] = [];
 
     // 从缓存里面取
@@ -72,7 +78,7 @@ export class CurdMixByDictService implements IExecuteContextHandler {
           sqlTable: SystemTables.sys_data_dict_item,
           sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
           sqlDatabase: SystemDbName,
-          sqlDdType: SystemDbType,
+          sqlDbType: SystemDbType,
         }
       );
       selectedRows = res1.getResRows();