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

package/src/middleware/global.middleware.ts

@@ -1,15 +1,15 @@
 import { Middleware, IMiddleware } from '@midwayjs/core';
 import { NextFunction, Context } from '@midwayjs/koa';
 import * as _ from 'lodash';
-import { Transaction } from '../libs/crud-pro/models/Transaction';
-import { UserSessionService } from '../service/UserSessionService';
-import { WorkbenchService } from '../service/WorkbenchService';
-import { ISessionInfo, UserSessionInfo } from '../models/userSession';
-import { ICommonResult, CommonResult } from '../libs/utils/common-dto';
-import {isEnableDebug, isEnableSuperAdmin} from '../libs/utils/fatcms-request';
-import { ContextLogger } from '../models/contextLogger';
+import { Transaction } from '@/libs/crud-pro/models/Transaction';
+import { UserSessionService } from '@/service/UserSessionService';
+import { WorkbenchService } from '@/service/WorkbenchService';
+import { ISessionInfo, UserSessionInfo } from '@/models/userSession';
+import { ICommonResult, CommonResult } from '@/libs/utils/common-dto';
+import { isEnableDebug, isEnableSuperAdmin } from '@/libs/utils/fatcms-request';
+import { ContextLogger } from '@/models/contextLogger';
 import { Stream } from 'node:stream';
-import {VisitStatService} from "../service/VisitStatService";
+import { VisitStatService } from '@/service/VisitStatService';
 
 function isFunction(fun: any): boolean {
   return typeof fun === 'function';
@@ -141,8 +141,6 @@ async function getVisitStatService(ctx: Context): Promise<VisitStatService> {
   return ctx.requestContext.getAsync(VisitStatService);
 }
 
-
-
 /**
  * 检查是否是超级管理员
  * @param ctx
@@ -199,7 +197,6 @@ function handleDebugError(e: any, ctx: Context): ICommonResult {
   return res;
 }
 
-
 async function trackRequest(ctx: Context) {
   try {
     const visitStatService = await getVisitStatService(ctx);
@@ -209,15 +206,22 @@ async function trackRequest(ctx: Context) {
   }
 }
 
+const excludePathPrefix = ['/ns/static/', '/ns/api/helpers'];
+
 /**
  * 全局中间件
  */
 @Middleware()
 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() {
@@ -226,7 +230,6 @@ export class GlobalMiddleware implements IMiddleware<Context, NextFunction> {
       ctx.transaction = new Transaction();
 
       try {
-
         // 支持的站点
         const workbenchService = await getWorkbenchService(ctx);
         const isSupportTheHost = await workbenchService.isSupportCurrentHostForForMiddleware();
@@ -242,7 +245,7 @@ export class GlobalMiddleware implements IMiddleware<Context, NextFunction> {
         ctx.workbenchInfo = await workbenchService.getCurrentHostWorkbenchInfo();
 
         // 数据埋点
-        await trackRequest(ctx)
+        await trackRequest(ctx);
 
         const res0 = await next();
 
@@ -256,7 +259,6 @@ export class GlobalMiddleware implements IMiddleware<Context, NextFunction> {
           return res0;
         }
 
-
         // 其他：普通的JSON数据
         let res = handleExecuteSqlContext(res0);
         res = handleNullRes(res);

package/src/models/AsyncTaskModel.ts

@@ -0,0 +1,79 @@
+export interface SysAsyncTaskEntity {
+  id: number;
+  task_uuid: string;
+  task_name: string;
+  task_description: string | null;
+  task_type: string;
+  task_status: SysAsyncTaskStatus;
+  input_params: any;
+  output_result: any | null;
+
+  input_file_path: string | null;
+  input_file_format: SysAsyncFileFormat | null;
+  input_file_size: number | null;
+
+  output_file_path: string | null;
+  output_file_format: SysAsyncFileFormat | 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;
+  updated_at: Date;
+  expired_at: Date | null;
+  completed_at: Date | null;
+  created_user_session: string;
+}
+
+export type SysAsyncTaskPartial = Partial<SysAsyncTaskEntity>;
+
+export enum SysAsyncTaskStatus {
+  PENDING = 'PENDING', // 等待中，还未进入排队
+  RUNNING = 'RUNNING', // 运行中
+  SUCCEEDED = 'SUCCEEDED', // 终止状态：全部成功
+  PART_SUCCEEDED = 'PART_SUCCEEDED',// 终止状态：部分成功
+  FAILED = 'FAILED', // 终止状态：失败
+  CANCELLED = 'CANCELLED', // 取消
+  PAUSED = 'PAUSED', // 暂停
+}
+
+export enum SysAsyncFileFormat {
+  XLSX = 'xlsx',
+  CSV = 'csv',
+  JSON = 'json',
+  PDF = 'pdf',
+  TXT = 'txt',
+  XML = 'xml',
+  ZIP = 'zip',
+  HTML = 'html',
+  PNG = 'png',
+  JPG = 'jpg',
+}
+
+export interface ISysAsyncTaskHandler {
+  execute(asyncTaskContext: SysAsyncTaskContext): Promise<void>;
+}
+
+export interface SysAsyncTaskContext {
+  task: SysAsyncTaskEntity;
+  updateTaskStatus: (sysAsyncTaskPartial: SysAsyncTaskPartial) => any;
+}
+
+export interface SysAsyncTaskHandlerConfig {
+  taskType: string;
+  handler: ISysAsyncTaskHandler;
+  maxRetries?: number;
+  priority?: number;
+  expireSeconds?: number;
+}

package/src/models/RedisKeys.ts

@@ -0,0 +1,13 @@
+
+
+const RedisKeys = {
+  ASYNC_TASK_LOCK : "FatAsyncTaskLock",
+  ASYNC_TASK_UPDATE_TIME : "FatAsyncTaskUpdateTime",
+  USER_SESSION_PREFIX : "FatUserSession_",
+  VISIT_STAT_LOCK_PREFIX : "FatVsLock_",
+  VISIT_STAT_DATE_PREFIX : "FatVsDate_",
+}
+
+export {
+  RedisKeys
+}

package/src/models/SystemTables.ts

@@ -1,5 +1,3 @@
-import {SqlDbType} from "../libs/crud-pro/models/keys";
-
 export const SystemTables = {
   sys_workbench: 'sys_workbench',
   sys_user_account: 'sys_user_account',
@@ -22,9 +20,8 @@ export const SystemTables = {
   sys_anyapi: 'sys_anyapi',
   sys_proxyapi: 'sys_proxyapi',
   sys_visit_stats: 'sys_visit_stats',
+  sys_async_tasks: 'sys_async_tasks',
 };
 
-export const SystemDbName = 'fatcms';
-export const SystemDbType = SqlDbType.mysql;
 
 export const SystemDevOpsWorkbench = 'devops';

package/src/models/bizmodels.ts

@@ -85,5 +85,4 @@ export interface IVisitorExt extends IVisitor {
   accountType: string;
 }
 
-
-export const FILE_GET_TYPES = ['thumbnail','preview', 'download'];
+export const FILE_GET_TYPES = ['thumbnail', 'preview', 'download'];

package/src/schedule/anonymousContext.ts

@@ -0,0 +1,79 @@
+import * as koa from '@midwayjs/koa';
+import {ContextLogger} from "@/models/contextLogger";
+import {Transaction} from "@/libs/crud-pro/models/Transaction";
+import {ISessionInfo, SYS_ACCOUNT_TYPE, UserSessionInfo} from "@/models/userSession";
+import {IWorkbenchEntity} from "@/models/SystemEntities";
+
+
+const anonymousUserInfo:ISessionInfo = {
+  nickName: 'anonymous_user',
+  avatar: '',
+  roleCodes: [],
+  functionCodes: [],
+  loginName: 'anonymous_user',
+  sessionId: '',
+  accountId: '',
+  workbenchCode: '',
+  accountType: SYS_ACCOUNT_TYPE,
+};
+
+const anonymousWorkbenchInfo: IWorkbenchEntity = {
+  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,
+};
+
+
+export type RunServiceAtAnonymousContextRunner = (ctx: koa.IMidwayKoaContext)=>any;
+
+
+class AnonymousContext {
+  private app: koa.Application;
+
+  setApp(app: koa.Application){
+    this.app = app;
+  }
+
+  getApp(){
+    return this.app;
+  }
+
+
+  async runServiceAtAnonymousContext( runner: RunServiceAtAnonymousContextRunner) {
+    const app = this.app;
+    const ctx: koa.IMidwayKoaContext = app.createAnonymousContext();
+
+    ctx.app = app;
+    ctx.contextLogger = new ContextLogger(ctx as any);
+    ctx.transaction = new Transaction();
+    ctx.userSession = new UserSessionInfo(anonymousUserInfo, true);
+    ctx.workbenchInfo = anonymousWorkbenchInfo;
+
+    let result: any = null;
+    let error: any = 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()
+
+
+
+export {
+  ANONYMOUS_CONTEXT
+}

package/src/schedule/index.ts

@@ -1,73 +1,12 @@
-import * as koa from '@midwayjs/koa';
-import { IScheduleService } from '../interface';
-import { ContextLogger } from '../models/contextLogger';
-import { Transaction } from '../libs/crud-pro/models/Transaction';
-import {ISessionInfo, SYS_ACCOUNT_TYPE, UserSessionInfo} from '../models/userSession';
-import { IWorkbenchEntity } from '../models/SystemEntities';
-
-const scheduleUserInfo:ISessionInfo = {
-  nickName: 'schedule_user',
-  avatar: '',
-  roleCodes: [],
-  functionCodes: [],
-  loginName: 'schedule_user',
-  sessionId: '',
-  accountId: '',
-  workbenchCode: '',
-  accountType: SYS_ACCOUNT_TYPE,
-};
-
-const scheduleWorkbenchInfo: IWorkbenchEntity = {
-  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: koa.Application, serviceName: string) {
-  const ctx = app.createAnonymousContext();
-
-  ctx.app = app;
-  ctx.contextLogger = new ContextLogger(ctx as any);
-  ctx.transaction = new Transaction();
-  ctx.userSession = new UserSessionInfo(scheduleUserInfo, true);
-  ctx.workbenchInfo = scheduleWorkbenchInfo;
-
-  try {
-    const serviceObject: IScheduleService = 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();
-  }
+import {SCHEDULE_QUEUE, runScheduleTaskOnce} from './runSchedule'
+import {ANONYMOUS_CONTEXT} from './anonymousContext'
+import {
+  INNER_SCHEDULE_INTERVAL
+} from './scheduleNames'
+
+export {
+  INNER_SCHEDULE_INTERVAL,
+  ANONYMOUS_CONTEXT,
+  SCHEDULE_QUEUE,
+  runScheduleTaskOnce
 }
-
-async function runSchedule(app: koa.Application, serviceList: string[]) {
-  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);
-    }
-  }
-}
-
-async function startSchedule(app: koa.Application, serviceList: string[]) {
-  await runSchedule(app, serviceList);
-  setInterval(() => {
-    runSchedule(app, serviceList);
-  }, 2 * 60 * 1000);
-}
-
-export { startSchedule };

package/src/schedule/runSchedule.ts

@@ -0,0 +1,83 @@
+import * as koa from '@midwayjs/koa';
+import {IScheduleService} from '@/interface';
+import {ANONYMOUS_CONTEXT} from "./anonymousContext";
+
+
+// 上次执行时间
+const lastExecuteTimeMap = {};
+
+const DEFAULT_SCHEDULE_INTERVAL = 2 * 60 * 1000;
+
+
+async function runScheduleTaskOnce(serviceName: string) {
+
+  return await ANONYMOUS_CONTEXT.runServiceAtAnonymousContext(async (ctx: koa.IMidwayKoaContext) => {
+    const serviceObject: IScheduleService = await ctx.requestContext.getAsync(serviceName);
+    if (serviceObject && serviceObject.runBySchedule) {
+      await serviceObject.runBySchedule();
+    } else {
+      ctx.logger.error(`runSchedule error , serviceName = ${serviceName}, 没有找到服务`);
+    }
+  });
+}
+
+
+class ScheduleQueue {
+  private scheduleIntervalMap: Map<string, number> = new Map();
+
+  public setScheduleTask(serviceName: string, intervalTime: number) {
+    this.scheduleIntervalMap.set(serviceName, intervalTime);
+  }
+
+  public removeScheduleTask(serviceName: string) {
+    this.scheduleIntervalMap.delete(serviceName);
+  }
+
+  private isAlreadyTimeToExecute(serviceName: string): boolean {
+    if (!lastExecuteTimeMap[serviceName]) {
+      return true; // 可以执行
+    }
+    const intervalTime1 = this.scheduleIntervalMap.get(serviceName);
+    const intervalTime = intervalTime1 || DEFAULT_SCHEDULE_INTERVAL; // 时间间隔
+    const lastExecuteTime = lastExecuteTimeMap[serviceName];
+    return (Date.now() - lastExecuteTime) >= intervalTime;
+  }
+
+
+  private async runScheduleTaskOnceCheckTime(serviceName: string) {
+    // 还没有到可以执行时间
+    if (!this.isAlreadyTimeToExecute(serviceName)) {
+      return;
+    }
+    lastExecuteTimeMap[serviceName] = Date.now();
+    await runScheduleTaskOnce(serviceName);
+  }
+
+  private async runScheduleServiceList() {
+    const serviceListKeys = this.scheduleIntervalMap.keys();
+    const serviceList = [...serviceListKeys];
+    for (let i = 0; i < serviceList.length; i++) {
+      const serviceName = serviceList[i];
+      try {
+        await this.runScheduleTaskOnceCheckTime(serviceName);
+      } catch (e) {
+        ANONYMOUS_CONTEXT.getApp().getCoreLogger().error(`runSchedule error , serviceName = ${serviceName}`, e);
+      }
+    }
+  }
+
+
+  public async startScheduleLoop() {
+    await this.runScheduleServiceList();
+    setInterval(() => {
+      this.runScheduleServiceList();
+    }, 1000); // 最少1秒执行一次
+  }
+
+
+}
+
+
+const SCHEDULE_QUEUE = new ScheduleQueue();
+
+export {SCHEDULE_QUEUE, runScheduleTaskOnce};

package/src/schedule/scheduleNames.ts

@@ -0,0 +1,21 @@
+
+const INNER_SCHEDULE_INTERVAL = {
+  proxyApiLoadService: 2 * 60 * 1000, // 2分钟重新加载一次,
+  workbenchService: 60 * 1000, // 1分钟重新加载一次,
+  visitStatService: 10 * 60 * 1000, // 10分钟重新加载一次,
+  asyncTaskRunnerService: 1000, // 1s可以执行
+}
+
+const INNER_SCHEDULE_NAMES = {
+  proxyApiLoadService: 'proxyApiLoadService',
+  workbenchService: 'workbenchService',
+  visitStatService: "visitStatService",
+  asyncTaskRunnerService: "asyncTaskRunnerService",
+}
+
+
+
+export {
+  INNER_SCHEDULE_INTERVAL,
+  INNER_SCHEDULE_NAMES
+}

package/src/service/AuthService.ts

@@ -5,12 +5,13 @@ import { CurdMixService } from './curd/CurdMixService';
 import * as md5 from 'md5';
 import { UserAccountService } from './UserAccountService';
 import { createUniqueId } from '../libs/utils/functions';
-import {IConsumerUserInfo, ISessionInfo, SYS_ACCOUNT_TYPE} from '../models/userSession';
-import {SystemDbName, SystemDbType, SystemTables} from '../models/SystemTables';
+import { IConsumerUserInfo, ISessionInfo, SYS_ACCOUNT_TYPE } from '../models/userSession';
+import { SystemTables } from '../models/SystemTables';
 import { UserSessionService } from './UserSessionService';
 import { CommonResult } from '../libs/utils/common-dto';
 import { isEnableSuperAdmin } from "../libs/utils/fatcms-request";
-import {CommonException} from "../libs/crud-pro/exceptions";
+import { CommonException } from "../libs/crud-pro/exceptions";
+import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
 
 @Provide()
 export class AuthService {
@@ -94,7 +95,7 @@ export class AuthService {
       nickName: consumerUserInfo.nickName,
       avatar: consumerUserInfo.avatar,
       roleCodes: [],
-      functionCodes:[],
+      functionCodes: [],
       loginName: consumerUserInfo.loginName,
       sessionId,
       accountId: consumerUserInfo.accountId,
@@ -141,7 +142,7 @@ export class AuthService {
       sessionId,
       accountId,
       workbenchCode,
-      accountType: SYS_ACCOUNT_TYPE
+      accountType: SYS_ACCOUNT_TYPE,
     };
 
     await this.userSessionService.saveUserSession(sessionInfo);
@@ -203,6 +204,8 @@ export class AuthService {
    * @private
    */
   private async queryUserRoleCodeList(accountId: string): Promise<string[]> {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+
     const res = await this.curdMixService.executeCrudByCfg(
       {
         condition: { account_id: accountId },
@@ -212,7 +215,7 @@ export class AuthService {
         sqlTable: SystemTables.sys_perm_user_role,
         sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
         sqlDatabase: SystemDbName,
-        sqlDdType: SystemDbType,
+        sqlDbType: SystemDbType,
       }
     );
     const rows = res.getResModel().rows || [];
@@ -232,6 +235,8 @@ export class AuthService {
       return [];
     }
 
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+
     const res = await this.curdMixService.executeCrudByCfg(
       {
         condition: { role_code: { $in: roleCodeList } },
@@ -241,7 +246,7 @@ export class AuthService {
         sqlTable: SystemTables.sys_perm_role_func,
         sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
         sqlDatabase: SystemDbName,
-        sqlDdType: SystemDbType,
+        sqlDbType: SystemDbType,
       }
     );
     const rows = res.getResModel().rows || [];
@@ -259,7 +264,7 @@ export class AuthService {
     const oldSessionId = sessionInfo.sessionId;
 
     const sessionId = createUniqueId();
-    const newSessionInfo: ISessionInfo = {...sessionInfo, sessionId};
+    const newSessionInfo: ISessionInfo = { ...sessionInfo, sessionId };
 
     await this.userSessionService.saveUserSession(newSessionInfo);
 

package/src/service/EnumInfoService.ts

@@ -3,10 +3,11 @@ import {Context} from '@midwayjs/koa';
 import {KeysOfSimpleSQL} from '../libs/crud-pro/models/keys';
 import {CurdProService} from './curd/CurdProService';
 import {RelatedType} from './curd/CurdMixUtils';
-import {SystemDbName, SystemDbType, SystemTables} from '../models/SystemTables';
+import {SystemTables} from '../models/SystemTables';
 import {parseConfigContentToEnumInfo, IEnumInfo} from '../libs/utils/parseConfig';
 import {RedisCacheService} from "./base/RedisCacheService";
 import {CurdMixByLinkToCustomService} from "./curd/CurdMixByLinkToCustomService";
+import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
 
 
 interface IQueryEnumInfo {
@@ -88,6 +89,8 @@ export class EnumInfoService {
   }
 
   private async queryEnumInfoBySysCfgEnum(code: string): Promise<IEnumInfo[]> {
+    const {SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    
     const res1 = await this.curdProService.executeCrudByCfg(
       {
         condition: { config_code: code },
@@ -96,7 +99,7 @@ export class EnumInfoService {
         sqlTable: SystemTables.sys_configs,
         sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
         sqlDatabase: SystemDbName,
-        sqlDdType: SystemDbType,
+        sqlDbType: SystemDbType,
       }
     );
     const obj = res1.getOneObj();
@@ -109,6 +112,8 @@ export class EnumInfoService {
   }
 
   private async queryEnumInfoItemByDict(code: string): Promise<IEnumInfo[]> {
+    const {SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    
     const res1 = await this.curdProService.executeCrudByCfg(
       {
         condition: { dict_code: code },
@@ -117,7 +122,7 @@ export class EnumInfoService {
         sqlTable: SystemTables.sys_data_dict_item,
         sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
         sqlDatabase: SystemDbName,
-        sqlDdType: SystemDbType,
+        sqlDbType: SystemDbType,
       }
     );
     const obj = res1.getResRows();

package/src/service/FileCenterService.ts

@@ -10,7 +10,7 @@ import { KeysOfSimpleSQL, KeysOfValidators } from '../libs/crud-pro/models/keys'
 import { AccessType, IEntityCommonInfo, UploadCategoryType } from '../models/bizmodels';
 import { IRequestCfgModel } from '../libs/crud-pro/interfaces';
 import { BaseService } from './base/BaseService';
-import {SystemDbName, SystemDbType} from '../models/SystemTables';
+import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
 
 function getSuffix(s: string): string {
   if (s) {
@@ -107,12 +107,14 @@ class FileDB {
   }
 
   async getFileInfo(fileKey: string): Promise<IFileInfo> {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+
     const condition: any = { file_key: fileKey };
     const cfgModel: IRequestCfgModel = {
       sqlTable: 'sys_file',
       sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
       sqlDatabase: SystemDbName,
-      sqlDdType: SystemDbType,
+      sqlDbType: SystemDbType,
       validateCfg: {
         'condition.file_key': [KeysOfValidators.REQUIRED, KeysOfValidators.STRING],
       },
@@ -123,11 +125,13 @@ class FileDB {
   }
 
   async saveFileInfo(fileInfo: IFileInfo) {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+
     const cfgModel = {
       sqlTable: 'sys_file',
       sqlSimpleName: KeysOfSimpleSQL.SIMPLE_INSERT,
       sqlDatabase: SystemDbName,
-      sqlDdType: SystemDbType,
+      sqlDbType: SystemDbType,
     };
     return await this.curdMixService.executeCrudByCfg(
       {
@@ -141,21 +145,23 @@ class FileDB {
   }
 
   async saveAssetsLog(fileInfo: IFileInfo) {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
     const cfgModel = {
       sqlTable: 'sys_assets_log',
       sqlSimpleName: KeysOfSimpleSQL.SIMPLE_INSERT,
       sqlDatabase: SystemDbName,
-      sqlDdType: SystemDbType,
+      sqlDbType: SystemDbType,
     };
     return await this.curdMixService.executeCrudByCfg({ data: fileInfo }, cfgModel);
   }
 
   async deleteFileInfo(id: number) {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
     const cfgModel: IRequestCfgModel = {
       sqlTable: 'sys_file',
       sqlSimpleName: KeysOfSimpleSQL.SIMPLE_DELETE,
       sqlDatabase: SystemDbName,
-      sqlDdType: SystemDbType,
+      sqlDbType: SystemDbType,
       validateCfg: {
         'condition.id': [KeysOfValidators.REQUIRED, KeysOfValidators.NUMBER],
       },
@@ -200,7 +206,7 @@ function toUploadOriginByReferer(referer: string): string {
       return 'doc-editor';
     }
     if (pathname.startsWith('/pages/devops/file-manage')) {
-      return  'file-manage';
+      return 'file-manage';
     }
   } catch (error) {
     console.error('toUploadOriginByReferer', error);