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

package/src/libs/crud-pro/utils/sqlConvert/convertPgType.ts

@@ -0,0 +1,127 @@
+//
+// // 定义 PostgreSQL 数据类型 OID 映射
+// const PG_TYPE_OIDS = {
+//   INT2: 21,    // smallint
+//   INT4: 23,    // integer
+//   INT8: 20,    // bigint
+//   FLOAT4: 700, // real
+//   FLOAT8: 701, // double precision
+//   NUMERIC: 1700, // numeric
+//   MONEY: 790,   // money
+//   BOOL: 16,     // boolean
+//   DATE: 1082,   // date
+//   TIMESTAMP: 1114, // timestamp without time zone
+//   TIMESTAMPTZ: 1184, // timestamp with time zone
+//   JSON: 114,    // json
+//   JSONB: 3802,  // jsonb
+// };
+//
+//
+//
+// /**
+//  * 将 PostgreSQL 数据类型转换为 JavaScript 类型
+//  * @param {any} value - 原始值
+//  * @param {number} oid - 数据类型 OID
+//  * @returns {any} 转换后的值
+//  */
+// function convertPgType(value: any, oid: any) {
+//   // 如果值为 null，直接返回
+//   if (value === null) {
+//     return null;
+//   }
+//
+//   const typeOfValue = typeof value;
+//   if (typeOfValue === 'undefined') {
+//     return null;
+//   }
+//   if (typeOfValue === 'number' || typeOfValue === "boolean" || typeOfValue === "object") {
+//     return value;
+//   }
+//   if (typeOfValue === 'bigint') {
+//     return value.toString()
+//   }
+//
+//   switch (oid) {
+//     // 整数类型（全部转为 Number）
+//     case PG_TYPE_OIDS.INT2: // smallint
+//     case PG_TYPE_OIDS.INT4: // integer
+//       return Number(value);
+//     case PG_TYPE_OIDS.INT8: // bigint
+//       return value;
+//
+//     // 浮点类型
+//     case PG_TYPE_OIDS.FLOAT4: // real
+//     case PG_TYPE_OIDS.FLOAT8: // double precision
+//     case PG_TYPE_OIDS.NUMERIC: // numeric
+//     case PG_TYPE_OIDS.MONEY: // money
+//       return Number(value);
+//
+//     // 布尔类型
+//     case PG_TYPE_OIDS.BOOL:
+//       if (typeof value === 'boolean') {
+//         return value;
+//       }
+//       return value === 't' || value === 'true' || value === true;
+//
+//     // 日期/时间类型
+//     case PG_TYPE_OIDS.DATE:
+//       return new Date(value).toISOString().split('T')[0];
+//
+//     case PG_TYPE_OIDS.TIMESTAMP:
+//     case PG_TYPE_OIDS.TIMESTAMPTZ:
+//       return new Date(value).toISOString();
+//
+//     // JSON 类型
+//     case PG_TYPE_OIDS.JSON:
+//     case PG_TYPE_OIDS.JSONB:
+//       // try {
+//       //   return JSON.parse(value);
+//       // } catch (e) {
+//       //   return value; // 解析失败时返回原始值
+//       // }
+//
+//     // 默认不转换
+//     default:
+//       return value;
+//   }
+// }
+//
+//
+// /**
+//  * 获取并转换PG查询结果的数据类型
+//  * @param result
+//  */
+// function pickAndConvertPgRows(result: any): any[] {
+//   if (!result || !Array.isArray(result.rows)) {
+//     return [];
+//   }
+//
+//   console.log('',convertPgType)
+//   try {
+//     // 获取字段类型 OID
+//     const fieldTypes = result.fields.map((field: any) => field.dataTypeID);
+//
+//     // 转换每一行的数据类型
+//     return result.rows.map((row:any) => {
+//       const convertedRow = {};
+//       Object.keys(row).forEach((key, index) => {
+//         const value = row[key];
+//         const oid = fieldTypes[index];
+//         convertedRow[key] = convertPgType(value, oid);
+//       });
+//       return convertedRow;
+//     });
+//   } catch (e) {
+//     console.error('pickAndConvertPgRows', e);
+//   }
+//   return [];
+// }
+
+function pickAndConvertPgRows(result: any): any[] {
+  if (!result || !Array.isArray(result.rows)) {
+    return [];
+  }
+  return result.rows;
+}
+
+export { pickAndConvertPgRows };

package/src/libs/global-config/global-config.ts

@@ -0,0 +1,108 @@
+import { IRequestCfgModel, IRequestModel } from '../crud-pro/interfaces';
+import { ExecuteContext } from '../crud-pro/models/ExecuteContext';
+import { SqlDbType } from '../crud-pro/models/keys';
+import { Context } from '@midwayjs/koa';
+
+interface IGlobalStaticConfig {
+  /**
+   * CrudStd: 业务系统自定义的修改：查询前的查询条件：cfgModel
+   * @param reqJson
+   * @param cfgModel
+   * @param appInfo
+   * @param ctx
+   */
+  bizUpdateCfgModelForCrudStd(reqJson: IRequestModel, cfgModel: IRequestCfgModel, appInfo: any, ctx: Context): Promise<any>;
+
+  /**
+   * CrudStd:  业务系统自定义的修改：查询后的返回值。
+   * @param reqJson
+   * @param cfgModel
+   * @param appInfo
+   * @param ctx
+   */
+  bizUpdateExecuteContextForCrudStd(reqJson: IRequestModel, cfgModel: IRequestCfgModel, appInfo: any, ctx: Context, executeContext: ExecuteContext): Promise<any>;
+
+  /**
+   * CrudMtd: 业务系统自定义的修改cfgModel
+   * @param reqJson
+   * @param cfgModel
+   * @param methodInfo
+   * @param ctx
+   */
+  bizUpdateCfgModelForCrudMtd(reqJson: any, cfgModel: any, methodInfo: any, ctx: any): Promise<any>;
+
+  /**
+   * CrudMtd: 业务系统自定义的修改ExecuteContext
+   * @param reqJson
+   * @param cfgModel
+   * @param methodInfo
+   * @param ctx
+   * @param executeContext
+   */
+  bizUpdateExecuteContextForCrudMtd(reqJson: any, cfgModel: any, methodInfo: any, ctx: any, executeContext: ExecuteContext): Promise<any>;
+
+  /**
+   * CrudPro: 业务系统自定义的修改cfgModel。这是最底层的！！全局的！！全局的！！全局的！！！
+   * @param reqJson
+   * @param cfgModel
+   */
+  bizUpdateCfgModelForCrudPro(reqJson: any, cfgModel: any): Promise<any>;
+
+  /**
+   * 生成用户的账号ID，业务系统可以生成类似工号的ID
+   * @param userSubmitData
+   */
+  generateUserAccountId(userSubmitData: any): Promise<string>;
+
+  /**
+   * 将业务系统表中的userId映射为fatcms的UserAccountId
+   * @param bizTableUserId 业余系统表中的UserId
+   */
+  toFatcmsUserAccountId(bizTableUserId: any): string;
+
+  SystemDbName: string;
+  SystemDbType: SqlDbType;
+
+  /**
+   * Excel导出时，每页查询的最大数量
+   */
+  maxPageSizeOfExportExcel: number;
+}
+
+const noop = () => {
+  return Promise.resolve();
+};
+
+class GlobalStaticConfig {
+  private configObject: IGlobalStaticConfig;
+  constructor() {
+    this.configObject = {
+      bizUpdateCfgModelForCrudStd: noop,
+      bizUpdateExecuteContextForCrudStd: noop,
+      bizUpdateCfgModelForCrudMtd: noop,
+      bizUpdateExecuteContextForCrudMtd: noop,
+      bizUpdateCfgModelForCrudPro: noop,
+      generateUserAccountId: null,
+      toFatcmsUserAccountId: (bizTableUserId: any) => {
+        return bizTableUserId;
+      },
+      SystemDbName: 'fatcms',
+      SystemDbType: SqlDbType.mysql,
+      maxPageSizeOfExportExcel: 1000,
+    };
+  }
+  public getConfig(): IGlobalStaticConfig {
+    return this.configObject as IGlobalStaticConfig;
+  }
+
+  public setConfig(configObject: any) {
+    if (!configObject || typeof configObject !== 'object') {
+      throw new Error('参数configObject不能为空');
+    }
+    Object.assign(this.configObject, configObject);
+  }
+}
+
+const GLOBAL_STATIC_CONFIG = new GlobalStaticConfig();
+
+export { GLOBAL_STATIC_CONFIG };

package/src/libs/utils/base64.ts

@@ -0,0 +1,40 @@
+function toBase64(obj: any): string {
+  const jsonString = JSON.stringify(obj);
+  return Buffer.from(jsonString, 'utf8').toString('base64');
+}
+
+/**
+ * 将经 toBase64 函数序列化的 Base64 字符串还原为 JS 对象
+ * @param base64Str - 经 toBase64 处理后的 Base64 字符串
+ * @returns 还原后的 JS 对象
+ * @throws 当 Base64 格式无效或 JSON 解析失败时抛出含具体原因的错误
+ */
+function fromBase64(base64Str: string): any {
+  // 校验输入是否为字符串
+  if (typeof base64Str !== 'string') {
+    throw new Error('input must Base64 string');
+  }
+
+  try {
+    // 1. 反向步骤1：将 Base64 字符串解码为 UTF-8 格式的 JSON 字符串
+    // 对应原函数的 Buffer.from(jsonString, 'utf8') 反向操作
+    const jsonString = Buffer.from(base64Str, 'base64').toString('utf8');
+
+    // 2. 反向步骤2：将 JSON 字符串解析为 JS 对象
+    // 对应原函数的 JSON.stringify(obj) 反向操作
+    const restoredObj = JSON.parse(jsonString);
+
+    return restoredObj;
+  } catch (error) {
+    // 分类处理不同错误类型，提供明确提示
+    if (error instanceof TypeError && error.message.includes('invalid base64')) {
+      throw new Error('还原失败：输入不是有效的 Base64 字符串');
+    } else if (error instanceof SyntaxError && error.message.includes('JSON')) {
+      throw new Error('还原失败：解码后的内容不是有效的 JSON 格式');
+    } else {
+      throw new Error(`还原失败：未知错误 - ${(error as Error).message}`);
+    }
+  }
+}
+
+export { toBase64, fromBase64 };

package/src/libs/utils/common-dto.ts

@@ -0,0 +1,52 @@
+export interface ICommonResult {
+  success: boolean;
+  data?: any;
+  message?: string;
+  code?: string;
+  debugInfo?: any;
+}
+
+export class CommonResult implements ICommonResult {
+  code: string;
+  data: any;
+  message: string;
+  success: boolean;
+  debugInfo: any;
+
+  public static successNotNull(data?: any): CommonResult {
+    const res = new CommonResult();
+    if (data) {
+      res.success = true;
+      res.data = data;
+    } else {
+      res.success = false;
+      res.message = '对象找不到';
+    }
+    return res;
+  }
+
+  public static successRes(data?: any): CommonResult {
+    const res = new CommonResult();
+    res.success = true;
+    res.data = data;
+    return res;
+  }
+
+  public static successMsg(message: string, data?: any): CommonResult {
+    const res = new CommonResult();
+    res.success = true;
+    res.message = message;
+    res.data = data;
+    return res;
+  }
+
+  public static errorRes(message: string, errorCode = '', debugInfo: any = null): CommonResult {
+    const res = new CommonResult();
+    res.success = false;
+    res.data = null;
+    res.message = message;
+    res.code = errorCode;
+    res.debugInfo = debugInfo;
+    return res;
+  }
+}

package/src/libs/utils/crypto-utils.ts

@@ -0,0 +1,50 @@
+import * as crypto from 'crypto';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as md5 from 'md5';
+import { Aes128CBC } from 'aes-128-cbc';
+
+function hashUtf8Hex(data: string): string {
+  const hash = crypto.createHash('sha256');
+  const chunkSize = 1024; // 每次处理 1MB 数据
+  for (let i = 0; i < data.length; i += chunkSize) {
+    const chunk = data.slice(i, i + chunkSize);
+    const inputBuffer = Buffer.from(chunk, 'utf8');
+    hash.update(inputBuffer);
+  }
+  return hash.digest('hex');
+}
+
+function readSeed1() {
+  // 这个文件肯定存在
+  const t = path.join(__dirname, '../../config/seed/aeskey.txt');
+  return fs.readFileSync(t, 'utf-8');
+}
+
+function readSeed2(): string {
+  const filePath = path.join(__dirname, '../../../config/seed/aeskey.txt');
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  return fs.readFileSync(filePath, 'utf-8');
+}
+
+function createAes128BySeedContent(seedContent: string) {
+  const hash1 = hashUtf8Hex(seedContent.trim());
+  const key = md5(hash1);
+  const iv = md5(key + hash1);
+  return new Aes128CBC(key, iv);
+}
+
+function createAes128BySeedFile() {
+  const seed2 = readSeed2();
+  if (seed2) {
+    return createAes128BySeedContent(seed2);
+  }
+  const seed1 = readSeed1();
+  return createAes128BySeedContent(seed1);
+}
+
+const privateAES = createAes128BySeedFile();
+
+export { privateAES };

package/src/libs/utils/errorToString.ts

@@ -0,0 +1,61 @@
+function errorToString(error: any): string {
+  // 处理非错误对象的情况
+  if (typeof error === 'undefined') {
+    return 'Error: undefined was thrown';
+  }
+
+  if (error === null) {
+    return 'Error: null was thrown';
+  }
+
+  // 处理原始值类型
+  const primitiveTypes = ['string', 'number', 'boolean', 'symbol'];
+  if (primitiveTypes.includes(typeof error)) {
+    return `Error: A primitive value was thrown\nValue: ${String(error)}`;
+  }
+
+  // 处理 Error 对象
+  if (error instanceof Error) {
+    const errorDetails = [];
+    errorDetails.push(`Error: ${error.name || 'Error'}`);
+    errorDetails.push(`Message: ${error.message || 'No error message'}`);
+
+    if (error.stack) {
+      errorDetails.push('Stack Trace:');
+      errorDetails.push(error.stack);
+    }
+
+    const extraProperties = ['code', 'fileName', 'lineNumber', 'columnNumber'];
+    extraProperties.forEach(prop => {
+      if (error[prop] !== undefined) {
+        errorDetails.push(`${prop}: ${error[prop]}`);
+      }
+    });
+
+    const customProps = Object.keys(error).filter(key => !['name', 'message', 'stack', ...extraProperties].includes(key));
+
+    if (customProps.length > 0) {
+      errorDetails.push('Custom Properties:');
+      customProps.forEach(prop => {
+        try {
+          const value = JSON.stringify(error[prop], null, 2) || String(error[prop]);
+          errorDetails.push(`  ${prop}: ${value}`);
+        } catch (e) {
+          errorDetails.push(`  ${prop}: [Object cannot be serialized]`);
+        }
+      });
+    }
+
+    return errorDetails.join('\n');
+  }
+
+  // 处理普通对象
+  try {
+    const objectDetails = JSON.stringify(error, null, 2);
+    return `Error: A plain object was thrown\nObject: ${objectDetails}`;
+  } catch (e) {
+    return `Error: An object was thrown but could not be serialized\nType: ${error.constructor?.name || 'Unknown'}`;
+  }
+}
+
+export { errorToString };

package/src/libs/utils/fatcms-request.ts

@@ -0,0 +1,103 @@
+import { Context } from '@midwayjs/koa';
+import * as _ from 'lodash';
+import { privateAES } from './crypto-utils';
+import { CommonException } from '../crud-pro/exceptions';
+
+function isEnableByHeaderKey(ctx: Context, configName: string) {
+  const fatcmsDebug = ctx.app.getConfig(configName);
+  const headerKey = _.get(fatcmsDebug, 'headerKey');
+  const headerSecret = _.get(fatcmsDebug, 'headerSecret');
+  if (!headerSecret || !headerKey) {
+    return false;
+  }
+  const headers = _.get(ctx, 'request.headers') || {};
+  return headers[headerKey] === headerSecret;
+}
+
+/**
+ * 是否开启调试能力
+ * @param ctx
+ */
+export function isEnableDebug(ctx: Context): boolean {
+  return isEnableByHeaderKey(ctx, 'fatcmsDebug');
+}
+
+/**
+ * 是否开启SA账号。只有账号密码没有用，必须通过ModHeader插件设置如下字段
+ * @param ctx
+ */
+export function isEnableSuperAdmin(ctx: Context): boolean {
+  return isEnableByHeaderKey(ctx, 'fatcmsSAEnable');
+}
+
+export function isLocalEnv(ctx: Context): boolean {
+  // 系统内部调用。如定时任务，没有request对象。
+  if (!ctx.request) {
+    return true;
+  }
+  const host = ctx.request.host;
+  return host.startsWith('127.0.0.1') || host.startsWith('localhost:');
+}
+
+/**
+ * 获取调试时专用的站点code
+ * @param ctx
+ */
+export function getDebugWorkbenchCode(ctx: Context) {
+  const headers = _.get(ctx, 'request.headers') || {};
+  return headers['fatcmsworkbench'];
+}
+
+/**
+ * 代理转发服务专用
+ * @param ctx
+ */
+export function getDebugProxyTarget(ctx: Context): string {
+  const headers = _.get(ctx, 'request.headers') || {};
+  return headers['fatcmsdebugproxytarget'];
+}
+
+export function getCsrfToken(ctx: Context): string {
+  const headers = _.get(ctx, 'request.headers') || {};
+  return headers['fatcmscsrftoken'];
+}
+
+/**
+ * 扩展的源码应用：本地开发调试时加载本地的js脚本
+ * @param ctx
+ */
+export function getExtLocalLoaderPort(ctx: Context): string {
+  const headers = _.get(ctx, 'request.headers') || {};
+  return headers['fatcmsextlocalloaderport'];
+}
+
+export async function isCsrfTokenValid(ctx: Context): Promise<boolean> {
+  // 本地开发，不需要校验
+  if (isLocalEnv(ctx) || isEnableDebug(ctx)) {
+    return true;
+  }
+
+  const fatcmscsrftoken = getCsrfToken(ctx);
+  if (!fatcmscsrftoken) {
+    return false;
+  }
+  try {
+    const depryptToken = await privateAES.time_decrypt_base64_utf8(fatcmscsrftoken);
+    if (depryptToken) {
+      const num = Number(depryptToken);
+      if (num && num + 6 * 3600 * 1000 > Date.now()) {
+        return true;
+      }
+    }
+  } catch (e) {
+    console.info('isCsrfTokenValid验证失败');
+  }
+  return false;
+}
+
+export async function assertCsrfToken(ctx: Context) {
+  const isOK = await isCsrfTokenValid(ctx);
+  if (!isOK) {
+    throw new CommonException('ASSERT_CSRF_TOKEN_ERROR', 'CSRF_TOKEN 验证失败');
+  }
+}

package/src/libs/utils/functions.ts

@@ -0,0 +1,78 @@
+import * as md5 from 'md5';
+import * as moment from 'moment';
+
+let createUniqueIdIndex = 0;
+function createUniqueId(): string {
+  createUniqueIdIndex++;
+  const p1 = md5(Date.now() + '' + Math.random() + '_' + createUniqueIdIndex);
+  const p2 = Date.now().toString(32);
+  return p1 + p2;
+}
+
+function parseJsonObject(str: any): any {
+  const typeofStr = typeof str;
+
+  if (str === null || typeofStr === 'undefined') {
+    return null;
+  }
+
+  if (typeofStr === 'object') {
+    return str;
+  }
+
+  if (typeofStr === 'string') {
+    str = str.trim();
+    if (str.startsWith('{') || str.startsWith('[')) {
+      try {
+        return JSON.parse(str);
+      } catch (e) {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+
+function trimStringArray(obj: any[]): string[] {
+  return obj
+    .map(s => {
+      if (typeof s === 'string') {
+        return s.trim();
+      }
+      return null;
+    })
+    .filter(Boolean);
+}
+
+function parseStringTrimArray(obj: any, separator = ','): string[] {
+  if (Array.isArray(obj)) {
+    return trimStringArray(obj);
+  }
+
+  if (typeof obj === 'string') {
+    const str = obj.trim();
+    if (str.length > 0) {
+      // 可能是一个JSON数组
+      if (str.startsWith('[') && str.endsWith(']')) {
+        const arr = parseJsonObject(str);
+        return trimStringArray(arr);
+      }
+
+      // 使用分隔符分隔
+      if (str.includes(separator)) {
+        const arr = str.split(separator);
+        return trimStringArray(arr);
+      }
+
+      return [str];
+    }
+  }
+
+  return null;
+}
+
+function getCurrentFullMoment(): string {
+  return moment(Date.now()).format('YYYY-MM-DD HH:mm:ss.SSS');
+}
+
+export { createUniqueId, parseJsonObject, parseStringTrimArray, getCurrentFullMoment };

package/src/libs/utils/ordernum-utils.ts

@@ -0,0 +1,14 @@
+import * as moment from 'moment';
+
+function generateOrderNumber(prefix = 'NO'): string {
+  // 获取当前时间并格式化为YYYYMMDDHHmmss
+  const timestamp = moment().format('YYYYMMDDHHmmss');
+
+  // 生成6位随机数字
+  const randomDigits = Math.floor(100000 + Math.random() * 900000);
+
+  // 组合订单号
+  return prefix + timestamp + randomDigits;
+}
+
+export { generateOrderNumber };

package/src/libs/utils/parseConfig.ts

@@ -0,0 +1,54 @@
+import * as _ from 'lodash';
+import { parseJsonObject } from './functions';
+
+interface IEnumInfo {
+  label: string;
+  value: string | number;
+  children?: IEnumInfo[];
+}
+
+function parseTreeTableToIEnumInfo(dataSource: any[]): IEnumInfo[] {
+  if (!dataSource || !Array.isArray(dataSource)) {
+    return undefined;
+  }
+  return dataSource.map((item: any) => {
+    const { key, nodeName, value, label } = item;
+    const children = parseTreeTableToIEnumInfo(item.children);
+    const enumInfo: IEnumInfo = {
+      label: label || nodeName,
+      value: value || key,
+    };
+    if (children) {
+      enumInfo.children = children;
+    }
+    return enumInfo;
+  });
+}
+
+function parseConfigContentToEnumInfo(configEntity: any): IEnumInfo[] {
+  const { config_content, config_type } = configEntity;
+
+  const configObj = parseJsonObject(config_content);
+  if (!configObj) {
+    return null;
+  }
+
+  if (config_type === 'treeTable') {
+    const dataSource = _.get(configObj, 'data.dataSource');
+    if (Array.isArray(dataSource)) {
+      return parseTreeTableToIEnumInfo(dataSource);
+    }
+    return [];
+  }
+
+  if (configObj.data && Array.isArray(configObj.data)) {
+    return configObj.data;
+  }
+
+  if (Array.isArray(configObj)) {
+    return configObj;
+  }
+  return [];
+}
+
+export { parseConfigContentToEnumInfo, IEnumInfo };