whistle.mock-plugins 1.0.0

package/app/cgi-bin/interfaces.js

@@ -0,0 +1,409 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+module.exports = function(req, res) {
+  const dataDir = this.dataDir;
+  const interfacesFile = path.join(dataDir, 'interfaces.json');
+  const featuresFile = path.join(dataDir, 'features.json');
+  
+  try {
+    // 确保配置文件存在并包含有效结构
+    if (!fs.existsSync(interfacesFile)) {
+      fs.writeJsonSync(interfacesFile, { interfaces: [] }, { spaces: 2 });
+    } else {
+      // 验证文件结构
+      try {
+        const fileData = fs.readJsonSync(interfacesFile);
+        if (!fileData || !fileData.interfaces) {
+          // 如果文件存在但结构无效，重新初始化
+          fs.writeJsonSync(interfacesFile, { interfaces: [] }, { spaces: 2 });
+          console.log('修复了损坏的interfaces文件结构');
+        }
+      } catch (e) {
+        // JSON解析错误时重新初始化文件
+        fs.writeJsonSync(interfacesFile, { interfaces: [] }, { spaces: 2 });
+        console.log('修复了无法解析的interfaces文件');
+      }
+    }
+    
+    // 处理GET请求 - 获取接口列表
+    if (req.method === 'GET') {
+      const { featureId } = req.query;
+      
+      if (!featureId) {
+        return res.status(400).json({
+          code: 400,
+          message: '功能ID不能为空',
+          data: null
+        });
+      }
+      
+      // 检查功能是否存在
+      let featureExists = false;
+      if (fs.existsSync(featuresFile)) {
+        try {
+          const featuresData = fs.readJsonSync(featuresFile);
+          if (featuresData && featuresData.features) {
+            const feature = featuresData.features.find(item => item.id === featureId);
+            featureExists = !!feature;
+          }
+          
+          if (!featureExists) {
+            return res.status(404).json({
+              code: 404,
+              message: '功能模块不存在',
+              data: null
+            });
+          }
+        } catch (err) {
+          console.error('读取功能文件错误:', err);
+          // 出错时继续处理
+        }
+      }
+      
+      // 读取接口数据
+      let interfacesData;
+      try {
+        interfacesData = fs.readJsonSync(interfacesFile);
+        if (!interfacesData || !interfacesData.interfaces) {
+          interfacesData = { interfaces: [] };
+        }
+      } catch (err) {
+        console.error('读取接口列表错误:', err);
+        interfacesData = { interfaces: [] };
+      }
+      
+      const filteredInterfaces = interfacesData.interfaces.filter(item => item.featureId === featureId);
+      
+      return res.json({
+        code: 0,
+        message: '成功',
+        data: filteredInterfaces
+      });
+    }
+    
+    // 处理POST请求 - 添加或更新接口
+    if (req.method === 'POST') {
+      const interfaceData = req.body;
+      
+      // 参数验证
+      if (!interfaceData.featureId) {
+        return res.status(400).json({
+          code: 400,
+          message: '功能ID不能为空',
+          data: null
+        });
+      }
+      
+      if (!interfaceData.name) {
+        return res.status(400).json({
+          code: 400,
+          message: '接口名称不能为空',
+          data: null
+        });
+      }
+      
+      if (!interfaceData.urlPattern) {
+        return res.status(400).json({
+          code: 400,
+          message: 'URL匹配规则不能为空',
+          data: null
+        });
+      }
+      
+      // 检查是否响应内容过大，超过100MB时给予特殊处理
+      if (interfaceData.responseContent && Buffer.byteLength(interfaceData.responseContent, 'utf8') > 100 * 1024 * 1024) {
+        return res.status(413).json({
+          code: 413,
+          message: '响应内容过大，超过100MB限制',
+          data: null
+        });
+      }
+      
+      // 检查功能是否存在
+      let featureExists = false;
+      if (fs.existsSync(featuresFile)) {
+        try {
+          const featuresData = fs.readJsonSync(featuresFile);
+          if (featuresData && featuresData.features) {
+            const feature = featuresData.features.find(item => item.id === interfaceData.featureId);
+            featureExists = !!feature;
+          }
+          
+          if (!featureExists) {
+            return res.status(404).json({
+              code: 404,
+              message: '功能模块不存在',
+              data: null
+            });
+          }
+        } catch (err) {
+          console.error('读取功能文件错误:', err);
+          // 忽略错误继续处理
+        }
+      }
+      
+      // 读取接口数据
+      let interfacesData;
+      try {
+        interfacesData = fs.readJsonSync(interfacesFile);
+        if (!interfacesData || !interfacesData.interfaces) {
+          interfacesData = { interfaces: [] };
+        }
+      } catch (err) {
+        console.error('读取接口列表错误:', err);
+        interfacesData = { interfaces: [] };
+      }
+      
+      // 如果有ID则更新，否则创建新接口
+      if (interfaceData.id) {
+        // 更新现有接口
+        const index = interfacesData.interfaces.findIndex(item => item.id === interfaceData.id);
+        
+        if (index === -1) {
+          return res.status(404).json({
+            code: 404,
+            message: '接口不存在',
+            data: null
+          });
+        }
+        
+        // 更新接口
+        interfacesData.interfaces[index] = {
+          ...interfacesData.interfaces[index],
+          name: interfaceData.name,
+          urlPattern: interfaceData.urlPattern,
+          proxyType: interfaceData.proxyType,
+          responseContent: interfaceData.responseContent,
+          targetUrl: interfaceData.targetUrl,
+          filePath: interfaceData.filePath,
+          httpStatus: interfaceData.httpStatus || 200,
+          responseDelay: interfaceData.responseDelay || 0,
+          httpMethod: interfaceData.httpMethod || 'ALL',
+          active: interfaceData.active !== false
+        };
+        
+        fs.writeJsonSync(interfacesFile, interfacesData, { spaces: 2 });
+        
+        return res.json({
+          code: 0,
+          message: '接口更新成功',
+          data: interfacesData.interfaces[index]
+        });
+      } else {
+        // 创建新接口
+        const newInterface = {
+          id: Date.now().toString(),
+          featureId: interfaceData.featureId,
+          name: interfaceData.name,
+          urlPattern: interfaceData.urlPattern,
+          proxyType: interfaceData.proxyType || 'response',
+          responseContent: interfaceData.responseContent || '',
+          targetUrl: interfaceData.targetUrl || '',
+          filePath: interfaceData.filePath || '',
+          httpStatus: interfaceData.httpStatus || 200,
+          responseDelay: interfaceData.responseDelay || 0,
+          httpMethod: interfaceData.httpMethod || 'ALL',
+          active: interfaceData.active !== false,
+          contentType: interfaceData.contentType || 'text/plain'
+        };
+        
+        // 确保interfaces数组存在
+        if (!Array.isArray(interfacesData.interfaces)) {
+          interfacesData.interfaces = [];
+        }
+        
+        interfacesData.interfaces.push(newInterface);
+        fs.writeJsonSync(interfacesFile, interfacesData, { spaces: 2 });
+        
+        return res.json({
+          code: 0,
+          message: '接口创建成功',
+          data: newInterface
+        });
+      }
+    }
+    
+    // 处理DELETE请求 - 删除接口
+    if (req.method === 'DELETE') {
+      const { id } = req.query;
+      
+      if (!id) {
+        return res.status(400).json({
+          code: 400,
+          message: '接口ID不能为空',
+          data: null
+        });
+      }
+      
+      let interfacesData;
+      try {
+        interfacesData = fs.readJsonSync(interfacesFile);
+        if (!interfacesData || !interfacesData.interfaces) {
+          interfacesData = { interfaces: [] };
+        }
+      } catch (err) {
+        console.error('读取接口列表错误:', err);
+        interfacesData = { interfaces: [] };
+      }
+      
+      const index = interfacesData.interfaces.findIndex(item => item.id === id);
+      
+      if (index === -1) {
+        return res.status(404).json({
+          code: 404,
+          message: '接口不存在',
+          data: null
+        });
+      }
+      
+      // 删除接口
+      const deletedInterface = interfacesData.interfaces.splice(index, 1)[0];
+      fs.writeJsonSync(interfacesFile, interfacesData, { spaces: 2 });
+      
+      return res.json({
+        code: 0,
+        message: '接口删除成功',
+        data: deletedInterface
+      });
+    }
+    
+    // 处理 PUT 请求 - 更新接口
+    if (req.method === 'PUT') {
+      const { id } = req.query;
+      const interfaceData = req.body;
+      
+      if (!id) {
+        return res.status(400).json({
+          code: 400,
+          message: '接口ID不能为空',
+          data: null
+        });
+      }
+      
+      // 读取接口数据
+      let interfacesData;
+      try {
+        interfacesData = fs.readJsonSync(interfacesFile);
+        if (!interfacesData || !interfacesData.interfaces) {
+          interfacesData = { interfaces: [] };
+        }
+      } catch (err) {
+        console.error('读取接口列表错误:', err);
+        return res.status(500).json({
+          code: 500, 
+          message: '读取接口数据失败',
+          data: null
+        });
+      }
+      
+      // 查找并更新接口
+      const index = interfacesData.interfaces.findIndex(item => item.id === id);
+      
+      if (index === -1) {
+        return res.status(404).json({
+          code: 404,
+          message: '接口不存在',
+          data: null
+        });
+      }
+      
+      // 更新接口数据
+      const updatedInterface = {
+        ...interfacesData.interfaces[index],
+        name: interfaceData.name || interfacesData.interfaces[index].name,
+        urlPattern: interfaceData.urlPattern || interfacesData.interfaces[index].urlPattern,
+        proxyType: interfaceData.proxyType || interfacesData.interfaces[index].proxyType,
+        responseContent: interfaceData.responseContent !== undefined ? interfaceData.responseContent : interfacesData.interfaces[index].responseContent,
+        targetUrl: interfaceData.targetUrl !== undefined ? interfaceData.targetUrl : interfacesData.interfaces[index].targetUrl,
+        filePath: interfaceData.filePath !== undefined ? interfaceData.filePath : interfacesData.interfaces[index].filePath,
+        httpStatus: interfaceData.httpStatus || interfacesData.interfaces[index].httpStatus,
+        responseDelay: interfaceData.responseDelay !== undefined ? interfaceData.responseDelay : interfacesData.interfaces[index].responseDelay,
+        httpMethod: interfaceData.httpMethod || interfacesData.interfaces[index].httpMethod,
+        active: interfaceData.active !== undefined ? interfaceData.active : interfacesData.interfaces[index].active,
+        contentType: interfaceData.contentType || interfacesData.interfaces[index].contentType,
+        updatedAt: new Date().toISOString()
+      };
+      
+      interfacesData.interfaces[index] = updatedInterface;
+      fs.writeJsonSync(interfacesFile, interfacesData, { spaces: 2 });
+      
+      return res.json({
+        code: 0,
+        message: '接口更新成功',
+        data: updatedInterface
+      });
+    }
+    
+    // 处理 PATCH 请求 - 部分更新接口（如启用/禁用状态）
+    if (req.method === 'PATCH') {
+      const { id } = req.query;
+      const patchData = req.body;
+      
+      if (!id) {
+        return res.status(400).json({
+          code: 400,
+          message: '接口ID不能为空',
+          data: null
+        });
+      }
+      
+      // 读取接口数据
+      let interfacesData;
+      try {
+        interfacesData = fs.readJsonSync(interfacesFile);
+        if (!interfacesData || !interfacesData.interfaces) {
+          interfacesData = { interfaces: [] };
+        }
+      } catch (err) {
+        console.error('读取接口列表错误:', err);
+        return res.status(500).json({
+          code: 500, 
+          message: '读取接口数据失败',
+          data: null
+        });
+      }
+      
+      // 查找接口
+      const index = interfacesData.interfaces.findIndex(item => item.id === id);
+      
+      if (index === -1) {
+        return res.status(404).json({
+          code: 404,
+          message: '接口不存在',
+          data: null
+        });
+      }
+      
+      // 部分更新接口数据
+      const updatedInterface = {
+        ...interfacesData.interfaces[index],
+        ...patchData,
+        updatedAt: new Date().toISOString()
+      };
+      
+      interfacesData.interfaces[index] = updatedInterface;
+      fs.writeJsonSync(interfacesFile, interfacesData, { spaces: 2 });
+      
+      return res.json({
+        code: 0,
+        message: '接口更新成功',
+        data: updatedInterface
+      });
+    }
+    
+    // 其他请求方法
+    return res.status(405).json({
+      code: 405,
+      message: '不支持的请求方法',
+      data: null
+    });
+  } catch (err) {
+    console.error('处理接口请求出错:', err);
+    return res.status(500).json({
+      code: 500,
+      message: '服务器内部错误: ' + err.message,
+      data: null
+    });
+  }
+}; 

package/app/cgi-bin/logs.js

@@ -0,0 +1,151 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+module.exports = function(req, res) {
+  const dataDir = this.dataDir;
+  const logsFile = path.join(dataDir, 'logs.json');
+  
+  // 处理GET请求 - 获取日志
+  if (req.method === 'GET') {
+    try {
+      // 解析查询参数
+      const limit = parseInt(req.query.limit) || 100;
+      const type = req.query.type || '';
+      const keyword = req.query.keyword || '';
+      const page = parseInt(req.query.page) || 1;
+      const pageSize = parseInt(req.query.pageSize) || 20;
+      
+      // 确保日志文件存在
+      if (!fs.existsSync(logsFile)) {
+        fs.writeJsonSync(logsFile, { logs: [] }, { spaces: 2 });
+        return res.json({
+          code: 0,
+          message: '成功',
+          data: {
+            logs: [],
+            total: 0,
+            page: 1,
+            pageSize: pageSize,
+            totalPages: 0
+          }
+        });
+      }
+      
+      // 读取日志
+      const logsData = fs.readJsonSync(logsFile);
+      
+      // 确保日志结构正确
+      if (!logsData || !logsData.logs || !Array.isArray(logsData.logs)) {
+        logsData.logs = [];
+      }
+      
+      // 标准化日志格式，确保每个日志项都有正确的字段
+      let logs = logsData.logs.map(log => {
+        if (!log) return null;
+        
+        // 标准化事件类型字段，确保兼容前端过滤
+        // 将type转换为eventType确保前端能够正确过滤
+        return {
+          id: log.id || Date.now().toString(),
+          timestamp: log.timestamp || new Date().toISOString(),
+          eventType: log.eventType || log.type || 'unknown',
+          type: log.type || log.eventType || 'unknown',
+          method: log.method || '',
+          url: log.url || '',
+          status: log.status || '',
+          message: log.message || '',
+          pattern: log.pattern || '',
+          ...log // 保留原有其他字段
+        };
+      }).filter(Boolean); // 过滤掉null
+      
+      // 根据类型过滤
+      if (type && type !== 'all') {
+        try {
+          logs = logs.filter(log => 
+            log && (log.eventType === type || log.type === type)
+          );
+        } catch (err) {
+          console.error('按类型过滤日志失败:', err);
+          // 出错时不过滤
+        }
+      }
+      
+      // 根据关键词过滤
+      if (keyword) {
+        try {
+          logs = logs.filter(log => {
+            if (!log) return false;
+            
+            // 检查关键字段是否包含关键词
+            const url = (log.url || '').toLowerCase();
+            const pattern = (log.pattern || '').toLowerCase();
+            const message = (log.message || '').toLowerCase();
+            const lowercaseKeyword = keyword.toLowerCase();
+            
+            return url.includes(lowercaseKeyword) || 
+                   pattern.includes(lowercaseKeyword) || 
+                   message.includes(lowercaseKeyword);
+          });
+        } catch (err) {
+          console.error('按关键词过滤日志失败:', err);
+          // 出错时不过滤
+        }
+      }
+      
+      // 计算总记录数和总页数
+      const total = logs.length;
+      const totalPages = Math.ceil(total / pageSize);
+      
+      // 分页
+      const startIndex = (page - 1) * pageSize;
+      const pagedLogs = logs.slice(startIndex, startIndex + pageSize);
+      
+      return res.json({
+        code: 0,
+        message: '成功',
+        data: {
+          logs: pagedLogs,
+          total: total,
+          page: page,
+          pageSize: pageSize,
+          totalPages: totalPages
+        }
+      });
+    } catch (err) {
+      console.error('获取日志失败:', err);
+      return res.status(500).json({
+        code: 500,
+        message: '获取日志失败: ' + err.message,
+        data: null
+      });
+    }
+  }
+  
+  // 处理DELETE请求 - 清空日志
+  if (req.method === 'DELETE') {
+    try {
+      fs.writeJsonSync(logsFile, { logs: [] }, { spaces: 2 });
+      
+      return res.json({
+        code: 0,
+        message: '日志已清空',
+        data: null
+      });
+    } catch (err) {
+      console.error('清空日志失败:', err);
+      return res.status(500).json({
+        code: 500,
+        message: '清空日志失败: ' + err.message,
+        data: null
+      });
+    }
+  }
+  
+  // 其他请求方法
+  return res.status(405).json({
+    code: 405,
+    message: '不支持的请求方法',
+    data: null
+  });
+}; 

package/app/cgi-bin/test-interface.js

@@ -0,0 +1,152 @@
+const fs = require('fs-extra');
+const path = require('path');
+const Mock = require('mockjs');
+
+module.exports = async function(req, res) {
+  const dataDir = this.dataDir;
+  const interfacesFile = path.join(dataDir, 'interfaces.json');
+  const featuresFile = path.join(dataDir, 'features.json');
+  
+  try {
+    // 只处理 POST 请求
+    if (req.method === 'POST') {
+      const { url, interfaceId } = req.body;
+      
+      // 参数验证
+      if (!url) {
+        return res.status(400).json({
+          code: 400,
+          message: '测试URL不能为空',
+          data: null
+        });
+      }
+      
+      if (!interfaceId) {
+        return res.status(400).json({
+          code: 400,
+          message: '接口ID不能为空',
+          data: null
+        });
+      }
+      
+      // 读取接口数据
+      let interfacesData;
+      try {
+        interfacesData = fs.readJsonSync(interfacesFile);
+        if (!interfacesData || !interfacesData.interfaces) {
+          return res.status(404).json({
+            code: 404,
+            message: '未找到接口数据',
+            data: null
+          });
+        }
+      } catch (err) {
+        return res.status(500).json({
+          code: 500,
+          message: '读取接口数据失败',
+          data: null
+        });
+      }
+      
+      // 查找指定接口
+      const targetInterface = interfacesData.interfaces.find(item => item.id === interfaceId);
+      
+      if (!targetInterface) {
+        return res.status(404).json({
+          code: 404,
+          message: '指定的接口不存在',
+          data: null
+        });
+      }
+      
+      // 检查接口是否已禁用
+      if (targetInterface.active === false) {
+        return res.status(400).json({
+          code: 400,
+          message: '接口已禁用，无法测试',
+          data: null
+        });
+      }
+      
+      // 检查功能模块是否已禁用
+      try {
+        const featuresData = fs.readJsonSync(featuresFile);
+        
+        if (featuresData && featuresData.features) {
+          const featureItem = featuresData.features.find(item => item.id === targetInterface.featureId);
+          
+          if (featureItem && featureItem.active === false) {
+            return res.status(400).json({
+              code: 400,
+              message: '所属功能模块已禁用，接口无法使用',
+              data: null
+            });
+          }
+        }
+      } catch (err) {
+        // 忽略读取错误，继续处理
+      }
+      
+      const startTime = Date.now();
+      
+      // 处理内容，支持 Mock.js 模板语法
+      let responseBody = targetInterface.responseContent;
+      
+      try {
+        // 如果响应内容是JSON，则尝试应用Mock.js模板
+        if (targetInterface.contentType && targetInterface.contentType.includes('json')) {
+          // 尝试解析JSON
+          const jsonTemplate = JSON.parse(responseBody);
+          // 使用Mock.js生成随机数据
+          const mockData = Mock.mock(jsonTemplate);
+          // 将结果转换回字符串
+          responseBody = JSON.stringify(mockData);
+        }
+      } catch (err) {
+        // 如果Mock失败，使用原始内容
+      }
+      
+      // 模拟接口处理延迟
+      const delay = targetInterface.responseDelay || 0;
+      if (delay > 0) {
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+      
+      const endTime = Date.now();
+      const duration = endTime - startTime;
+      
+      // 模拟接口处理
+      const responseData = {
+        statusCode: targetInterface.httpStatus || 200,
+        contentType: targetInterface.contentType || 'application/json; charset=utf-8',
+        responseBody: responseBody,
+        mockInfo: {
+          matchedPattern: targetInterface.urlPattern,
+          requestMethod: targetInterface.httpMethod,
+          delay: delay,
+          duration: duration,
+          timestamp: new Date().toISOString()
+        }
+      };
+      
+      return res.json({
+        code: 0,
+        message: '成功',
+        data: responseData
+      });
+    } else {
+      // 不支持的请求方法
+      return res.status(405).json({
+        code: 405,
+        message: '不支持的请求方法',
+        data: null
+      });
+    }
+  } catch (err) {
+    return res.status(500).json({
+      code: 500,
+      message: '服务器内部错误: ' + err.message,
+      data: null
+    });
+  }
+}; 

package/app/public/index.html

@@ -0,0 +1 @@
+<!doctype html><html lang="zh-CN"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Whistle Mock 数据工厂</title><script defer="defer" src="/js/index.js"></script></head><body><div id="root"></div></body></html>