midway-fatcms 0.0.1-beta.18 → 0.0.1-beta.19

package/src/controller/gateway/StaticController.ts

@@ -1,328 +1,298 @@
 import { All, Controller, Inject, Param } from '@midwayjs/core';
 import { Context } from '@midwayjs/koa';
 import { BaseApiController } from '../base/BaseApiController';
-import * as _ from 'lodash';
 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';
 
-
 interface HttpGetRes {
-    statusCode: number;
-    headers: any;
-    body: NodeJS.ReadableStream
+  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,
-    }
+  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;
+  @Inject()
+  protected ctx: Context;
+
+  constructor() {
+    super();
+    this.initNotFoundList();
+  }
+
+  private getLocalPaths(): any {
+    const appDir = this.app.getAppDir();
+    const localDir = path.join(appDir, './public/static'); // 本地文件存储目录
+    const notFoundListFile = path.join(localDir, '__404__list.json'); // 404列表文件
+    return {
+      localDir,
+      notFoundListFile,
+    };
+  }
 
-    constructor() {
-        super();
-        this.initNotFoundList();
+  private async initNotFoundList() {
+    if (notFoundListIsInit) {
+      return;
     }
-
-
-    private getLocalPaths(): any {
-        const appDir = this.app.getAppDir();
-        const localDir = path.join(appDir, './public/static'); // 本地文件存储目录
-        const notFoundListFile = path.join(localDir, '__404__list.json') // 404列表文件
-        return {
-            localDir,
-            notFoundListFile
-        }
+    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(),
+    };
 
-    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);
-            }
+    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) {
+      console.debug('[StaticController]responseLocalFile', 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) {
+    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)
+        // }
+
+        console.log(`返回本地文件: ${relativePath}`);
+        this.ctx.status = 200;
+        this.ctx.set(headers);
+
+        this.ctx.body = stream;
+        return true;
+      }
+    } catch (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)
-                // }
-
-                console.log(`返回本地文件: ${relativePath}`);
-                this.ctx.status = 200;
-                this.ctx.set(headers);
-
+    return false;
+  }
 
+  @All('/:ossName/:relativePath+')
+  async proxyStaticFile(@Param('ossName') ossName: string, @Param('relativePath') relativePath: string) {
+    const { localDir } = this.getLocalPaths();
+    const PATH_CONFIG = getPathConfig(ossName);
 
-                this.ctx.body = stream;
-                return true;
-            }
-        } catch (error) {
-            // 文件不存在，继续请求远程
-        }
+    // 构建本地路径和远程路径
+    const localFilePath = path.join(localDir, 'files', ossName, relativePath);
+    const localHeaderPath = path.join(localDir, 'headers', ossName, relativePath);
+    const remoteUrl = `${PATH_CONFIG.remoteBaseUrl}/${relativePath}`;
 
-        return false;
+    // 检查是否在404列表中
+    if (notFoundList.has(relativePath)) {
+      this.ctx.status = 404;
+      return this.ctx.render('500', { errorMsg: ' 远程文件不存在, 命中notFoundList' });
     }
 
-    @All('/:ossName/:relativePath+')
-    async proxyStaticFile(@Param('ossName') ossName: string, @Param('relativePath') relativePath: string) {
-
-        const { localDir } = this.getLocalPaths();
-        const PATH_CONFIG = getPathConfig(ossName);
-
+    // 检查并返回本地文件
+    if (await this.responseLocalFile(localFilePath, localHeaderPath, relativePath)) {
+      return;
+    }
 
-        // 构建本地路径和远程路径
-        const localFilePath = path.join(localDir, ossName, "files", relativePath);
-        const localHeaderPath = path.join(localDir, ossName, "headers", relativePath);
-        const remoteUrl = `${PATH_CONFIG.remoteBaseUrl}/${relativePath}`;
+    // 请求远程文件
+    console.log(`请求远程文件: ${remoteUrl}`);
 
-        // 检查是否在404列表中
-        if (notFoundList.has(relativePath)) {
-            this.ctx.status = 404;
-            return this.ctx.render('500', { errorMsg: ' 远程文件不存在, 命中notFoundList' });
-        }
+    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;
-        }
-
-
-        // 请求远程文件
-        console.log(`请求远程文件: ${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();
-                console.log(`远程文件不存在，已记录404: ${relativePath}`);
-                this.ctx.status = 404;
-                return this.ctx.render('500', { errorMsg: ' 远程文件不存在，已记录404' });
-            } else {
-                // 其他状态码
-                const msg = `远程服务器返回状态码: ${remoteRes.statusCode}`;
-                console.log(msg);
-                this.ctx.status = 502;
-                return this.ctx.render('500', { errorMsg: msg });
-            }
-        } catch (err) {
-            const msg = `请求远程文件失败: ${err}`;
-            console.log(msg);
-            this.ctx.status = 500;
-            return this.ctx.render('500', { errorMsg: msg });
+          return;
         }
-
-        this.ctx.status = 500;
-        return this.ctx.render('500', { errorMsg: "未知异常" });
+      } else if (remoteRes.statusCode === 404) {
+        // 记录404并返回
+        notFoundList.add(relativePath);
+        await this.saveNotFoundList();
+        console.log(`远程文件不存在，已记录404: ${relativePath}`);
+        this.ctx.status = 404;
+        return this.ctx.render('500', { errorMsg: ' 远程文件不存在，已记录404' });
+      } else {
+        // 其他状态码
+        const msg = `远程服务器返回状态码: ${remoteRes.statusCode}`;
+        console.log(msg);
+        this.ctx.status = 502;
+        return this.ctx.render('500', { errorMsg: msg });
+      }
+    } catch (err) {
+      const msg = `请求远程文件失败: ${err}`;
+      console.log(msg);
+      this.ctx.status = 500;
+      return this.ctx.render('500', { errorMsg: msg });
     }
 
-
-    // 保存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) {
-            console.error('保存404列表失败:', error);
-        }
+    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) {
+      console.error('保存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);
-            });
+  }
+
+  // 封装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 });
+  // 新增：将响应body写入文件的函数
+  async writeResponseToFile(httpsGetRes: HttpGetRes, localFilePath: string, localHeaderPath: string): Promise<void> {
+    // 创建本地目录（如果不存在）
+    const localFileDir = path.dirname(localFilePath);
+    await fs.mkdir(localFileDir, { recursive: true });
 
-        try {
-            const { statusCode, body } = httpsGetRes;
+    const localHeaderDir = path.dirname(localHeaderPath);
+    await fs.mkdir(localHeaderDir, { recursive: true });
 
-            // 检查HTTP状态码
-            if (statusCode >= 400) {
-                throw new Error(`HTTP请求失败，状态码: ${statusCode}`);
-            }
+    try {
+      const { statusCode, body } = httpsGetRes;
 
-            // 创建可写流
-            const fileStream = fs2.createWriteStream(localFilePath);
+      // 检查HTTP状态码
+      if (statusCode >= 400) {
+        throw new Error(`HTTP请求失败，状态码: ${statusCode}`);
+      }
 
-            // 使用管道将响应流写入文件
-            await new Promise((resolve, reject) => {
-                body.pipe(fileStream);
+      // 创建可写流
+      const fileStream = fs2.createWriteStream(localFilePath);
 
-                body.on('error', (err) => {
-                    reject(new Error(`读取响应流失败: ${err.message}`));
-                });
+      // 使用管道将响应流写入文件
+      await new Promise((resolve, reject) => {
+        body.pipe(fileStream);
 
-                fileStream.on('finish', resolve);
-                fileStream.on('error', (err) => {
-                    reject(new Error(`写入文件失败: ${err.message}`));
-                });
-            });
-
-            console.log(`文件已成功写入1: ${localFilePath}`);
-
-            await fs.writeFile(localHeaderPath, JSON.stringify(httpsGetRes.headers), 'utf8')
+        body.on('error', err => {
+          reject(new Error(`读取响应流失败: ${err.message}`));
+        });
 
-            console.log(`文件已成功写入2: ${localHeaderPath}`);
+        fileStream.on('finish', resolve);
+        fileStream.on('error', err => {
+          reject(new Error(`写入文件失败: ${err.message}`));
+        });
+      });
 
+      console.log(`文件已成功写入1: ${localFilePath}`);
 
-        } catch (err) {
-            // 发生错误时删除可能存在的不完整文件
-            if (fs2.existsSync(localFilePath)) {
-                fs2.unlinkSync(localFilePath);
-            }
-            throw new Error(`下载过程中发生错误: ${err.message}`);
-        }
-    }
+      await fs.writeFile(localHeaderPath, JSON.stringify(httpsGetRes.headers), 'utf8');
 
-    // 根据文件扩展名获取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';
+      console.log(`文件已成功写入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

@@ -16,7 +16,7 @@ import { CommonResult } from '../libs/utils/common-dto';
 @Controller('/ns/api/helpers')
 export class HelpersApi {
   @Inject()
-  ctx: Context;
+  protected ctx: Context;
 
   @Inject()
   private midwayWebRouterService: MidwayWebRouterService;

package/src/controller/home.controller.ts

@@ -47,8 +47,6 @@ export class HomeController extends BaseApiController {
     return this.ctx.renderString(html_content, { workbenchInfo, userInfo, utils }, { viewEngine: 'ejs' });
   }
 
-
-
   @Get('/robots.txt')
   async robots(): Promise<string> {
     return `User-agent: * \nDisallow: /ns/api/manage/`;
@@ -63,7 +61,4 @@ export class HomeController extends BaseApiController {
   //   ctx.set('Content-Type', 'image/jpeg');
   //   ctx.body = buffer;
   // }
-
-
-
 }

package/src/controller/manage/AnyApiMangeApi.ts

@@ -7,13 +7,13 @@ import { SystemFuncCode } from '@/models/SystemPerm';
 import { SystemTables } from '@/models/SystemTables';
 import { ISysAnyApiEntity } from '@/models/SystemEntities';
 import * as md5 from 'md5';
-import {parseJsonObject} from "@/libs/utils/functions";
+import { parseJsonObject } from '@/libs/utils/functions';
 
 function fixBodyData(body: any) {
   const dataObj: any = (body.data || {}) as ISysAnyApiEntity;
   const parsedOthers = parseJsonObject(dataObj.others);
   dataObj.func_code_md5 = md5(dataObj.func_code || '');
-  dataObj.req_params = parsedOthers?.req_params?.length || 0;   // 参数个数
+  dataObj.req_params = parsedOthers?.req_params?.length || 0; // 参数个数
 }
 
 @Controller('/ns/api/manage/anyapi', { middleware: [checkPermission(SystemFuncCode.AnyApiManageRead)] })
@@ -31,7 +31,7 @@ export class AnyApiMangeApi extends BaseApiController {
     return this.executeSysSimpleSQL(SystemTables.sys_anyapi, KeysOfSimpleSQL.SIMPLE_QUERY_ONE);
   }
 
-  @Post('/createAnyApi',  { middleware: [checkPermission(SystemFuncCode.AnyApiManageWrite)] })
+  @Post('/createAnyApi', { middleware: [checkPermission(SystemFuncCode.AnyApiManageWrite)] })
   async createAnyApi() {
     fixBodyData(this.ctx.request.body);
 
@@ -44,7 +44,7 @@ export class AnyApiMangeApi extends BaseApiController {
     });
   }
 
-  @Post('/updateAnyApi' , { middleware: [checkPermission(SystemFuncCode.AnyApiManageWrite)] })
+  @Post('/updateAnyApi', { middleware: [checkPermission(SystemFuncCode.AnyApiManageWrite)] })
   async updateAnyApi() {
     fixBodyData(this.ctx.request.body);
 

package/src/controller/manage/AppLogMangeApi.ts

@@ -1,9 +1,9 @@
 import { Controller, Inject, Post } from '@midwayjs/core';
 import { Context } from '@midwayjs/koa';
-import { KeysOfSimpleSQL, KeysOfValidators } from '../../libs/crud-pro/models/keys';
+import { KeysOfSimpleSQL, KeysOfValidators } from '@/libs/crud-pro/models/keys';
 import { BaseApiController } from '../base/BaseApiController';
-import { checkPermission } from '../../middleware/permission.middleware';
-import {SystemFuncCode} from "../../models/SystemPerm";
+import { checkPermission } from '@/middleware/permission.middleware';
+import { SystemFuncCode } from '@/models/SystemPerm';
 
 @Controller('/ns/api/manage/appLog', { middleware: [checkPermission(SystemFuncCode.AppMangeRead)] })
 export class AppLogMangeApi extends BaseApiController {