whistle.mock-plugins 1.0.6-beta.12 → 1.0.6-beta.13

package/lib/routes/interfaces.js

@@ -20,60 +20,55 @@ const processInterfaceData = (data) => {
   const result = { ...data };
   
   // 调试日志
-  console.log('处理接口数据:', JSON.stringify({
+  console.log('=== 开始处理接口数据 ===');
+  console.log('原始数据:', JSON.stringify({
+    name: result.name,
     hasResponses: !!result.responses,
+    responsesType: typeof result.responses,
     responsesLength: result.responses ? result.responses.length : 0,
-    responseContent: !!result.responseContent
-  }));
+    responses: result.responses,
+    responseContent: !!result.responseContent,
+    activeResponseId: result.activeResponseId
+  }, null, 2));
   
-  // 如果没有提供 responses 但有 responseContent，创建默认响应
-  if ((!result.responses || !Array.isArray(result.responses) || result.responses.length === 0) && result.responseContent) {
-    result.responses = [{
-      id: Math.random().toString(36).substring(2, 15),
-      name: '默认响应',
-      description: '',
-      content: result.responseContent
-    }];
-    result.activeResponseId = result.responses[0].id;
-    console.log('创建默认响应:', result.responses[0].id);
-  }
-  
-  // 确保 responses 是数组
-  if (!Array.isArray(result.responses)) {
-    result.responses = [];
-    console.log('修正 responses 为空数组');
-  }
-  
-  // 确保每个响应都有合法的 id, name 和 content
-  result.responses = result.responses.map((resp, index) => {
-    if (!resp.id) {
-      resp.id = Math.random().toString(36).substring(2, 15);
-      console.log(`为响应 ${index} 添加 ID:`, resp.id);
-    }
-    if (!resp.name) {
-      resp.name = `响应 ${index + 1}`;
-      console.log(`为响应 ${index} 添加默认名称:`, resp.name);
-    }
-    if (!resp.content && result.responseContent && index === 0) {
-      resp.content = result.responseContent;
-      console.log(`为响应 ${index} 添加默认内容`);
+  // 处理 responses 数组
+  if (result.responses && Array.isArray(result.responses) && result.responses.length > 0) {
+    console.log('发现 responses 数组，直接处理多响应数据');
+    
+    // 确保每个响应都有合法的 id, name 和 content
+    result.responses = result.responses.map((resp, index) => {
+      console.log(`处理响应 ${index}:`, resp);
+      
+      if (!resp.id) {
+        resp.id = Math.random().toString(36).substring(2, 15);
+        console.log(`为响应 ${index} 添加 ID:`, resp.id);
+      }
+      if (!resp.name) {
+        resp.name = `响应 ${index + 1}`;
+        console.log(`为响应 ${index} 添加默认名称:`, resp.name);
+      }
+      
+      const processedResp = {
+        id: resp.id,
+        name: resp.name,
+        description: resp.description || '',
+        content: resp.content || '{}'
+      };
+      
+      console.log(`处理后的响应 ${index}:`, processedResp);
+      return processedResp;
+    });
+    
+    console.log('处理后的响应数组长度:', result.responses.length);
+    console.log('所有处理后的响应:', result.responses);
+    
+    // 如果有响应但没有设置 activeResponseId，默认使用第一个
+    if (!result.activeResponseId) {
+      result.activeResponseId = result.responses[0].id;
+      console.log('设置默认激活响应:', result.activeResponseId);
     }
-    return {
-      id: resp.id,
-      name: resp.name,
-      description: resp.description || '',
-      content: resp.content || '{}'
-    };
-  });
-  
-  // 如果有响应但没有设置 activeResponseId，默认使用第一个
-  if (result.responses.length > 0 && !result.activeResponseId) {
-    result.activeResponseId = result.responses[0].id;
-    console.log('设置默认激活响应:', result.activeResponseId);
-  }
-  
-  // 确保 responseContent 字段始终存在（向后兼容）
-  if (result.responses.length > 0) {
+    
+    // 确保 responseContent 字段始终存在（向后兼容）
     const activeResponse = result.activeResponseId
       ? result.responses.find(r => r.id === result.activeResponseId)
       : result.responses[0];
@@ -82,14 +77,43 @@ const processInterfaceData = (data) => {
       result.responseContent = activeResponse.content;
       console.log('设置 responseContent 为当前激活响应内容');
     }
+    
+  } else if (result.responseContent) {
+    // 如果没有提供 responses 但有 responseContent，创建默认响应（向后兼容）
+    console.log('创建默认响应，因为没有 responses 数组但有 responseContent');
+    result.responses = [{
+      id: Math.random().toString(36).substring(2, 15),
+      name: '默认响应',
+      description: '',
+      content: result.responseContent
+    }];
+    result.activeResponseId = result.responses[0].id;
+    console.log('创建的默认响应:', result.responses[0]);
+    
+  } else {
+    // 如果既没有 responses 也没有 responseContent，创建一个空的默认响应
+    console.log('创建空的默认响应');
+    result.responses = [{
+      id: Math.random().toString(36).substring(2, 15),
+      name: '默认响应',
+      description: '',
+      content: '{}'
+    }];
+    result.activeResponseId = result.responses[0].id;
+    result.responseContent = '{}';
+    console.log('创建的空默认响应:', result.responses[0]);
   }
   
   // 最终日志
-  console.log('处理后的接口数据:', JSON.stringify({
+  console.log('=== 处理后的最终接口数据 ===');
+  console.log('最终数据:', JSON.stringify({
+    name: result.name,
     responsesLength: result.responses.length,
+    responses: result.responses,
     activeResponseId: result.activeResponseId,
     hasResponseContent: !!result.responseContent
-  }));
+  }, null, 2));
+  console.log('=== 接口数据处理完成 ===\n');
   
   return result;
 };
@@ -104,33 +128,69 @@ const initRouter = () => {
   // 获取所有接口
   router.get('/interfaces', (req, res) => {
     try {
+      const { featureId } = req.query;
+      
       // 读取所有功能
       const featuresFile = path.join(DATA_DIR, 'features.json');
       if (!fs.existsSync(featuresFile)) {
-        return res.json([]);
+        return res.json({ code: 0, data: [] });
       }
       
       const features = fs.readJsonSync(featuresFile);
       let allInterfaces = [];
       
-      // 读取每个功能的接口
-      features.forEach(feature => {
-        const interfacesFile = path.join(DATA_DIR, `interfaces-${feature.id}.json`);
+      if (featureId) {
+        // 获取特定功能的接口
+        const interfacesFile = path.join(DATA_DIR, `interfaces-${featureId}.json`);
         if (fs.existsSync(interfacesFile)) {
           const interfaces = fs.readJsonSync(interfacesFile);
-          // 添加功能名称到接口数据中
-          const interfacesWithFeature = interfaces.map(item => ({
-            ...item,
-            featureName: feature.name
-          }));
-          allInterfaces = allInterfaces.concat(interfacesWithFeature);
+          console.log('=== 获取接口：从文件读取的原始数据 ===');
+          console.log(`文件路径: ${interfacesFile}`);
+          console.log('原始接口数据:', JSON.stringify(interfaces, null, 2));
+          
+          const processedInterfaces = interfaces.map((item, index) => {
+            console.log(`=== 处理接口 ${index}: ${item.name} ===`);
+            console.log('处理前的接口数据:', JSON.stringify(item, null, 2));
+            
+            // 确保每个接口都经过数据处理
+            const processed = processInterfaceData(item);
+            console.log('处理后的接口数据:', JSON.stringify(processed, null, 2));
+            
+            const feature = features.find(f => f.id === featureId);
+            const result = {
+              ...processed,
+              featureName: feature ? feature.name : '未知功能'
+            };
+            
+            console.log('最终接口数据:', JSON.stringify(result, null, 2));
+            return result;
+          });
+          allInterfaces = processedInterfaces;
         }
-      });
+      } else {
+        // 读取每个功能的接口
+        features.forEach(feature => {
+          const interfacesFile = path.join(DATA_DIR, `interfaces-${feature.id}.json`);
+          if (fs.existsSync(interfacesFile)) {
+            const interfaces = fs.readJsonSync(interfacesFile);
+            // 确保每个接口都经过数据处理
+            const processedInterfaces = interfaces.map(item => {
+              const processed = processInterfaceData(item);
+              return {
+                ...processed,
+                featureName: feature.name
+              };
+            });
+            allInterfaces = allInterfaces.concat(processedInterfaces);
+          }
+        });
+      }
       
-      res.json(allInterfaces);
+      console.log(`获取接口列表成功，共 ${allInterfaces.length} 个接口`);
+      res.json({ code: 0, data: allInterfaces });
     } catch (err) {
       console.error('获取接口列表失败:', err);
-      res.status(500).json({ error: '获取接口列表失败' });
+      res.status(500).json({ code: 1, message: '获取接口列表失败: ' + err.message });
     }
   });
   
@@ -140,7 +200,7 @@ const initRouter = () => {
       // 读取所有功能
       const featuresFile = path.join(DATA_DIR, 'features.json');
       if (!fs.existsSync(featuresFile)) {
-        return res.status(404).json({ error: '接口不存在' });
+        return res.status(404).json({ code: 1, message: '接口不存在' });
       }
       
       const features = fs.readJsonSync(featuresFile);
@@ -153,8 +213,10 @@ const initRouter = () => {
           const interfaces = fs.readJsonSync(interfacesFile);
           const found = interfaces.find(item => item.id === req.params.id);
           if (found) {
+            // 确保数据经过处理
+            const processed = processInterfaceData(found);
             foundInterface = {
-              ...found,
+              ...processed,
               featureName: feature.name
             };
             break;
@@ -163,13 +225,14 @@ const initRouter = () => {
       }
       
       if (!foundInterface) {
-        return res.status(404).json({ error: '接口不存在' });
+        return res.status(404).json({ code: 1, message: '接口不存在' });
       }
       
-      res.json(foundInterface);
+      console.log(`获取接口详情成功: ${foundInterface.name}，响应数量: ${foundInterface.responses ? foundInterface.responses.length : 0}`);
+      res.json({ code: 0, data: foundInterface });
     } catch (err) {
       console.error('获取接口详情失败:', err);
-      res.status(500).json({ error: '获取接口详情失败' });
+      res.status(500).json({ code: 1, message: '获取接口详情失败: ' + err.message });
     }
   });
   
@@ -210,7 +273,10 @@ const initRouter = () => {
         : [];
       
       // 处理接口数据，确保兼容多响应格式
+      console.log('=== 创建接口：开始处理数据 ===');
+      console.log('接收到的接口数据:', JSON.stringify(interfaceData, null, 2));
       const processedData = processInterfaceData(interfaceData);
+      console.log('处理后的接口数据:', JSON.stringify(processedData, null, 2));
       
       // 创建新接口
       const newInterface = {
@@ -220,10 +286,20 @@ const initRouter = () => {
         updatedAt: new Date().toISOString()
       };
       
+      console.log('=== 创建接口：准备保存的完整接口数据 ===');
+      console.log('完整的新接口数据:', JSON.stringify(newInterface, null, 2));
+      
       interfaces.push(newInterface);
       
       // 保存接口列表
       fs.writeJsonSync(interfacesFile, interfaces, { spaces: 2 });
+      console.log('接口数据已保存到文件:', interfacesFile);
+      
+      // 验证保存后从文件读取的数据
+      const savedInterfaces = fs.readJsonSync(interfacesFile);
+      const savedInterface = savedInterfaces.find(item => item.id === newInterface.id);
+      console.log('=== 创建接口：验证保存后的数据 ===');
+      console.log('从文件读取的保存后数据:', JSON.stringify(savedInterface, null, 2));
       
       // 更新功能模块的接口数量
       const featureIndex = features.findIndex(f => f.id === interfaceData.featureId);
@@ -231,6 +307,9 @@ const initRouter = () => {
       features[featureIndex].updatedAt = new Date().toISOString();
       fs.writeJsonSync(featuresFile, features, { spaces: 2 });
       
+      console.log('=== 创建接口：准备返回的数据 ===');
+      console.log('返回给前端的数据:', JSON.stringify(newInterface, null, 2));
+      
       res.json({
         code: 0,
         message: '接口创建成功',
@@ -303,7 +382,10 @@ const initRouter = () => {
       }
       
       // 处理接口数据，确保兼容多响应格式
+      console.log('=== 更新接口：开始处理数据 ===');
+      console.log('接收到的接口数据:', JSON.stringify(interfaceData, null, 2));
       const processedData = processInterfaceData(interfaceData);
+      console.log('处理后的接口数据:', JSON.stringify(processedData, null, 2));
       
       // 更新接口
       const updatedInterface = {
@@ -312,10 +394,23 @@ const initRouter = () => {
         updatedAt: new Date().toISOString()
       };
       
+      console.log('=== 更新接口：准备保存的完整接口数据 ===');
+      console.log('完整的更新接口数据:', JSON.stringify(updatedInterface, null, 2));
+      
       interfaces[index] = updatedInterface;
       
       // 保存接口列表
       fs.writeJsonSync(interfacesFile, interfaces, { spaces: 2 });
+      console.log('接口数据已保存到文件:', interfacesFile);
+      
+      // 验证保存后从文件读取的数据
+      const savedInterfaces = fs.readJsonSync(interfacesFile);
+      const savedInterface = savedInterfaces.find(item => item.id === id);
+      console.log('=== 更新接口：验证保存后的数据 ===');
+      console.log('从文件读取的保存后数据:', JSON.stringify(savedInterface, null, 2));
+      
+      console.log('=== 更新接口：准备返回的数据 ===');
+      console.log('返回给前端的数据:', JSON.stringify(updatedInterface, null, 2));
       
       res.json({
         code: 0,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whistle.mock-plugins",
-  "version": "1.0.6-beta.12",
+  "version": "1.0.6-beta.13",
   "description": "Whistle 插件，用于快速创建 API 模拟数据",
   "main": "lib/index.js",
   "scripts": {

package/ui/src/pages/InterfaceManagement.js

@@ -112,9 +112,38 @@ const InterfaceManagement = () => {
     try {
       setInterfacesLoading(true);
       const response = await axios.get(`/cgi-bin/interfaces?featureId=${selectedFeatureId}`);
+      
+      console.log('获取接口列表响应:', response.data);
+      
       if (response.data && response.data.code === 0 && Array.isArray(response.data.data)) {
-        setInterfaces(response.data.data);
+        // 确保每个接口的响应数据格式正确
+        const processedInterfaces = response.data.data.map(item => {
+          console.log(`处理接口 ${item.name}:`, {
+            hasResponses: !!item.responses,
+            responsesLength: item.responses ? item.responses.length : 0,
+            activeResponseId: item.activeResponseId
+          });
+          
+          // 确保 responses 是数组
+          if (!Array.isArray(item.responses)) {
+            item.responses = [];
+          }
+          
+          // 确保每个响应都有必要的字段
+          item.responses = item.responses.map((resp, index) => ({
+            id: resp.id || `resp-${index}-${Date.now()}`,
+            name: resp.name || `响应 ${index + 1}`,
+            description: resp.description || '',
+            content: resp.content || '{}'
+          }));
+          
+          return item;
+        });
+        
+        setInterfaces(processedInterfaces);
+        console.log('处理后的接口列表:', processedInterfaces);
       } else {
+        console.warn('接口数据格式不正确:', response.data);
         setInterfaces([]);
         message.warning('获取接口配置数据格式不正确');
       }
@@ -304,14 +333,20 @@ const InterfaceManagement = () => {
   const handleSubmit = async () => {
     try {
       const values = await form.validateFields();
-      console.log('表单提交，原始值:', values);
+      console.log('=== 开始表单提交 ===');
+      console.log('表单提交，原始值:', JSON.stringify(values, null, 2));
       
       // 获取当前激活的响应ID和所有响应
       const activeResponseId = values.activeResponseId;
       let responses = values.responses || [];
       
+      console.log('提取的原始响应数据:', responses);
+      console.log('响应数据类型:', typeof responses);
+      console.log('是否为数组:', Array.isArray(responses));
+      
       // 确保responses是数组格式
       if (!Array.isArray(responses)) {
+        console.log('响应数据不是数组，尝试解析...');
         try {
           if (typeof responses === 'string') {
             responses = JSON.parse(responses);
@@ -327,18 +362,24 @@ const InterfaceManagement = () => {
         }
       }
       
-      console.log('处理前的响应数据:', responses);
+      console.log('处理前的响应数据:', JSON.stringify(responses, null, 2));
       
       // 确保每个响应都有名称、描述和内容
-      const cleanedResponses = responses.map((resp, index) => ({
-        id: resp.id || uuidv4(),
-        name: resp.name || `响应 ${index + 1}`,
-        description: resp.description || '',
-        content: resp.content || '{}'
-      }));
+      const cleanedResponses = responses.map((resp, index) => {
+        console.log(`处理响应 ${index}:`, resp);
+        const cleaned = {
+          id: resp.id || uuidv4(),
+          name: resp.name || `响应 ${index + 1}`,
+          description: resp.description || '',
+          content: resp.content || '{}'
+        };
+        console.log(`处理后的响应 ${index}:`, cleaned);
+        return cleaned;
+      });
       
       // 如果没有响应，创建一个默认响应
       if (cleanedResponses.length === 0) {
+        console.log('没有响应数据，创建默认响应');
         const defaultId = uuidv4();
         cleanedResponses.push({
           id: defaultId,
@@ -357,8 +398,10 @@ const InterfaceManagement = () => {
       // 获取激活的响应
       const activeResponse = cleanedResponses.find(r => r.id === validActiveResponseId) || cleanedResponses[0];
       
-      console.log('处理后的响应数据:', cleanedResponses);
+      console.log('=== 清理后的响应数据 ===');
+      console.log('清理后的响应数据:', JSON.stringify(cleanedResponses, null, 2));
       console.log('激活的响应ID:', validActiveResponseId);
+      console.log('激活的响应:', activeResponse);
       
       // 检查responseBody是否是有效的JSON
       if (values.proxyType === 'response' && values.contentType.includes('application/json')) {
@@ -406,18 +449,24 @@ const InterfaceManagement = () => {
         active: true
       };
       
-      console.log('提交的接口数据:', interfaceData);
+      console.log('=== 最终提交的接口数据 ===');
+      console.log('提交的接口数据:', JSON.stringify(interfaceData, null, 2));
       
       let response;
       if (editingInterface) {
         // 更新现有接口
+        console.log('执行接口更新，ID:', editingInterface.id);
         response = await axios.put(`/cgi-bin/interfaces?id=${editingInterface.id}`, interfaceData);
       } else {
         // 创建新接口
+        console.log('执行接口创建');
         response = await axios.post('/cgi-bin/interfaces', interfaceData);
       }
 
+      console.log('服务器响应:', response.data);
+
       if (response.data && response.data.code === 0) {
+        console.log('=== 接口操作成功 ===');
         message.success(editingInterface ? '接口更新成功' : '接口创建成功');
         setModalVisible(false);
         fetchInterfaces();
@@ -432,6 +481,7 @@ const InterfaceManagement = () => {
         // 已经显示了错误信息，不需要再显示
         return;
       }
+      console.error('=== 接口操作失败 ===');
       console.error('操作失败:', error);
       message.error(error.response?.data?.message || error.message || '操作失败');
     }
@@ -1155,7 +1205,7 @@ const InterfaceManagement = () => {
 
             {/* 根据proxyType显示不同的表单项 */}
             <Form.Item noStyle shouldUpdate={(prevValues, currentValues) => prevValues.proxyType !== currentValues.proxyType}>
-              {({ getFieldValue }) => {
+              {({ getFieldValue, setFieldsValue }) => {
                 const proxyType = getFieldValue('proxyType');
                 
                 if (proxyType === 'response') {
@@ -1240,11 +1290,6 @@ const InterfaceManagement = () => {
                             
                             const activeResponseId = getFieldValue('activeResponseId');
                             
-                            // 同步更新响应内容到form.responses字段
-                            const updateResponses = (newResponses) => {
-                              setFieldsValue({ responses: newResponses });
-                            };
-                            
                             return (
                               <List
                                 size="small"
@@ -1288,14 +1333,15 @@ const InterfaceManagement = () => {
                                           placeholder="响应名称" 
                                           value={item.name || `响应 ${index + 1}`}
                                           onChange={(e) => {
-                                            const newResponses = [...responses];
-                                            if (newResponses[index]) {
-                                              newResponses[index] = {
-                                                ...newResponses[index],
-                                                name: e.target.value
-                                              };
-                                              updateResponses(newResponses);
-                                            }
+                                            console.log(`更新响应 ${item.id} 的名称:`, e.target.value);
+                                            const currentResponses = getFieldValue('responses') || [];
+                                            const newResponses = currentResponses.map(resp => 
+                                              resp.id === item.id 
+                                                ? { ...resp, name: e.target.value }
+                                                : resp
+                                            );
+                                            console.log('新的响应列表:', newResponses);
+                                            setFieldsValue({ responses: newResponses });
                                           }}
                                           style={{ width: '100%' }}
                                         />
@@ -1304,14 +1350,15 @@ const InterfaceManagement = () => {
                                         placeholder="响应描述（可选）" 
                                         value={item.description || ''}
                                         onChange={(e) => {
-                                          const newResponses = [...responses];
-                                          if (newResponses[index]) {
-                                            newResponses[index] = {
-                                              ...newResponses[index],
-                                              description: e.target.value
-                                            };
-                                            updateResponses(newResponses);
-                                          }
+                                          console.log(`更新响应 ${item.id} 的描述:`, e.target.value);
+                                          const currentResponses = getFieldValue('responses') || [];
+                                          const newResponses = currentResponses.map(resp => 
+                                            resp.id === item.id 
+                                              ? { ...resp, description: e.target.value }
+                                              : resp
+                                          );
+                                          console.log('新的响应列表:', newResponses);
+                                          setFieldsValue({ responses: newResponses });
                                         }}
                                         style={{ marginBottom: 8 }}
                                         rows={2}