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

package/src/controller/gateway/PublicApiController.ts

@@ -0,0 +1,140 @@
+import { Controller, Get, Inject, Post } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import * as _ from 'lodash';
+import { BaseApiController } from '../base/BaseApiController';
+import { SystemTables } from '@/models/SystemTables';
+import { EnumInfoService } from '@/service/EnumInfoService';
+import { CommonResult } from '@/libs/utils/common-dto';
+import { parseJsonObject } from '@/libs/utils/functions';
+import { WorkbenchService } from '@/service/WorkbenchService';
+import { SystemRoleCode } from '@/models/SystemPerm';
+import { KeysOfAuthType } from '@/libs/crud-pro/models/keys';
+
+/**
+ * 公开的API，无需鉴权，所有人可以直接访问
+ */
+@Controller('/ns/gw/api/publicApi')
+export class PublicApiController extends BaseApiController {
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  private enumInfoService: EnumInfoService;
+
+  @Inject()
+  private workbenchService: WorkbenchService;
+
+  /**
+   * 获取所有站点列表
+   */
+  @Get('/getAllWorkbenchInfoList')
+  async getAllWorkbenchInfoList(): Promise<CommonResult> {
+    const entities = await this.workbenchService.getAllWorkbenchInfoList(false);
+    const entities2 = entities.map(e => {
+      return {
+        workbench_domain: e.workbench_domain,
+        workbench_code: e.workbench_code,
+        workbench_desc: e.workbench_desc,
+        workbench_name: e.workbench_name,
+      };
+    });
+    return CommonResult.successRes(entities2);
+  }
+
+  /**
+   * 获取菜单信息
+   */
+  @Get('/getWorkbenchMenu')
+  async getWorkbenchMenu(): Promise<CommonResult> {
+    const query = this.ctx.query || {};
+    const workbenchMenuCode = query.workbenchMenuCode;
+    if (!workbenchMenuCode) {
+      return CommonResult.errorRes('param workbenchMenuCode is null');
+    }
+
+    const workbenchMenuCodeStr = '' + workbenchMenuCode;
+    const workbenchMenuCodeArray = workbenchMenuCodeStr.split(',');
+
+    const condition = {
+      menu_code: {
+        $in: workbenchMenuCodeArray,
+      },
+    };
+    
+    const rows = await this.sysDBUtil.getList({ condition }, SystemTables.sys_menus);
+
+    const map = {};
+    for (let i = 0; i < rows.length; i++) {
+      const rowElement = rows[i];
+      const menu_code = rowElement.menu_code;
+      const view_auth_config = rowElement.view_auth_config;
+      const view_auth_type = rowElement.view_auth_type;
+
+      const hasPermission = this.ctx.userSession.isAuthPass(view_auth_type, view_auth_config);
+
+      const menu_config_content = rowElement.menu_config_content;
+      delete rowElement.menu_config_content;
+      const menu_list = parseJsonObject(menu_config_content) || [];
+      map[menu_code] = { ...rowElement, menu_list, hasPermission };
+    }
+
+    // 特殊的devops菜单
+    map['devops'] = {
+      menu_list: [], // 这个特殊的菜单在前端写死。
+      hasPermission: this.ctx.userSession.isAuthPass(KeysOfAuthType.byRoleCode, [SystemRoleCode.DevOpsWriter, SystemRoleCode.DevOpsViewer, SystemRoleCode.SuperAdmin]),
+    };
+
+    return CommonResult.successRes(map);
+  }
+
+  /**
+   * 获取页面信息
+   */
+  @Post('/getNavPageInfo')
+  async getNavPageInfo(): Promise<CommonResult> {
+    const body = this.ctx.request.body as any;
+    const { workbenchCode, appCode, pathname } = body;
+    const resultData: any = {};
+    const getOne = async (condition: any, tablenName: string, key: string) => {
+      const values = Object.values(condition).filter(Boolean);
+      // 查询条件不能为空
+      if (values.length > 0) {
+        const oneData = await this.sysDBUtil.getOne({ condition }, tablenName);
+        if (oneData && oneData['app_schema']) {
+          oneData['app_schema'] = parseJsonObject(oneData['app_schema']);
+        }
+        resultData[key] = oneData;
+      }
+    };
+
+    await getOne({ app_code: appCode }, SystemTables.sys_app, 'appData');
+    await getOne({ page_path: pathname, workbench_code: workbenchCode }, SystemTables.sys_app_page, 'pageData');
+
+    return CommonResult.successRes(resultData);
+  }
+
+  /**
+   * 获取配置的枚举项信息： 都是无需鉴权的
+   */
+  @Post('/getEnumInfo')
+  async getEnumInfo(): Promise<CommonResult> {
+    const body = this.ctx.request.body as any;
+    const query = this.ctx.query || {};
+    let codeList = _.get(body, 'codeList');
+    const refreshCache = `${_.get(body, 'refreshCache')}` === 'true' || query.refreshCache === 'true';
+
+    if (query.codeList) {
+      //codeList=dict@@SexEnum,sysCfgEnum@@EntityStatusEnum
+      const codeListStr: string = query.codeList as string;
+      codeList = codeListStr.split(',').map(str => {
+        const ss = str.split('@@');
+        return {
+          type: ss[0],
+          code: ss[1],
+        };
+      });
+    }
+    const enumInfos = await this.enumInfoService.queryEnumInfo(codeList, refreshCache);
+    return CommonResult.successRes(enumInfos);
+  }
+}

package/src/controller/gateway/StaticController.ts

@@ -0,0 +1,296 @@
+import { All, Controller, Inject, Param } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { BaseApiController } from '../base/BaseApiController';
+import * as fs from 'fs/promises';
+import * as fs2 from 'fs';
+import * as path from 'path';
+import * as https from 'https';
+import { parseJsonObject } from '@/libs/utils/functions';
+import { ANONYMOUS_CONTEXT } from "@/schedule";
+
+interface HttpGetRes {
+  statusCode: number;
+  headers: any;
+  body: NodeJS.ReadableStream;
+}
+
+function getPathConfig(ossName: string) {
+  const remoteBaseUrlMap = {
+    cdnjsx: 'https://cdnjsx.oss-cn-shanghai.aliyuncs.com',
+    'i.alicdn.com': 'https://i.alicdn.com',
+    'img.alicdn.com': 'https://img.alicdn.com',
+    'at.alicdn.com': 'https://at.alicdn.com',
+  };
+  let remoteBaseUrl = remoteBaseUrlMap[ossName];
+  if (!remoteBaseUrl) {
+    console.error(`getPathConfig ossName: ${ossName} 未配置`);
+    remoteBaseUrl = `https://${ossName}`;
+  }
+  return {
+    remoteBaseUrl,
+  };
+}
+
+// 404列表缓存
+let notFoundList = new Set();
+let notFoundListIsInit = false;
+
+/**
+ * 静态文件代理功能
+ */
+@Controller('/ns/static')
+export class StaticController extends BaseApiController {
+  @Inject()
+  protected ctx: Context;
+
+  private getLocalPaths(): any {
+    const app = ANONYMOUS_CONTEXT.getApp();
+    const appDir = app.getAppDir();
+    const localDir = path.join(appDir, './public/static'); // 本地文件存储目录
+    const notFoundListFile = path.join(localDir, '__404__list.json'); // 404列表文件
+    return {
+      localDir,
+      notFoundListFile,
+    };
+  }
+
+  private async initNotFoundList() {
+    if (notFoundListIsInit) {
+      return;
+    }
+    notFoundListIsInit = true;
+
+    const { localDir, notFoundListFile } = this.getLocalPaths();
+    try {
+      // 确保本地存储目录存在
+      await fs.mkdir(localDir, { recursive: true });
+      const data = await fs.readFile(notFoundListFile, 'utf8');
+
+      notFoundList = new Set(JSON.parse(data));
+      console.log(`已加载${notFoundList.size}个404记录`);
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        console.error('读取404列表失败:', error);
+      }
+    }
+  }
+
+  private async responseLocalFile(localFilePath: string, localHeaderPath: string, relativePath: string): Promise<boolean> {
+    const headers = {
+      'Cache-Control': 'public, max-age=31536000',
+      Expires: new Date(Date.now() + 31536000000).toUTCString(),
+    };
+
+    try {
+      // 检查本地文件是否存在.头文件
+      const stats = await fs.stat(localHeaderPath);
+      if (stats.isFile()) {
+        const headerDataStr = await fs.readFile(localHeaderPath, 'utf8');
+        const headerData = parseJsonObject(headerDataStr);
+        if (headerData) {
+          headers['content-type'] = headerData['content-type'];
+          headers['content-length'] = headerData['content-length'];
+          headers['last-modified'] = headerData['last-modified'];
+          headers['etag'] = headerData['etag'];
+          headers['cache-control'] = headerData['cache-control'];
+          headers['accept-ranges'] = headerData['accept-ranges'];
+        }
+      }
+    } catch (error) {
+      this.logDebug('[StaticController]responseLocalFile', error);
+    }
+
+    try {
+      // 检查本地文件是否存在
+      const stats = await fs.stat(localFilePath);
+      if (stats.isFile()) {
+        if (!headers['content-type']) {
+          headers['content-type'] = this.getMimeType(localFilePath);
+        }
+
+        const stream = fs2.createReadStream(localFilePath);
+        stream.setMaxListeners(50);
+        // const oldOn = stream.on.bind(stream);
+        // stream.on = (...args)=>{
+        //     return oldOn(...args)
+        // }
+
+        this.logInfo(`[StaticController]返回本地文件: ${relativePath}`);
+        this.ctx.status = 200;
+        this.ctx.set(headers);
+
+        this.ctx.body = stream;
+        return true;
+      }
+    } catch (error) {
+      // 文件不存在，继续请求远程
+    }
+
+    return false;
+  }
+
+  @All('/:ossName/:relativePath+')
+  async proxyStaticFile(@Param('ossName') ossName: string, @Param('relativePath') relativePath: string) {
+    await this.initNotFoundList()
+    const { localDir } = this.getLocalPaths();
+    const PATH_CONFIG = getPathConfig(ossName);
+
+    // 构建本地路径和远程路径
+    const localFilePath = path.join(localDir, 'files', ossName, relativePath);
+    const localHeaderPath = path.join(localDir, 'headers', ossName, relativePath);
+    const remoteUrl = `${PATH_CONFIG.remoteBaseUrl}/${relativePath}`;
+
+    // 检查是否在404列表中
+    if (notFoundList.has(relativePath)) {
+      this.ctx.status = 404;
+      return this.ctx.render('500', { errorMsg: ' 远程文件不存在, 命中notFoundList' });
+    }
+
+    // 检查并返回本地文件
+    if (await this.responseLocalFile(localFilePath, localHeaderPath, relativePath)) {
+      return;
+    }
+
+    // 请求远程文件
+    this.logInfo(`[StaticController]请求远程文件: ${remoteUrl}`);
+
+    try {
+      const remoteRes = await this.httpsGet(remoteUrl);
+
+      // 处理远程响应状态码
+      if (remoteRes.statusCode === 200) {
+        // 写入本地文件
+        await this.writeResponseToFile(remoteRes, localFilePath, localHeaderPath);
+
+        // 检查并返回本地文件
+        if (await this.responseLocalFile(localFilePath, localHeaderPath, relativePath)) {
+          return;
+        }
+      } else if (remoteRes.statusCode === 404) {
+        // 记录404并返回
+        notFoundList.add(relativePath);
+        await this.saveNotFoundList();
+        this.logInfo(`[StaticController]远程文件不存在，已记录404: ${relativePath}`);
+        this.ctx.status = 404;
+        return this.ctx.render('500', { errorMsg: ' 远程文件不存在，已记录404' });
+      } else {
+        // 其他状态码
+        const msg = `[StaticController]远程服务器返回状态码: ${remoteRes.statusCode}`;
+        this.logInfo(msg);
+        this.ctx.status = 502;
+        return this.ctx.render('500', { errorMsg: msg });
+      }
+    } catch (err) {
+      const msg = `[StaticController]请求远程文件失败: ${err}`;
+      this.logError(msg);
+      this.ctx.status = 500;
+      return this.ctx.render('500', { errorMsg: msg });
+    }
+
+    this.ctx.status = 500;
+    return this.ctx.render('500', { errorMsg: '未知异常' });
+  }
+
+  // 保存404列表
+  async saveNotFoundList() {
+    const { notFoundListFile } = this.getLocalPaths();
+    try {
+      // 确保存储404列表的目录存在
+      const dir = path.dirname(notFoundListFile);
+      await fs.mkdir(dir, { recursive: true });
+
+      await fs.writeFile(notFoundListFile, JSON.stringify(Array.from(notFoundList), null), 'utf8');
+    } catch (error) {
+      this.logError('[StaticController]保存404列表失败:', error);
+    }
+  }
+
+  // 封装https请求为异步函数
+  async httpsGet(url: string): Promise<HttpGetRes> {
+    return new Promise<HttpGetRes>((resolve, reject) => {
+      https
+        .get(url, res => {
+          resolve({
+            statusCode: res.statusCode || 500,
+            headers: res.headers,
+            body: res,
+          });
+        })
+        .on('error', err => {
+          reject(err);
+        });
+    });
+  }
+
+  // 新增：将响应body写入文件的函数
+  async writeResponseToFile(httpsGetRes: HttpGetRes, localFilePath: string, localHeaderPath: string): Promise<void> {
+    // 创建本地目录（如果不存在）
+    const localFileDir = path.dirname(localFilePath);
+    await fs.mkdir(localFileDir, { recursive: true });
+
+    const localHeaderDir = path.dirname(localHeaderPath);
+    await fs.mkdir(localHeaderDir, { recursive: true });
+
+    try {
+      const { statusCode, body } = httpsGetRes;
+
+      // 检查HTTP状态码
+      if (statusCode >= 400) {
+        throw new Error(`HTTP请求失败，状态码: ${statusCode}`);
+      }
+
+      // 创建可写流
+      const fileStream = fs2.createWriteStream(localFilePath);
+
+      // 使用管道将响应流写入文件
+      await new Promise((resolve, reject) => {
+        body.pipe(fileStream);
+
+        body.on('error', err => {
+          reject(new Error(`读取响应流失败: ${err.message}`));
+        });
+
+        fileStream.on('finish', resolve);
+        fileStream.on('error', err => {
+          reject(new Error(`写入文件失败: ${err.message}`));
+        });
+      });
+
+      this.logInfo(`[StaticController]文件已成功写入1: ${localFilePath}`);
+
+      await fs.writeFile(localHeaderPath, JSON.stringify(httpsGetRes.headers), 'utf8');
+
+      this.logInfo(`[StaticController]文件已成功写入2: ${localHeaderPath}`);
+    } catch (err) {
+      // 发生错误时删除可能存在的不完整文件
+      if (fs2.existsSync(localFilePath)) {
+        fs2.unlinkSync(localFilePath);
+      }
+      throw new Error(`下载过程中发生错误: ${err.message}`);
+    }
+  }
+
+  // 根据文件扩展名获取MIME类型
+  getMimeType(filePath: string) {
+    const extname = path.extname(filePath).toLowerCase();
+    const mimeTypes = {
+      '.html': 'text/html',
+      '.js': 'text/javascript',
+      '.css': 'text/css',
+      '.json': 'application/json',
+      '.png': 'image/png',
+      '.jpg': 'image/jpg',
+      '.gif': 'image/gif',
+      '.svg': 'image/svg+xml',
+      '.woff': 'font/woff',
+      '.woff2': 'font/woff2',
+      '.ttf': 'font/ttf',
+      '.eot': 'application/vnd.ms-fontobject',
+      '.txt': 'text/plain',
+      '.pdf': 'application/pdf',
+      '.mp4': 'video/mp4',
+      '.ico': 'image/x-icon',
+    };
+    return mimeTypes[extname] || 'application/octet-stream';
+  }
+}

package/src/controller/helpers.controller.ts

@@ -0,0 +1,161 @@
+import { Inject, Controller, Get, Post, MidwayWebRouterService, Query } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import * as _ from 'lodash';
+import * as md5 from 'md5';
+import { CurdMixService } from '@/service/curd/CurdMixService';
+import { CommonException, Exceptions } from '@/libs/crud-pro/exceptions';
+import { createUniqueId } from '@/libs/utils/functions';
+import { privateAES } from '@/libs/utils/crypto-utils';
+import { CommonResult } from '@/libs/utils/common-dto';
+
+// http://127.0.0.1:7002/ns/api/helpers/getApiScript?prefix=/ns/api/manage
+// http://127.0.0.1:7002/ns/api/helpers/getApiScript
+// http://127.0.0.1:7002/ns/api/helpers/getApiEnv
+// http://127.0.0.1:7002/ns/api/helpers/cryptoAes128CBC?input=123
+
+@Controller('/ns/api/helpers')
+export class HelpersApi {
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  private midwayWebRouterService: MidwayWebRouterService;
+
+  @Inject()
+  protected curdMixService: CurdMixService;
+
+  @Get('/getApiEnv')
+  async getApiEnv() {
+    const host = this.ctx.req.headers.host;
+    const env = this.ctx.app.env;
+    const href = this.ctx.href;
+    const proc = process;
+    return {
+      env,
+      href,
+      host,
+      ctx: this.ctx,
+      processInfo: {
+        version: proc.version,
+        versions: proc.versions,
+        env: proc.env,
+        argv: proc.argv,
+        cwd: proc.cwd(),
+      },
+    };
+  }
+
+  @Get('/getApiScript')
+  async getApiScript(@Query() queryData) {
+    this.checkLocalPermissionEnv();
+
+    const prefix = queryData.prefix || '/api/';
+
+    const routers0 = await this.midwayWebRouterService.getFlattenRouterTable();
+
+    const routers = routers0.filter(r => {
+      return r.fullUrl.startsWith(prefix);
+    });
+
+    const group = _.groupBy(routers, r => {
+      return r.controllerId;
+    });
+
+    const groupKeys = Object.keys(group).sort();
+
+    const controllers = groupKeys.map(controllerId => {
+      const routers2 = group[controllerId];
+
+      const routers3 = routers2.sort((a, b) => {
+        const f1 = '' + a.fullUrl;
+        const f2 = '' + b.fullUrl;
+        return f1.localeCompare(f2);
+      });
+
+      const methods = routers3
+        .map(r => {
+          let method = r.requestMethod.toUpperCase();
+          if (method === 'ALL') {
+            method = 'POST';
+          }
+          return `  ${r.method}: createApiRequest('${r.fullUrl}', '${method}'),`;
+        })
+        .filter(r => {
+          return !!r;
+        })
+        .join('\n');
+      return `const ${controllerId} = {\n${methods} \n}`;
+    });
+
+    const href = this.ctx.href;
+    const infos = `/* 代码生成路径为：${href} */ \n`;
+    const imports = 'import {createApiRequest} from "./utils.js";\n';
+    const exports = groupKeys.join(',\n  ');
+    return infos + imports + controllers.join('\n\n') + `\n\nexport {\n  ${exports} \n}`;
+  }
+
+  @Post('/testExecuteCrudByCfg')
+  async testExecuteCrudByCfg() {
+    this.checkLocalPermissionEnv();
+
+    const { reqJson, cfgModel } = this.ctx.request.body as any;
+    return await this.curdMixService.executeCrudByCfg(reqJson, cfgModel);
+  }
+
+  /**
+   * 工具函数: 由明文生成数据库中的存储的密码
+   * @param queryData
+   */
+  @Get('/generateDatabasePassword')
+  async generateDatabasePassword(@Query() queryData) {
+    const loginName = queryData.loginName;
+    const pw0 = queryData.pw0;
+
+    // 这个函数的逻辑，在生产环境中，在前端执行
+    const toUnsaltedPwd = (pw0: string, loginName: string): string => {
+      return md5(md5(pw0) + '_' + loginName);
+    };
+
+    const unsaltedPwd = toUnsaltedPwd(pw0, loginName);
+    const pwd_salt = createUniqueId();
+    const pwd_md5 = md5(unsaltedPwd + pwd_salt);
+
+    return {
+      pwd_salt,
+      pwd_md5,
+      login_name: loginName,
+    };
+  }
+
+  /**
+   * 工具函数: 使用Aes128CBC加密
+   * @param queryData
+   */
+  @Get('/cryptoAes128CBC')
+  async cryptoAes128CBC(@Query() queryData) {
+    const input = queryData.input;
+    if (!input) {
+      return CommonResult.errorRes('input 参数不能为空');
+    }
+    const encrypted = await privateAES.time_encrypt_utf8_base64(input);
+    const decrypted = await privateAES.time_decrypt_base64_utf8(encrypted);
+    return CommonResult.successRes({
+      input,
+      encrypted,
+      decrypted,
+      isEqual: input === decrypted,
+    });
+  }
+
+  private checkLocalPermissionEnv() {
+    const isLocalEnv = (): boolean => {
+      const env = this.ctx.app.env;
+      const host = this.ctx.req.headers.host;
+      return env === 'local' && (host.startsWith('127.0.0.1') || host.startsWith('localhost:') || host === 'localhost');
+    };
+
+    if (!isLocalEnv()) {
+      throw new CommonException(Exceptions.NO_AUTH, '此测试函数，仅只有本地环境可以调用');
+    }
+  }
+}

package/src/controller/home.controller.ts

@@ -0,0 +1,66 @@
+import { Controller, Get, Inject } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { BaseApiController } from './base/BaseApiController';
+import { WorkbenchService } from '@/service/WorkbenchService';
+import { createRenderUtils } from '@/libs/utils/render-utils';
+import { privateAES } from '@/libs/utils/crypto-utils';
+
+@Controller('/')
+export class HomeController extends BaseApiController {
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  protected workbenchService: WorkbenchService;
+
+  @Get('/*')
+  async home(): Promise<string> {
+    const host = this.ctx.request.host;
+    const hostname = this.ctx.request.hostname;
+
+    const workbenchInfo = await this.workbenchService.getCurrentHostWorkbenchInfo();
+
+    if (!workbenchInfo || workbenchInfo.status !== 1) {
+      this.logInfo(`域名不存在：hostname = ${hostname}, host=${host}`);
+      const infos = {
+        host,
+        errorInfo: `ERR_FATCMS_REFUSED <br/> 域名配置不存在：hostname = ${hostname}, host=${host}`,
+      };
+      this.ctx.status = 404;
+      return this.ctx.render('404_workbench', infos);
+    }
+
+    const html_content = workbenchInfo.html_content || '未配置HTML模版';
+
+    const userInfo = this.getUserSessionInfo();
+
+    const fatcmscsrftoken = await privateAES.time_encrypt_utf8_base64('' + Date.now());
+
+    const utils = createRenderUtils({
+      ctx: this.ctx,
+      userInfo,
+      workbenchInfo,
+      package_assets: workbenchInfo.package_assets,
+      fatcmscsrftoken,
+    });
+
+    const query = this.ctx.query || {};
+
+    return this.ctx.renderString(html_content, { workbenchInfo, userInfo, utils, query }, { viewEngine: 'ejs' });
+  }
+
+  @Get('/robots.txt')
+  async robots(): Promise<string> {
+    return `User-agent: * \nDisallow: /ns/api/manage/`;
+  }
+
+  // @Get('/favicon.ico')
+  // async favicon() {
+  //   debugger
+  //   const p = path.join(this.app.getBaseDir(), './views/favicon.ico');
+  //   const buffer = fs.readFileSync(p);
+  //   const ctx = this.ctx;
+  //   ctx.set('Content-Type', 'image/jpeg');
+  //   ctx.body = buffer;
+  // }
+}