midway-fatcms 0.0.1-beta.55 → 0.0.1-beta.56

package/src/service/VisitStatService.ts

@@ -0,0 +1,166 @@
+import { Inject, Provide } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { IScheduleService } from '@/interface';
+import { BaseService } from './base/BaseService';
+import { CurdProService } from './curd/CurdProService';
+import { SystemTables } from '@/models/SystemTables';
+import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
+import { FILE_GET_TYPES } from '@/models/bizmodels';
+import { CommonResult } from '@/libs/utils/common-dto';
+import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
+import { RedisKeys } from '@/models/RedisKeys';
+
+// 3天 的秒数
+const EXPIRE_TIME = 3 * 24 * 60 * 60;
+
+const STAT_TYPES = {
+  pv: 'pv',
+  uv_ip: 'uv_ip',
+  uv_uid: 'uv_uid',
+};
+
+@Provide()
+export class VisitStatService extends BaseService implements IScheduleService {
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  private curdProService: CurdProService;
+
+  async runBySchedule(): Promise<any> {
+    const hours = new Date().getHours();
+    this.logInfo('[VisitStatService] runBySchedule called, hours = ' + hours);
+    return this.flushVisitStatToDB();
+  }
+
+  async flushVisitStatToDB(): Promise<any> {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+
+    //  统计昨天的数据。
+    const stat_date = new Date(Date.now() - 24 * 3600 * 1000).toISOString().split('T')[0];
+
+    const lockKey = `${RedisKeys.VISIT_STAT_LOCK_PREFIX}${stat_date}`;
+    // 每天只能执行一次
+    const client = this.redisService;
+    const nxRes = await client.set(lockKey, 1, 'EX', EXPIRE_TIME, 'NX');
+    if (nxRes !== 'OK') {
+      this.logInfo('[VisitStatService] flushVisitStatToDB 每天只能执行一次 ');
+      return CommonResult.errorRes('每天只能执行一次');
+    }
+
+    this.logInfo('[VisitStatService] flushVisitStatToDB start ');
+
+    let totalCount = 0;
+    let successCount = 0;
+
+    try {
+      const keys = await client.keys(`${RedisKeys.VISIT_STAT_DATE_PREFIX}${stat_date}::*`);
+      // `vs_${date}::${req_host}::${resource_type}::${stat_type}::${resource}`;
+      totalCount = keys.length;
+
+      for (const key of keys) {
+        try {
+          const parts = key.split('::');
+          if (parts.length === 5) {
+            const req_host = parts[1];
+            const resource_type = parts[2];
+            const stat_type = parts[3];
+            const stat_resource = parts[4];
+
+            let stat_count: number;
+            if (stat_type === STAT_TYPES.uv_ip || stat_type === STAT_TYPES.uv_uid) {
+              stat_count = await client.scard(key);
+            } else {
+              stat_count = parseInt(await client.get(key)) || 0;
+            }
+
+            await this.curdProService.executeCrudByCfg(
+              {
+                data: {
+                  stat_date,
+                  stat_resource,
+                  stat_type,
+                  resource_type,
+                  stat_count,
+                  req_host,
+                },
+              },
+              {
+                sqlSimpleName: KeysOfSimpleSQL.SIMPLE_INSERT,
+                sqlDatabase: SystemDbName,
+                sqlDbType: SystemDbType,
+                sqlTable: SystemTables.sys_visit_stats,
+              }
+            );
+
+            await client.del(key);
+            successCount++;
+          }
+        } catch (e) {
+          this.logError('[VisitStatService] flushVisitStatToDB: key = ' + key, e);
+          console.log('[VisitStatService] flushVisitStatToDB: key = ' + key, e);
+        }
+      }
+    } catch (error) {
+      this.logError('[VisitStatService] flushVisitStatToDB', error);
+      console.log('[VisitStatService] flushVisitStatToDB', error);
+    }
+
+    this.logInfo('[VisitStatService] flushVisitStatToDB end ');
+
+    return CommonResult.successRes({ successCount, totalCount });
+  }
+
+  /**
+   * 统计请求数据
+   */
+  async trackRequest(resource: string, resourceType: string) {
+    // 文件下载定制
+    if (resource.startsWith('/ns/gw/file/get/')) {
+      for (let i = 0; i < FILE_GET_TYPES.length; i++) {
+        const fileGetType = FILE_GET_TYPES[i];
+        const pathPrefix = `/ns/gw/file/get/${fileGetType}/`;
+        if (resource.startsWith(pathPrefix)) {
+          const res2 = resource.substring(pathPrefix.length);
+          return this.trackRequestImpl(res2, fileGetType);
+        }
+      }
+    }
+
+    // 文档访问定制
+    if (resource.startsWith('/ns/app/doc-editor/libview')) {
+      const { docLibId, docId } = this.ctx.query || {};
+      return this.trackRequestImpl(`${docLibId},${docId}`, 'docLibView');
+    }
+
+    return this.trackRequestImpl(resource, resourceType);
+  }
+
+  private async trackRequestImpl(resource: string, resource_type: string) {
+    const client = this.redisService;
+    const ip = this.ctx.headers['x-real-ip'];
+    const userSession = this.ctx.userSession;
+    const req_host = this.ctx?.request?.host || 'null'; // 域名
+    const date = new Date().toISOString().split('T')[0];
+
+    const toDateResourceKey = (stat_type: string): string => {
+      return `${RedisKeys.VISIT_STAT_DATE_PREFIX}${date}::${req_host}::${resource_type}::${stat_type}::${resource}`;
+    };
+
+    const pv_key = toDateResourceKey(STAT_TYPES.pv);
+    const uv_ip_key = toDateResourceKey(STAT_TYPES.uv_ip);
+    const uv_uid_key = toDateResourceKey(STAT_TYPES.uv_uid);
+
+    // 统计 PV
+    await Promise.all([client.incr(pv_key), client.expire(pv_key, EXPIRE_TIME)]);
+
+    // IP 访问 UV
+    await Promise.all([client.sadd(uv_ip_key, `${ip}`), client.expire(uv_ip_key, EXPIRE_TIME)]);
+
+    if (userSession && userSession.isLogin()) {
+      const accountId = userSession.getSessionInfo().accountId;
+      // 统计 UV
+      await Promise.all([client.sadd(uv_uid_key, accountId), client.expire(uv_uid_key, EXPIRE_TIME)]);
+    }
+  }
+}

package/src/service/WorkbenchService.ts

@@ -0,0 +1,220 @@
+import { Inject, Provide, Config } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
+import { SystemTables } from '@/models/SystemTables';
+import { BaseService } from './base/BaseService';
+// import { LRUCache } from 'lru-cache';
+import { CurdProService } from './curd/CurdProService';
+import { CommonException } from '@/libs/crud-pro/exceptions';
+import { parseJsonObject } from '@/libs/utils/functions';
+import { IWorkbenchEntity } from '@/models/SystemEntities';
+import { IScheduleService } from '@/interface';
+import { getDebugWorkbenchCode } from '@/libs/utils/fatcms-request';
+import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
+import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
+import { HEADER_KEY_RUN_BY_ASYNC_TASK_WORKBENCH_CODE } from '@/models/AsyncTaskModel';
+//
+// const lruCache = new LRUCache<string, any>({
+//   max: 500,
+//   ttl: 1000 * 60 * 60,
+//   ttlAutopurge: true,
+// });
+
+const lruCache = new Map<string, any>();
+
+const CACHE_KEY_WORKBENCH_LIST = 'CACHE_KEY_WORKBENCH_LIST';
+const CACHE_KEY_DOMAIN_MAP = 'CACHE_KEY_DOMAIN_MAP';
+
+@Provide()
+export class WorkbenchService extends BaseService implements IScheduleService {
+  @Inject()
+  ctx: Context;
+
+  @Inject()
+  private curdProService: CurdProService;
+
+  @Config('fatcmsTargetWorkbenchCode')
+  private fatcmsTargetWorkbenchCode: string;
+
+  public clearCache() {
+    lruCache.set(CACHE_KEY_WORKBENCH_LIST, null);
+    lruCache.set(CACHE_KEY_DOMAIN_MAP, null);
+  }
+
+  public async runBySchedule() {
+    await this.getAllWorkbenchInfoMap(true);
+  }
+
+  /**
+   * 获取所有站点列表
+   * @param isForceRefresh 是否强制刷新缓存
+   * @returns
+   */
+  public async getAllWorkbenchInfoList(isForceRefresh?: boolean): Promise<IWorkbenchEntity[]> {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+
+    let listData = lruCache.get(CACHE_KEY_WORKBENCH_LIST);
+    if (!listData || isForceRefresh === true) {
+      const reqJson = { condition: {}, pageSize: 1000, limit: 1000 };
+      const res = await this.curdProService.executeCrudByCfg(reqJson, {
+        sqlTable: SystemTables.sys_workbench,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+      });
+      listData = res.getResRows();
+      lruCache.set(CACHE_KEY_WORKBENCH_LIST, listData);
+    }
+    return listData;
+  }
+
+  /**
+   * 获取所有站点列表，以map的形式返回。其中key为站点域名，value为站点信息
+   * @param isForceRefresh 是否强制刷新缓存
+   * @returns
+   */
+  public async getAllWorkbenchInfoMap(isForceRefresh?: boolean): Promise<Record<any, IWorkbenchEntity>> {
+    let listData: any[];
+    let domainMap = lruCache.get(CACHE_KEY_DOMAIN_MAP);
+    if (!domainMap || isForceRefresh === true) {
+      listData = await this.getAllWorkbenchInfoList(isForceRefresh);
+      const domainMap1 = MixinUtils.toMap(listData, (e: any) => e.workbench_domain); // 主域名。其他两个域名。
+      const domainMap2 = MixinUtils.toMap(listData, (e: any) => e.workbench_domain2);
+      const domainMap3 = MixinUtils.toMap(listData, (e: any) => e.workbench_domain3);
+      domainMap = { ...domainMap1, ...domainMap2, ...domainMap3 };
+      lruCache.set(CACHE_KEY_DOMAIN_MAP, domainMap);
+    }
+    return domainMap;
+  }
+
+  /**
+   * 检查站点编码是否匹配
+   * @param workbench_code_array 站点编码数组
+   * @param workbench_code 站点编码
+   * @returns
+   */
+  public isMatchWorkbenchCode(workbench_code_array: string | string[], workbench_code: string): boolean {
+    if (workbench_code_array === '*') {
+      return true;
+    }
+    const supportWorkbenchArray = parseJsonObject(workbench_code_array)
+      .map(s => s.trim())
+      .filter(Boolean);
+
+    return supportWorkbenchArray.includes('*') || supportWorkbenchArray.includes(workbench_code);
+  }
+
+  /**
+   * 根据站点编码获取站点信息
+   * @param workbenchCode 站点编码
+   * @returns
+   */
+  private async getWorkbenchInfoByCode(workbenchCode: string): Promise<IWorkbenchEntity> {
+    const list = await this.getAllWorkbenchInfoList();
+    for (let i = 0; i < list.length; i++) {
+      const workbenchInfo = list[i];
+      if (workbenchInfo.workbench_code === workbenchCode) {
+        return workbenchInfo;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 根据域名获取站点信息
+   * @param host 域名
+   * @returns
+   */
+  private async getWorkbenchInfoByHost(host: string): Promise<IWorkbenchEntity> {
+    const domainMap = await this.getAllWorkbenchInfoMap();
+    return domainMap[host];
+  }
+
+  /**
+   * 获取当前请求的域名所对应的站点信息
+   */
+  public async getCurrentHostWorkbenchInfo(): Promise<IWorkbenchEntity> {
+    // 本地调试模式
+    if (this.isEnableDebug() && this.isLocalEnv()) {
+      const debugWorkbenchCode = getDebugWorkbenchCode(this.ctx);
+      if (!debugWorkbenchCode) {
+        throw new CommonException('本地环境调试时需要使用ModHeader浏览器插件，指定站点编码');
+      }
+      return await this.getWorkbenchInfoByCode(debugWorkbenchCode);
+    }
+
+    // 内部异步任务，指定了workbench code
+    const asyncTaskWorkbenchCode = this.ctx.headers[HEADER_KEY_RUN_BY_ASYNC_TASK_WORKBENCH_CODE];
+    if (asyncTaskWorkbenchCode && typeof asyncTaskWorkbenchCode === 'string') {
+      return await this.getWorkbenchInfoByCode(asyncTaskWorkbenchCode);
+    }
+
+    // 只有一个workbench的场景。对于后台系统。不需要配置域名的场景。
+    const fatcmsTargetWorkbenchCode = this.fatcmsTargetWorkbenchCode;
+    if (typeof fatcmsTargetWorkbenchCode === 'string' && fatcmsTargetWorkbenchCode.length > 3) {
+      return await this.getWorkbenchInfoByCode(fatcmsTargetWorkbenchCode);
+    }
+
+    //正式环境： 根据域名获取站点配置
+    const host = this.getCurrentHost();
+    const workbenchInfo = await this.getWorkbenchInfoByHost(host);
+    if (workbenchInfo) {
+      return workbenchInfo;
+    }
+    // 最后兜底
+    return await this.getWorkbenchInfoByHost('*');
+  }
+
+  /**
+   * 获取当前请求的域名
+   * @returns
+   */
+  private getCurrentHost(): string {
+    const host = this.ctx.request.host;
+    if (!host) {
+      throw new CommonException('GET_CURRENT_HOST_ERROR', '获取当前域名失败');
+    }
+    return host;
+  }
+
+  public async isSupportCurrentWorkbench(workbench_code_array: string | string[]): Promise<boolean> {
+    // 本地调试模式
+    if (this.isEnableDebug() && this.isLocalEnv()) {
+      return true;
+    }
+
+    if (!workbench_code_array) {
+      throw new CommonException('IS_SUPPORT_CURRENT_WORKBENCH', '未配置支持的站点字段');
+    }
+
+    const workbench = await this.getCurrentHostWorkbenchInfo();
+    if (!workbench) {
+      throw new CommonException('WORKBENCH_IS_NOT_FOUND', '站点未找到');
+    }
+
+    const curWorkbenchCode = workbench.workbench_code;
+    return this.isMatchWorkbenchCode(workbench_code_array, curWorkbenchCode);
+  }
+
+  public async isSupportCurrentHostForForMiddleware(): Promise<string | boolean> {
+    // 本地调试模式
+    if (this.isEnableDebug() && this.isLocalEnv()) {
+      return true;
+    }
+
+    const host = this.getCurrentHost();
+
+    const workbenchInfo = await this.getCurrentHostWorkbenchInfo();
+
+    if (!workbenchInfo || workbenchInfo.status !== 1) {
+      this.logInfo(`域名不存在 host=${host}`);
+      const infos = {
+        host,
+        errorInfo: `ERR_FATCMS_REFUSED <br/> 域名配置不存在 host=${host}`,
+      };
+      this.ctx.status = 404;
+      return this.ctx.render('404_workbench', infos);
+    }
+    return true;
+  }
+}

package/src/service/anyapi/AnyApiSandboxService.ts

@@ -0,0 +1,121 @@
+import { Inject, Provide } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import * as vm from 'node:vm';
+import { LRUCache } from 'lru-cache';
+import { BaseService } from '../base/BaseService';
+import { CurdMixService } from '../curd/CurdMixService';
+import { ISysAnyApiEntity } from '../../models/SystemEntities';
+import axios from 'axios';
+import * as _ from 'lodash';
+import * as moment from 'moment';
+import * as nodemailer from 'nodemailer';
+
+const scriptCacheOptions = {
+  max: 500,
+  ttl: 1000 * 60 * 5,
+  allowStale: false,
+  updateAgeOnGet: true,
+  updateAgeOnHas: true,
+};
+
+const scriptCache = new LRUCache<string, vm.Script>(scriptCacheOptions);
+
+function getCompiledScript(anyApi: ISysAnyApiEntity, code: string): vm.Script {
+  const { id, func_code_md5 } = anyApi;
+  const cacheKey = id + '_' + func_code_md5;
+  const oldScript = scriptCache.get(cacheKey);
+  if (oldScript) {
+    return oldScript;
+  }
+  const script = new vm.Script(code);
+  scriptCache.set(cacheKey, script);
+  return script;
+}
+
+export interface IRunInSandboxParams {
+  body: any;
+  query: any;
+  headers: any;
+  params?: any;
+}
+
+@Provide()
+export class AnyApiSandboxService extends BaseService {
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  private curdMixService: CurdMixService;
+
+  public async runInSandbox(anyApi: ISysAnyApiEntity, allParams: IRunInSandboxParams) {
+    const { func_code, method } = anyApi;
+
+    return new Promise((resolve, reject) => {
+      const logger = this.getPrefixContextLogger(`[AnyApiSandboxService][method=${method}]`);
+      // 创建一个沙盒上下文
+      const proc = process;
+      const newContext = {
+        sandbox: {
+          allParams,
+          logger,
+          moment,
+          axios,
+          nodemailer,
+          _,
+          userSession: this.ctx.userSession,
+          ctx: this.ctx,
+          curdMixService: this.curdMixService,
+          redisService: this.redisService,
+          publicOSSService: this.getPublicOSSService(),
+          privateOSSService: this.getPrivateOSSService(),
+          returnSuccess: resolve,
+          returnError: reject,
+          processInfo: {
+            version: proc.version,
+            versions: proc.versions,
+            env: process.env,
+            argv: process.argv,
+            cwd: process.cwd(),
+          },
+        },
+        console: logger,
+        JSON: JSON,
+      };
+
+      const nextLine100 = new Array(10).fill('\n').join('');
+      const bindCode = this.toBindCodeString('httpController', newContext, 'sandbox');
+      const code = `
+      (async () => {
+        ${nextLine100}${func_code}; // 必须有一个 class HttpController { async handleRequest(params){} }
+        ${nextLine100}
+        try {
+          const httpController = new HttpController();
+          ${bindCode}
+          const res = await httpController.handleRequest(sandbox.allParams.params);
+          sandbox.returnSuccess(res);
+        } catch (e) {
+          sandbox.returnError(e)
+        }
+      })(); `;
+
+      try {
+        const script = getCompiledScript(anyApi, code);
+        script.runInNewContext(newContext, {
+          filename: 'method',
+          timeout: anyApi.timeout_ms || 1000 * 60 * 5,
+        });
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+
+  private toBindCodeString(toName: string, newContext: any, fromName: any): string {
+    const keys = Object.keys(newContext[fromName]);
+    return keys
+      .map(key => {
+        return `${toName}.${key} = ${fromName}.${key};\n`;
+      })
+      .join('');
+  }
+}

package/src/service/anyapi/AnyApiService.ts

@@ -0,0 +1,186 @@
+import { Inject, Provide } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
+import { SystemTables } from '@/models/SystemTables';
+import { LRUCache } from 'lru-cache';
+import { BizException } from '@/models/devops';
+import { CurdMixService } from '../curd/CurdMixService';
+import { ISysAnyApiEntity } from '@/models/SystemEntities';
+import { AnyApiSandboxService, IRunInSandboxParams } from './AnyApiSandboxService';
+import { parseJsonObject } from '@/libs/utils/functions';
+import * as _ from 'lodash';
+import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
+import { WorkbenchService } from '../WorkbenchService';
+import { validateByCfgString } from '@/libs/crud-pro/utils/ValidateUtils';
+import { API_BASE_TYPE, ApiBaseService } from '../base/ApiBaseService';
+import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
+
+const lruCache = new LRUCache<string, any>({
+  max: 500,
+  ttl: 1000 * 60,
+  ttlAutopurge: true,
+});
+
+@Provide()
+export class AnyApiService extends ApiBaseService {
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  private curdMixService: CurdMixService;
+
+  @Inject()
+  private anyApiSandboxService: AnyApiSandboxService;
+
+  @Inject()
+  protected workbenchService: WorkbenchService;
+
+  async executeAnyApiMethod(methodCode: string, headers: any, body: any, query: any) {
+    const anyApi = await this.getAnyApiMethod(methodCode);
+    if (!anyApi || anyApi.status !== 1) {
+      throw new BizException('接口不存在或已下线：' + methodCode);
+    }
+
+    const isSupport = await this.workbenchService.isSupportCurrentWorkbench(anyApi.workbench_code_array);
+    if (!isSupport) {
+      throw new BizException('此接口不支持在当前站点打开：' + methodCode);
+    }
+
+    await super.beforeCheckApiAccessibility(API_BASE_TYPE.PROXY_API, anyApi);
+
+    if (!anyApi.func_code) {
+      throw new BizException('没有配置代码：' + methodCode);
+    }
+
+    if (!this.checkFuncCode(anyApi.func_code)) {
+      throw new BizException('接口代码校验失败：不满足形式： class HttpController { async handleRequest(params){} }; ');
+    }
+
+    const allParams: IRunInSandboxParams = { headers, body, query };
+    allParams.params = this.toAnyApiParams(anyApi, allParams); // 组合参数
+
+    // 执行代码
+    const funcRes = await this.executeFunctionCode(anyApi, allParams);
+    return funcRes;
+  }
+
+  private async getAnyApiMethod(methodCode: string): Promise<ISysAnyApiEntity> {
+    // 开发环境，不使用缓存
+    if (this.isEnableDebug()) {
+      return this._getAnyApiMethod(methodCode);
+    }
+
+    // 线上环境可以使用缓存
+    let anyApi = lruCache.get(methodCode);
+    if (!anyApi) {
+      anyApi = await this._getAnyApiMethod(methodCode);
+      lruCache.set(methodCode, anyApi);
+    }
+    return anyApi;
+  }
+
+  private async _getAnyApiMethod(methodCode: string): Promise<ISysAnyApiEntity> {
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+
+    const res = await this.curdMixService.executeCrudByCfg(
+      { condition: { method: methodCode } },
+      {
+        sqlTable: SystemTables.sys_anyapi,
+        method: `get_sys_anyapi_${methodCode}`,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+        updateCfg: {},
+      }
+    );
+    const obj: ISysAnyApiEntity = res.getOneObj();
+    if (!obj) {
+      return null;
+    }
+    obj.parsedOthers = parseJsonObject(obj.others);
+    return obj;
+  }
+
+  /**
+   * 构造参数
+   * @param anyApi
+   * @param allParams
+   * @private
+   */
+  private toAnyApiParams(anyApi: ISysAnyApiEntity, allParams: IRunInSandboxParams): any {
+    if (!anyApi.req_params) {
+      return {};
+    }
+
+    const configs = anyApi.parsedOthers?.req_params || [];
+    const params = {};
+    for (let i = 0; i < configs.length; i++) {
+      const { name, fromType, fromKey, validate_required, validate_cfg_list, valueType, defaultValue } = configs[i];
+      const value = _.get(allParams, [fromType, fromKey], defaultValue);
+      if (validate_required && MixinUtils.isEmpty(value)) {
+        throw new BizException(`参数校验失败：${name} 不能为空`);
+      }
+
+      // 参数校验
+      if (Array.isArray(validate_cfg_list)) {
+        for (let j = 0; j < validate_cfg_list.length; j++) {
+          const validateCfg = validate_cfg_list[j];
+          validateByCfgString(validateCfg, value, name);
+        }
+      }
+
+      // 格式转换
+      params[name] = MixinUtils.parseValueByType(value, valueType);
+    }
+    return params;
+  }
+
+  /**
+   * 运行代码
+   * @param anyApiEntity
+   * @param allParams
+   * @private
+   */
+  private async executeFunctionCode(anyApiEntity: ISysAnyApiEntity, allParams: IRunInSandboxParams): Promise<any> {
+    return this.anyApiSandboxService.runInSandbox(anyApiEntity, allParams);
+  }
+
+  private checkFuncCode(func_code: string): boolean {
+    if (!func_code) {
+      return false;
+    }
+
+    const lineHasKey = (lineTrim: string, target: string): boolean => {
+      const words = lineTrim.split(/[\s{}();]/);
+      for (let i = 0; i < words.length; i++) {
+        const word = words[i];
+        if (word && word === target) {
+          return true;
+        }
+      }
+      return false;
+    };
+
+    let hasClass = false;
+    let hasMethod = false;
+    const lines = func_code.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line) {
+        const lineTrim = line.trim();
+        if (lineTrim) {
+          if (lineHasKey(lineTrim, 'class') && lineHasKey(lineTrim, 'HttpController')) {
+            hasClass = true;
+          }
+          if (lineHasKey(lineTrim, 'async') && lineHasKey(lineTrim, 'handleRequest')) {
+            hasMethod = true;
+          }
+          if (lineTrim.startsWith('handleRequest')) {
+            hasMethod = true;
+          }
+        }
+      }
+    }
+    return hasMethod && hasClass;
+  }
+}