midway-fatcms 0.0.1-beta.1

package/src/service/base/ApiRateLimiter.ts

@@ -0,0 +1,59 @@
+import { LRUCache } from 'lru-cache';
+
+// 定义 TokenBucket 类
+class TokenBucket {
+  private capacity: number;
+  private fillRate: number;
+  private tokens: number;
+  private lastRefillTime: number;
+
+  constructor(capacity: number, fillRate: number) {
+    this.capacity = capacity;
+    this.fillRate = fillRate;
+    this.tokens = capacity;
+    this.lastRefillTime = Date.now();
+  }
+
+  private refill(): void {
+    const now = Date.now();
+    const elapsedTime = (now - this.lastRefillTime) / 1000;
+    const newTokens = elapsedTime * this.fillRate;
+    this.tokens = Math.min(this.capacity, this.tokens + newTokens);
+    this.lastRefillTime = now;
+  }
+
+  public tryAcquire(tokensNeeded = 1): boolean {
+    this.refill();
+    if (this.tokens >= tokensNeeded) {
+      this.tokens -= tokensNeeded;
+      return true;
+    }
+    return false;
+  }
+}
+
+// 定义一个全局的 Map 来存储不同接口和用户组合的令牌桶
+const apiUserBuckets = new LRUCache<string, TokenBucket>({
+  max: 500,
+  ttl: 1000 * 60 * 5,
+  ttlAutopurge: true,
+});
+
+/**
+ * 对接口ID ， 每个用户ID 进行限流。
+ * @param apiId 接口ID
+ * @param userId 用户ID
+ * @param limit_max 限流令牌桶最大值，最大容量
+ * @param limit_rate 每秒产生的令牌数量
+ * @return {Boolean} 返回token是否可以用。不能被处理就返回false
+ */
+function tryAcquireToken(apiId: string, userId: string, limit_max: number, limit_rate: number): boolean {
+  const key = `${apiId}-${userId}`;
+  if (!apiUserBuckets.has(key)) {
+    apiUserBuckets.set(key, new TokenBucket(limit_max, limit_rate));
+  }
+  const bucket = apiUserBuckets.get(key)!;
+  return bucket.tryAcquire();
+}
+
+export { tryAcquireToken };

package/src/service/base/BaseService.ts

@@ -0,0 +1,74 @@
+import { Inject, Provide, App } from '@midwayjs/core';
+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';
+
+
+@Provide()
+export class BaseService {
+  @Inject()
+  protected ctx: Context;
+
+  @App()
+  protected app: koa.Application;
+
+  @Inject()
+  protected redisService: RedisService;
+
+  @Inject()
+  protected ossServiceFactory: OSSServiceFactory;
+
+
+  /**
+   * 用户自己上传的文件，使用私有的bucket。
+   * @protected
+   */
+  protected getPrivateOSSService(): OSSService {
+    return this.ossServiceFactory.get<OSSService>('privateBucket');
+  }
+
+  /**
+   * 公共读的bucket，如js文件等使用它
+   * @protected
+   */
+  protected getPublicOSSService(): OSSService {
+    return this.ossServiceFactory.get<OSSService>('publicBucket');
+  }
+
+
+  protected getContextLogger(): ILoggerContext {
+    return this.ctx.contextLogger || consoleLogger;
+  }
+
+  protected getPrefixContextLogger(prefix: string) {
+    const s = this.ctx.contextLogger as ContextLogger;
+    return s.getPrefixContextLogger(prefix);
+  }
+
+  protected logInfo(msg: string, ...args: any) {
+    this.getContextLogger().info(msg, ...args);
+  }
+
+  protected logError(msg: string, ...args: any) {
+    this.getContextLogger().error(msg, ...args);
+  }
+
+  protected logWarn(msg: string, ...args: any) {
+    this.getContextLogger().warn(msg, ...args);
+  }
+
+  protected logDebug(msg: string, ...args: any) {
+    this.getContextLogger().debug(msg, ...args);
+  }
+
+  protected isLocalEnv(): boolean {
+    return isLocalEnv(this.ctx);
+  }
+
+  protected isEnableDebug(): boolean {
+    return isEnableDebug(this.ctx);
+  }
+}

package/src/service/base/RedisCacheService.ts

@@ -0,0 +1,38 @@
+import { Inject, Provide, App } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { RedisService } from '@midwayjs/redis';
+import { OSSServiceFactory } from '@midwayjs/oss';
+import * as koa from '@midwayjs/koa';
+import {parseJsonObject} from "../../libs/utils/functions";
+
+
+@Provide()
+export class RedisCacheService {
+  @Inject()
+  protected ctx: Context;
+
+  @App()
+  protected app: koa.Application;
+
+  @Inject()
+  protected redisService: RedisService;
+
+  @Inject()
+  protected ossServiceFactory: OSSServiceFactory;
+
+
+  async getJsonObject(key: string): Promise<any>  {
+    const str = await this.redisService.get(key);
+    return parseJsonObject(str)
+  }
+
+  async setJsonObject(key: string, obj: any, expireSecond: number): Promise<any> {
+    const str = JSON.stringify(obj);
+    return this.redisService.set(key, str, 'EX', expireSecond);
+  }
+
+  async removeItem(key: string): Promise<any>  {
+    return await this.redisService.del(key);
+  }
+
+}

package/src/service/crudstd/CrudStdActionService.ts

@@ -0,0 +1,27 @@
+import { Inject, Provide } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import * as _ from 'lodash';
+import { CurdMixService } from '../curd/CurdMixService';
+import { IRequestModel } from '../../libs/crud-pro/interfaces';
+import { ICrudStdAppInfo } from '../../models/bizmodels';
+import { BaseService } from '../base/BaseService';
+
+interface IHandleStdActionByReq {
+  actionsMap: any;
+  appInfo: ICrudStdAppInfo;
+  params: IRequestModel;
+  actionCfg: any;
+}
+
+@Provide()
+export class CrudStdActionService extends BaseService {
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  protected curdMixService: CurdMixService;
+
+  public async handleStdActionByReq({ appInfo, params, actionCfg }: IHandleStdActionByReq) {
+    return null;
+  }
+}

package/src/service/crudstd/CrudStdConstant.ts

@@ -0,0 +1,62 @@
+/**
+ * 工具栏的动作。一般都是批量操作
+ */
+const toolbarOptions = {
+  ToolbarCreateFormPro: 'ToolbarCreateFormPro', // 新建
+  ToolbarBatchEditFormPro: 'ToolbarBatchEditFormPro', // 批量编辑
+  ToolbarBatchDelete: 'ToolbarBatchDelete', //批量删除
+  ToolbarBatchCreate: 'ToolbarBatchCreate', // 批量新建
+  ToolbarSpecializedScene: 'ToolbarSpecializedScene',
+  ToolbarOpenURL: 'ToolbarOpenURL',
+};
+
+/**
+ * 操作列的可选项
+ * @type {{}}
+ */
+const actionColumnOptions = {
+  ActionDialogEditFormPro: 'ActionDialogEditFormPro',
+  ActionDialogDelete: 'ActionDialogDelete',
+  ActionLinkTo: 'ActionLinkTo', // 跳转链接(自动拼参数)
+  ActionLinkToCustom: 'ActionLinkToCustom', // 跳转链接(完全自定义)
+  ActionDialogEditJSON: 'ActionDialogEditJSON',
+  ActionDialogEditHTML: 'ActionDialogEditHTML',
+  ActionDialogEditText: 'ActionDialogEditText',
+  ActionDialogEditRichText: 'ActionDialogEditRichText',
+  ActionDialogEditExcel: 'ActionDialogEditExcel',
+  ActionDrawerRelationCrud: 'ActionDrawerRelationCrud', // 关联对象CRUD
+  ActionSpecializedScene: 'ActionSpecializedScene',
+};
+
+/**
+ * 表格列展示字段
+ * @type {{}}
+ */
+const tableColumnRenders = {
+  RenderString: 'RenderString',
+  RenderDictEnumText: 'RenderDictEnumText',
+  RenderDictEnumStatus: 'RenderDictEnumStatus',
+  RenderEntityStatus: 'RenderEntityStatus',
+  RenderDateTime: 'RenderDateTime',
+  RenderDate: 'RenderDate',
+  RenderImage: 'RenderImage',
+  RenderLink: 'RenderLink',
+  RenderHTML: 'RenderHTML',
+  RenderJSON: 'RenderJSON',
+  RenderDialogText: 'RenderDialogText',
+  RenderDialogHTML: 'RenderDialogHTML',
+  RenderDialogJSON: 'RenderDialogJSON',
+  RenderUserInfo: 'RenderUserInfo',
+};
+
+/**
+ * 字段关联数据类型
+ * @type {{}}
+ */
+const fieldLinkToTypes = {
+  linkToDict: 'linkToDict',
+  linkToSysCfgEnum: 'linkToSysCfgEnum',
+  linkToCustom: 'linkToCustom',
+};
+
+export { toolbarOptions, actionColumnOptions, tableColumnRenders, fieldLinkToTypes };

package/src/service/crudstd/CrudStdRelationService.ts

@@ -0,0 +1,78 @@
+import { Inject, Provide } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import * as _ from 'lodash';
+import { CurdMixService } from '../curd/CurdMixService';
+import { IRequestCfgModel } from '../../libs/crud-pro/interfaces';
+import { ICrudStdAppInfoForSettingKey } from '../../models/bizmodels';
+import { BaseService } from '../base/BaseService';
+import { tableColumnRenders, fieldLinkToTypes } from './CrudStdConstant';
+import { RelatedType } from '../curd/CurdMixUtils';
+
+@Provide()
+export class CrudStdRelationService extends BaseService {
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  protected curdMixService: CurdMixService;
+
+  async addCfgModelColumnsRelation(cfgModel: IRequestCfgModel, appInfo: ICrudStdAppInfoForSettingKey) {
+    const tableColumns = appInfo?.stdCrudCfgObj?.tableColumns;
+    const tableFields = appInfo?.stdCrudCfgObj?.tableFields || [];
+
+    if (!Array.isArray(tableColumns)) {
+      return;
+    }
+
+    const columnsRelation = [];
+    cfgModel.columnsRelation = columnsRelation;
+    for (let i = 0; i < tableColumns.length; i++) {
+      const tableColumn = tableColumns[i];
+      const dataIndex = _.get(tableColumn, 'dataIndex');
+      const componentName = _.get(tableColumn, 'component.componentName');
+
+      // 关联用户信息
+      if (componentName === tableColumnRenders.RenderUserInfo) {
+        columnsRelation.push({
+          relatedType: RelatedType.accountBasic,
+          sourceColumn: dataIndex,
+          targetColumns: [], // 使用默认
+        });
+      }
+
+      // 关联枚举文案/状态标签颜色
+      if (componentName === tableColumnRenders.RenderDictEnumText || componentName === tableColumnRenders.RenderDictEnumStatus) {
+        const fieldCfg = tableFields.find(f => {
+          return f.fieldIndex === dataIndex;
+        });
+
+        if (fieldCfg && fieldCfg.linkToType === fieldLinkToTypes.linkToCustom) {
+          columnsRelation.push({
+            relatedType: RelatedType.linkToCustom,
+            relatedCode: fieldCfg.linkToCustom,
+            sourceColumn: dataIndex,
+            targetColumns: [], // 使用默认
+          });
+        }
+
+        if (fieldCfg && fieldCfg.linkToType === fieldLinkToTypes.linkToSysCfgEnum) {
+          columnsRelation.push({
+            relatedType: RelatedType.sysCfgEnum,
+            relatedCode: fieldCfg.linkToSysCfgEnumCode,
+            sourceColumn: dataIndex,
+            targetColumns: [], // 使用默认
+          });
+        }
+
+        if (fieldCfg && fieldCfg.linkToType === fieldLinkToTypes.linkToDict) {
+          columnsRelation.push({
+            relatedType: RelatedType.dict,
+            relatedCode: fieldCfg.linkToDictCode,
+            sourceColumn: dataIndex,
+            targetColumns: [], // 使用默认
+          });
+        }
+      }
+    }
+  }
+}

package/src/service/crudstd/CrudStdService.ts

@@ -0,0 +1,188 @@
+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 { 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 { CrudStdActionService } from './CrudStdActionService';
+import { CrudStdRelationService } from './CrudStdRelationService';
+import * as _ from 'lodash';
+import { ApiBaseService } from '../base/ApiBaseService';
+import {parseDatabaseName} from "../../libs/crud-pro/utils/DatabaseName";
+
+export const SPECIAL_SETTING_KEY = {
+  QUERY_LIST: 'QUERY_LIST',
+  QUERY_ONE: 'QUERY_ONE',
+};
+
+@Provide()
+export class CrudStdService extends ApiBaseService {
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  protected curdMixService: CurdMixService;
+
+  @Inject()
+  protected crudStdActionService: CrudStdActionService;
+
+  @Inject()
+  protected crudStdRelationService: CrudStdRelationService;
+
+  /**
+   * 执行普通CRUD
+   */
+  public async executeStdQuery(appCode: string, settingKey: string, params: IRequestModel, sqlSimpleName: KeysOfSimpleSQL) {
+    const appInfo = await this.getParsedCrudStdAppForSettingKey(appCode, settingKey);
+    const stdCrudCfgObj = appInfo.stdCrudCfgObj;
+
+    if (!appInfo || appInfo.status !== 1) {
+      throw new BizException('应用不存在或已下线：' + appCode);
+    }
+
+    const databaseName = stdCrudCfgObj.tableBaseInfo.databaseName;
+
+    const { dbType, dbName } = parseDatabaseName(databaseName);
+
+    const cfgModel: IRequestCfgModel = {
+      sqlDatabase: dbName,
+      sqlDdType: dbType,
+      sqlTable: stdCrudCfgObj.tableBaseInfo.tableName,
+      sqlSimpleName,
+    };
+
+    // 接口返回最大值
+    const maxLimit = _.get(stdCrudCfgObj, 'othersSetting.values.maxLimit');
+    if (typeof maxLimit === 'number' && maxLimit > 0) {
+      cfgModel.maxLimit = maxLimit;
+    }
+
+    if (!appInfo.settingKeyActionCfg.hasOperationPerm) {
+      throw new BizException('没有权限');
+    }
+
+    // 根据用户配置，设置关联查询的数据信息。
+    await this.crudStdRelationService.addCfgModelColumnsRelation(cfgModel, appInfo);
+    return await this.curdMixService.executeCrudByCfg(params, cfgModel);
+  }
+
+  /**
+   * 获取appInfo 并且拿到当前settingKey相关的信息
+   * @param appCode
+   * @param settingKey
+   * @private
+   */
+  private async getParsedCrudStdAppForSettingKey(appCode: string, settingKey: string): Promise<ICrudStdAppInfoForSettingKey> {
+    if (!appCode) {
+      throw new BizException('缺少参数:curdStdAppCode');
+    }
+    const appInfo: ICrudStdAppInfoForSettingKey = await this.getParsedCrudStdAppInfo(appCode);
+    if (!appInfo) {
+      return null;
+    }
+
+    const actionsMap = appInfo.actionsMap;
+    const appSchema = appInfo.stdCrudCfgObj;
+
+    if (settingKey === SPECIAL_SETTING_KEY.QUERY_LIST || settingKey === SPECIAL_SETTING_KEY.QUERY_ONE) {
+      const authSettingValues = _.get(appSchema, 'authSetting.values');
+      const { auth_type, auth_config_by_func_code, auth_config_by_role_code } = authSettingValues || {};
+      const authConfig = auth_type === 'byFuncCode' ? auth_config_by_func_code : auth_config_by_role_code;
+      const hasOperationPerm = this.ctx.userSession.isAuthPass(auth_type as any, authConfig);
+      appInfo.settingKeyActionCfg = { settingKey, hasOperationPerm };
+    } else {
+      const actionCfg = actionsMap[settingKey];
+      if (!actionCfg) {
+        throw new BizException('没有找到相关配置:' + JSON.stringify({ appCode, settingKey }));
+      }
+      const componentNameCfg = _.get(actionCfg, 'component.componentName');
+      if (!componentNameCfg) {
+        throw new BizException('没有配置动作组件:' + JSON.stringify({ appCode, settingKey }));
+      }
+      appInfo.settingKeyActionCfg = actionCfg;
+    }
+
+    return appInfo;
+  }
+
+  /**
+   * 执行动作
+   * @param appCode
+   * @param settingKey
+   * @param params
+   */
+  public async executeStdActionByReq(appCode: string, settingKey: string, params: IRequestModel): Promise<ExecuteContext> {
+    const appInfo = await this.getParsedCrudStdAppForSettingKey(appCode, settingKey);
+    if (!appInfo || appInfo.status !== 1) {
+      throw new BizException('应用不存在或已下线：' + appCode);
+    }
+
+    const actionsMap = appInfo.actionsMap;
+    const actionCfg = appInfo.settingKeyActionCfg;
+
+    return this.crudStdActionService.handleStdActionByReq({ appInfo, params, actionsMap, actionCfg });
+  }
+
+  /**
+   * 查询APP信息
+   * @param appCode
+   * @private
+   */
+  private async getCrudStdAppInfo(appCode?: string) {
+    this.logInfo('getCrudStdAppInfo', appCode);
+
+    const ss = {
+      sqlTable: SystemTables.sys_app,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
+      sqlDatabase: SystemDbName,
+      sqlDdType: SystemDbType,
+    };
+    return await this.curdMixService.executeCrudByCfg({ condition: { app_code: appCode } }, ss);
+  }
+
+  /**
+   * 查询APP信息
+   * @param appCode
+   * @private
+   */
+  public async getParsedCrudStdAppInfo(appCode: string): Promise<ICrudStdAppInfo> {
+    const a = await this.getCrudStdAppInfo(appCode);
+    const { row } = a.getResModel();
+    if (!row) {
+      return null;
+    }
+    const { app_schema, ...others } = row;
+    const stdCrudCfgObj = parseJsonObject(app_schema);
+
+    // 为了方便查找到action对象
+    const actionsMap = {};
+    const keys = Object.keys(stdCrudCfgObj);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const arrayCfg = stdCrudCfgObj[key];
+      if (Array.isArray(arrayCfg)) {
+        for (let j = 0; j < arrayCfg.length; j++) {
+          const actionCfg = arrayCfg[j];
+          actionCfg.hasOperationPerm = this.hasOperationPerm(actionCfg);
+          if (actionCfg.settingKey) {
+            actionsMap[actionCfg.settingKey] = actionCfg;
+          }
+        }
+      }
+    }
+
+    return { ...others, stdCrudCfgObj, actionsMap };
+  }
+
+  private hasOperationPerm(actionCfg: any): boolean {
+    const permissionCode = _.get(actionCfg, 'permissionCode');
+    if (permissionCode) {
+      return this.ctx.userSession.isAuthPass(KeysOfAuthType.byFuncCode, permissionCode);
+    }
+    return true; // 无需鉴权
+  }
+}

package/src/service/curd/CurdMixByAccountService.ts

@@ -0,0 +1,83 @@
+import { Inject, Provide } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+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 { KeysOfSimpleSQL } from '../../libs/crud-pro/models/keys';
+import { ColumnRelation, IRequestCfgModel, IRequestModel } from '../../libs/crud-pro/interfaces';
+import { MixinUtils } from '../../libs/crud-pro/utils/MixinUtils';
+
+const dictMixUtils = new CrudMixUtils(RelatedType.accountBasic);
+
+const TMP_CTX_KEY = _.uniqueId('CurdMixByAccountService');
+
+@Provide()
+export class CurdMixByAccountService implements IExecuteContextHandler {
+  @Inject()
+  ctx: Context;
+
+  @Inject()
+  protected curdProService: CurdProService;
+
+  async handleExecuteContextPrepare(executeContext: ExecuteContext) {
+    const relations = dictMixUtils.pickColumnRelations(executeContext);
+    if (!relations || relations.length === 0) {
+      return;
+    }
+
+    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 (accountIds.size === 0) {
+      return;
+    }
+
+    const cfgModel: IRequestCfgModel = {
+      method: 'UserAccountService.queryAccountBasicInfoByIds',
+      sqlTable: SystemTables.sys_user_account,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+      sqlDatabase: SystemDbName,
+      sqlDdType: SystemDbType,
+    };
+
+    const reqJson: IRequestModel = {
+      columns: ['nick_name', 'avatar', 'account_id'],
+      condition: {
+        account_id: {
+          $in: [...accountIds],
+        },
+      },
+    };
+
+    const res = await this.curdProService.executeCrudByCfg(reqJson, cfgModel);
+    const userInfos = res.getResRows();
+    executeContext[TMP_CTX_KEY] = MixinUtils.toNewMap(userInfos, (obj: any) => obj.account_id);
+  }
+
+  async handleExecuteContext(executeContext: ExecuteContext): Promise<void> {
+    const userInfoMap = executeContext[TMP_CTX_KEY] as Map<string, any>;
+    if (!userInfoMap || userInfoMap.size === 0) {
+      return;
+    }
+
+    dictMixUtils.forEachRowAndColumnsRelation(executeContext, (row: any, columnRelation: ColumnRelation) => {
+      const sourceColumn = columnRelation.sourceColumn;
+      const targetColumns = columnRelation.targetColumns;
+      if (!Array.isArray(targetColumns) || targetColumns.length === 0) {
+        columnRelation.targetColumns = [
+          { from: 'nick_name', to: `${sourceColumn}_user.nick_name` },
+          { from: 'avatar', to: `${sourceColumn}_user.avatar` },
+        ];
+      }
+      dictMixUtils.copyColumnRelationToRowNoRelatedCode(row, userInfoMap, columnRelation);
+    });
+  }
+}