refactor: 统一使用ApiResponse替代ResponseEntity，重构6个CRM控制器

backend/src/main/java/com/oms/common/ApiResponse.java

@@ -8,6 +8,10 @@ public class ApiResponse<T> {
     private String message;
     private T data;
 
+    public static <T> ApiResponse<T> success() {
+        return success(null);
+    }
+
     public static <T> ApiResponse<T> success(T data) {
         ApiResponse<T> response = new ApiResponse<>();
         response.setCode(200);
@@ -22,4 +26,16 @@ public class ApiResponse<T> {
         response.setMessage(message);
         return response;
     }
+
+    public static <T> ApiResponse<T> notFound(String message) {
+        return error(404, message);
+    }
+
+    public static <T> ApiResponse<T> badRequest(String message) {
+        return error(400, message);
+    }
+
+    public static <T> ApiResponse<T> serverError(String message) {
+        return error(500, message);
+    }
 }

backend/src/main/java/com/oms/controller/ChatLogController.java

@@ -1,56 +1,60 @@
 package com.oms.controller;
 
+import com.oms.common.ApiResponse;
 import com.oms.dto.ChatLogDTO;
 import com.oms.entity.ChatLog;
 import com.oms.service.ChatLogService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
+import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.*;
+
 import java.util.List;
-import java.util.Map;
 
 @RestController
 @RequestMapping("/crm/chat-logs")
+@RequiredArgsConstructor
 public class ChatLogController {
 
-    @Autowired
-    private ChatLogService chatLogService;
+    private final ChatLogService chatLogService;
 
     @GetMapping
-    public ResponseEntity<Map<String, List<?>>> getChatLogs(
+    public ApiResponse<List<ChatLog>> getChatLogs(
             @RequestParam(required = false) String sessionId,
             @RequestParam(required = false) String status) {
-        List<ChatLog> items = chatLogService.listChatLogs(sessionId, status);
-        return ResponseEntity.ok(Map.of("items", items));
+        return ApiResponse.success(chatLogService.listChatLogs(sessionId, status));
     }
 
     @GetMapping("/{id}")
-    public ResponseEntity<ChatLog> getChatLog(@PathVariable Long id) {
+    public ApiResponse<ChatLog> getChatLog(@PathVariable Long id) {
         ChatLog log = chatLogService.getChatLog(id);
-        return log != null ? ResponseEntity.ok(log) : ResponseEntity.notFound().build();
+        if (log == null) {
+            return ApiResponse.notFound("聊天记录不存在");
+        }
+        return ApiResponse.success(log);
     }
 
     @PostMapping
-    public ResponseEntity<ChatLog> createChatLog(@RequestBody ChatLogDTO dto) {
-        ChatLog log = chatLogService.createChatLog(dto);
-        return ResponseEntity.ok(log);
+    public ApiResponse<ChatLog> createChatLog(@RequestBody ChatLogDTO dto) {
+        return ApiResponse.success(chatLogService.createChatLog(dto));
     }
 
     @PutMapping("/{id}")
-    public ResponseEntity<ChatLog> updateChatLog(@PathVariable Long id, @RequestBody ChatLogDTO dto) {
+    public ApiResponse<ChatLog> updateChatLog(@PathVariable Long id, @RequestBody ChatLogDTO dto) {
         ChatLog log = chatLogService.updateChatLog(id, dto);
-        return log != null ? ResponseEntity.ok(log) : ResponseEntity.notFound().build();
+        if (log == null) {
+            return ApiResponse.notFound("聊天记录不存在");
+        }
+        return ApiResponse.success(log);
     }
 
     @PostMapping("/{id}/mark")
-    public ResponseEntity<Map<String, Object>> markChatLog(@PathVariable Long id, @RequestBody Map<String, String> body) {
-        ChatLog log = chatLogService.markChatLog(id, body.get("tag"));
-        return ResponseEntity.ok(Map.of("success", log != null));
+    public ApiResponse<Void> markChatLog(@PathVariable Long id, @RequestBody java.util.Map<String, String> body) {
+        chatLogService.markChatLog(id, body.get("tag"));
+        return ApiResponse.success();
     }
 
     @DeleteMapping("/{id}")
-    public ResponseEntity<Void> deleteChatLog(@PathVariable Long id) {
+    public ApiResponse<Void> deleteChatLog(@PathVariable Long id) {
         chatLogService.deleteChatLog(id);
-        return ResponseEntity.ok().build();
+        return ApiResponse.success();
     }
 }

backend/src/main/java/com/oms/controller/PricingRuleController.java

@@ -1,50 +1,54 @@
 package com.oms.controller;
 
+import com.oms.common.ApiResponse;
 import com.oms.dto.PricingRuleDTO;
 import com.oms.entity.PricingRule;
 import com.oms.service.PricingRuleService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
+import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.*;
+
 import java.util.List;
-import java.util.Map;
 
 @RestController
 @RequestMapping("/pricing-rules")
+@RequiredArgsConstructor
 public class PricingRuleController {
 
-    @Autowired
-    private PricingRuleService pricingRuleService;
+    private final PricingRuleService pricingRuleService;
 
     @GetMapping
-    public ResponseEntity<Map<String, List<?>>> getPricingRules(
+    public ApiResponse<List<PricingRule>> getPricingRules(
             @RequestParam(required = false) String ruleType,
             @RequestParam(required = false) String status) {
-        List<PricingRule> items = pricingRuleService.listRules(ruleType, status);
-        return ResponseEntity.ok(Map.of("items", items));
+        return ApiResponse.success(pricingRuleService.listRules(ruleType, status));
     }
 
     @GetMapping("/{id}")
-    public ResponseEntity<PricingRule> getPricingRule(@PathVariable Long id) {
+    public ApiResponse<PricingRule> getPricingRule(@PathVariable Long id) {
         PricingRule rule = pricingRuleService.getRule(id);
-        return rule != null ? ResponseEntity.ok(rule) : ResponseEntity.notFound().build();
+        if (rule == null) {
+            return ApiResponse.notFound("定价规则不存在");
+        }
+        return ApiResponse.success(rule);
     }
 
     @PostMapping
-    public ResponseEntity<PricingRule> createPricingRule(@RequestBody PricingRuleDTO dto) {
-        PricingRule rule = pricingRuleService.createRule(dto);
-        return ResponseEntity.ok(rule);
+    public ApiResponse<PricingRule> createPricingRule(@RequestBody PricingRuleDTO dto) {
+        return ApiResponse.success(pricingRuleService.createRule(dto));
     }
 
     @PutMapping("/{id}")
-    public ResponseEntity<PricingRule> updatePricingRule(@PathVariable Long id, @RequestBody PricingRuleDTO dto) {
+    public ApiResponse<PricingRule> updatePricingRule(@PathVariable Long id, @RequestBody PricingRuleDTO dto) {
         PricingRule rule = pricingRuleService.updateRule(id, dto);
-        return rule != null ? ResponseEntity.ok(rule) : ResponseEntity.notFound().build();
+        if (rule == null) {
+            return ApiResponse.notFound("定价规则不存在");
+        }
+        return ApiResponse.success(rule);
     }
 
     @DeleteMapping("/{id}")
-    public ResponseEntity<Void> deletePricingRule(@PathVariable Long id) {
+    public ApiResponse<Void> deletePricingRule(@PathVariable Long id) {
         pricingRuleService.deleteRule(id);
-        return ResponseEntity.ok().build();
+        return ApiResponse.success();
     }
 }

backend/src/main/java/com/oms/controller/ReportController.java

@@ -1,56 +1,63 @@
 package com.oms.controller;
 
+import com.oms.common.ApiResponse;
 import com.oms.dto.ReportDTO;
 import com.oms.entity.Report;
 import com.oms.service.ReportService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
+import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.*;
+
 import java.util.List;
-import java.util.Map;
 
 @RestController
 @RequestMapping("/reports")
+@RequiredArgsConstructor
 public class ReportController {
 
-    @Autowired
-    private ReportService reportService;
+    private final ReportService reportService;
 
     @GetMapping
-    public ResponseEntity<Map<String, List<?>>> getReports(
+    public ApiResponse<List<Report>> getReports(
             @RequestParam(required = false) String reportType,
             @RequestParam(required = false) String status) {
-        List<Report> items = reportService.listReports(reportType, status);
-        return ResponseEntity.ok(Map.of("items", items));
+        return ApiResponse.success(reportService.listReports(reportType, status));
     }
 
     @GetMapping("/{id}")
-    public ResponseEntity<Report> getReport(@PathVariable Long id) {
+    public ApiResponse<Report> getReport(@PathVariable Long id) {
         Report report = reportService.getReport(id);
-        return report != null ? ResponseEntity.ok(report) : ResponseEntity.notFound().build();
+        if (report == null) {
+            return ApiResponse.notFound("报表不存在");
+        }
+        return ApiResponse.success(report);
     }
 
     @PostMapping
-    public ResponseEntity<Report> createReport(@RequestBody ReportDTO dto) {
-        Report report = reportService.createReport(dto);
-        return ResponseEntity.ok(report);
+    public ApiResponse<Report> createReport(@RequestBody ReportDTO dto) {
+        return ApiResponse.success(reportService.createReport(dto));
     }
 
     @PutMapping("/{id}")
-    public ResponseEntity<Report> updateReport(@PathVariable Long id, @RequestBody ReportDTO dto) {
+    public ApiResponse<Report> updateReport(@PathVariable Long id, @RequestBody ReportDTO dto) {
         Report report = reportService.updateReport(id, dto);
-        return report != null ? ResponseEntity.ok(report) : ResponseEntity.notFound().build();
+        if (report == null) {
+            return ApiResponse.notFound("报表不存在");
+        }
+        return ApiResponse.success(report);
     }
 
     @DeleteMapping("/{id}")
-    public ResponseEntity<Void> deleteReport(@PathVariable Long id) {
+    public ApiResponse<Void> deleteReport(@PathVariable Long id) {
         reportService.deleteReport(id);
-        return ResponseEntity.ok().build();
+        return ApiResponse.success();
     }
 
     @PostMapping("/{id}/generate")
-    public ResponseEntity<Report> generateReport(@PathVariable Long id) {
+    public ApiResponse<Report> generateReport(@PathVariable Long id) {
         Report report = reportService.generateReport(id);
-        return report != null ? ResponseEntity.ok(report) : ResponseEntity.notFound().build();
+        if (report == null) {
+            return ApiResponse.notFound("报表不存在");
+        }
+        return ApiResponse.success(report);
     }
 }

backend/src/main/java/com/oms/controller/ReportDataController.java

@@ -1,48 +1,52 @@
 package com.oms.controller;
 
+import com.oms.common.ApiResponse;
 import com.oms.dto.ReportDataDTO;
 import com.oms.entity.ReportData;
 import com.oms.service.ReportDataService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
+import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.*;
+
 import java.util.List;
-import java.util.Map;
 
 @RestController
 @RequestMapping("/report-data")
+@RequiredArgsConstructor
 public class ReportDataController {
 
-    @Autowired
-    private ReportDataService reportDataService;
+    private final ReportDataService reportDataService;
 
     @GetMapping
-    public ResponseEntity<Map<String, List<?>>> getReportData(@RequestParam Long reportId) {
-        List<ReportData> items = reportDataService.listByReportId(reportId);
-        return ResponseEntity.ok(Map.of("items", items));
+    public ApiResponse<List<ReportData>> getReportData(@RequestParam Long reportId) {
+        return ApiResponse.success(reportDataService.listByReportId(reportId));
     }
 
     @GetMapping("/{id}")
-    public ResponseEntity<ReportData> getReportDataById(@PathVariable Long id) {
+    public ApiResponse<ReportData> getReportDataById(@PathVariable Long id) {
         ReportData data = reportDataService.getReportData(id);
-        return data != null ? ResponseEntity.ok(data) : ResponseEntity.notFound().build();
+        if (data == null) {
+            return ApiResponse.notFound("报表数据不存在");
+        }
+        return ApiResponse.success(data);
     }
 
     @PostMapping
-    public ResponseEntity<ReportData> createReportData(@RequestBody ReportDataDTO dto) {
-        ReportData data = reportDataService.createReportData(dto);
-        return ResponseEntity.ok(data);
+    public ApiResponse<ReportData> createReportData(@RequestBody ReportDataDTO dto) {
+        return ApiResponse.success(reportDataService.createReportData(dto));
     }
 
     @PutMapping("/{id}")
-    public ResponseEntity<ReportData> updateReportData(@PathVariable Long id, @RequestBody ReportDataDTO dto) {
+    public ApiResponse<ReportData> updateReportData(@PathVariable Long id, @RequestBody ReportDataDTO dto) {
         ReportData data = reportDataService.updateReportData(id, dto);
-        return data != null ? ResponseEntity.ok(data) : ResponseEntity.notFound().build();
+        if (data == null) {
+            return ApiResponse.notFound("报表数据不存在");
+        }
+        return ApiResponse.success(data);
     }
 
     @DeleteMapping("/{id}")
-    public ResponseEntity<Void> deleteReportData(@PathVariable Long id) {
+    public ApiResponse<Void> deleteReportData(@PathVariable Long id) {
         reportDataService.deleteReportData(id);
-        return ResponseEntity.ok().build();
+        return ApiResponse.success();
     }
 }

backend/src/main/java/com/oms/controller/SatisfactionController.java

@@ -1,55 +1,58 @@
 package com.oms.controller;
 
+import com.oms.common.ApiResponse;
 import com.oms.dto.SatisfactionDTO;
 import com.oms.entity.Satisfaction;
 import com.oms.service.SatisfactionService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
+import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.*;
+
 import java.util.List;
-import java.util.Map;
 
 @RestController
 @RequestMapping("/crm/satisfactions")
+@RequiredArgsConstructor
 public class SatisfactionController {
 
-    @Autowired
-    private SatisfactionService satisfactionService;
+    private final SatisfactionService satisfactionService;
 
     @GetMapping
-    public ResponseEntity<Map<String, List<?>>> getSatisfactions(
+    public ApiResponse<List<Satisfaction>> getSatisfactions(
             @RequestParam(required = false) String rating) {
-        List<Satisfaction> items = satisfactionService.listSatisfactions(rating);
-        return ResponseEntity.ok(Map.of("items", items));
+        return ApiResponse.success(satisfactionService.listSatisfactions(rating));
     }
 
     @GetMapping("/{id}")
-    public ResponseEntity<Satisfaction> getSatisfaction(@PathVariable Long id) {
+    public ApiResponse<Satisfaction> getSatisfaction(@PathVariable Long id) {
         Satisfaction sat = satisfactionService.getSatisfaction(id);
-        return sat != null ? ResponseEntity.ok(sat) : ResponseEntity.notFound().build();
+        if (sat == null) {
+            return ApiResponse.notFound("满意度评价不存在");
+        }
+        return ApiResponse.success(sat);
     }
 
     @PostMapping
-    public ResponseEntity<Satisfaction> createSatisfaction(@RequestBody SatisfactionDTO dto) {
-        Satisfaction sat = satisfactionService.createSatisfaction(dto);
-        return ResponseEntity.ok(sat);
+    public ApiResponse<Satisfaction> createSatisfaction(@RequestBody SatisfactionDTO dto) {
+        return ApiResponse.success(satisfactionService.createSatisfaction(dto));
     }
 
     @PutMapping("/{id}")
-    public ResponseEntity<Satisfaction> updateSatisfaction(@PathVariable Long id, @RequestBody SatisfactionDTO dto) {
+    public ApiResponse<Satisfaction> updateSatisfaction(@PathVariable Long id, @RequestBody SatisfactionDTO dto) {
         Satisfaction sat = satisfactionService.updateSatisfaction(id, dto);
-        return sat != null ? ResponseEntity.ok(sat) : ResponseEntity.notFound().build();
+        if (sat == null) {
+            return ApiResponse.notFound("满意度评价不存在");
+        }
+        return ApiResponse.success(sat);
     }
 
     @DeleteMapping("/{id}")
-    public ResponseEntity<Void> deleteSatisfaction(@PathVariable Long id) {
+    public ApiResponse<Void> deleteSatisfaction(@PathVariable Long id) {
         satisfactionService.deleteSatisfaction(id);
-        return ResponseEntity.ok().build();
+        return ApiResponse.success();
     }
 
     @GetMapping("/average-score")
-    public ResponseEntity<Map<String, Double>> getAverageScore() {
-        Double avg = satisfactionService.getAverageScore();
-        return ResponseEntity.ok(Map.of("averageScore", avg));
+    public ApiResponse<Double> getAverageScore() {
+        return ApiResponse.success(satisfactionService.getAverageScore());
     }
 }

backend/src/main/java/com/oms/controller/SupplyCapabilityController.java

@@ -26,6 +26,11 @@ public class SupplyCapabilityController {
         return ApiResponse.success(supplyCapabilityService.getBySkuId(skuId));
     }
 
+    @GetMapping("/capabilities")
+    public ApiResponse<List<SupplyCapability>> getAll() {
+        return ApiResponse.success(supplyCapabilityService.getAll());
+    }
+
     @GetMapping("/capability/{id}")
     public ApiResponse<SupplyCapabilityDTO> getById(@PathVariable Long id) {
         return ApiResponse.success(supplyCapabilityService.getDtoById(id));

backend/src/main/java/com/oms/controller/TicketController.java

@@ -1,64 +1,75 @@
 package com.oms.controller;
 
+import com.oms.common.ApiResponse;
 import com.oms.dto.TicketDTO;
 import com.oms.entity.Ticket;
 import com.oms.service.TicketService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
+import lombok.RequiredArgsConstructor;
 import org.springframework.web.bind.annotation.*;
+
 import java.util.List;
 import java.util.Map;
 
 @RestController
 @RequestMapping("/crm/tickets")
+@RequiredArgsConstructor
 public class TicketController {
 
-    @Autowired
-    private TicketService ticketService;
+    private final TicketService ticketService;
 
     @GetMapping
-    public ResponseEntity<Map<String, List<?>>> getTickets(
+    public ApiResponse<List<Ticket>> getTickets(
             @RequestParam(required = false) String status,
             @RequestParam(required = false) String priority) {
-        List<Ticket> items = ticketService.listTickets(status, priority);
-        return ResponseEntity.ok(Map.of("items", items));
+        return ApiResponse.success(ticketService.listTickets(status, priority));
     }
 
     @GetMapping("/{id}")
-    public ResponseEntity<Ticket> getTicket(@PathVariable Long id) {
+    public ApiResponse<Ticket> getTicket(@PathVariable Long id) {
         Ticket ticket = ticketService.getTicket(id);
-        return ticket != null ? ResponseEntity.ok(ticket) : ResponseEntity.notFound().build();
+        if (ticket == null) {
+            return ApiResponse.notFound("工单不存在");
+        }
+        return ApiResponse.success(ticket);
     }
 
     @PostMapping
-    public ResponseEntity<Ticket> createTicket(@RequestBody TicketDTO dto) {
-        Ticket ticket = ticketService.createTicket(dto);
-        return ResponseEntity.ok(ticket);
+    public ApiResponse<Ticket> createTicket(@RequestBody TicketDTO dto) {
+        return ApiResponse.success(ticketService.createTicket(dto));
     }
 
     @PutMapping("/{id}")
-    public ResponseEntity<Ticket> updateTicket(@PathVariable Long id, @RequestBody TicketDTO dto) {
+    public ApiResponse<Ticket> updateTicket(@PathVariable Long id, @RequestBody TicketDTO dto) {
         Ticket ticket = ticketService.updateTicket(id, dto);
-        return ticket != null ? ResponseEntity.ok(ticket) : ResponseEntity.notFound().build();
+        if (ticket == null) {
+            return ApiResponse.notFound("工单不存在");
+        }
+        return ApiResponse.success(ticket);
     }
 
     @PostMapping("/{id}/assign")
-    public ResponseEntity<Ticket> assignTicket(@PathVariable Long id, @RequestBody Map<String, Object> body) {
+    public ApiResponse<Ticket> assignTicket(@PathVariable Long id, @RequestBody Map<String, Object> body) {
         Long assignedTo = Long.valueOf(body.get("assignedTo").toString());
         String assignedName = body.get("assignedName").toString();
         Ticket ticket = ticketService.assignTicket(id, assignedTo, assignedName);
-        return ticket != null ? ResponseEntity.ok(ticket) : ResponseEntity.notFound().build();
+        if (ticket == null) {
+            return ApiResponse.notFound("工单不存在");
+        }
+        return ApiResponse.success(ticket);
     }
 
     @PostMapping("/{id}/resolve")
-    public ResponseEntity<Ticket> resolveTicket(@PathVariable Long id, @RequestBody Map<String, String> body) {
+    public ApiResponse<Ticket> resolveTicket(@PathVariable Long id, @RequestBody Map<String, String> body) {
         Ticket ticket = ticketService.resolveTicket(id, body.get("resolution"));
-        return ticket != null ? ResponseEntity.ok(ticket) : ResponseEntity.notFound().build();
+        if (ticket == null) {
+            return ApiResponse.notFound("工单不存在");
+        }
+        return ApiResponse.success(ticket);
     }
 
     @DeleteMapping("/{id}")
-    public ResponseEntity<Void> deleteTicket(@PathVariable Long id) {
+    public ApiResponse<Void> deleteTicket(@PathVariable Long id) {
         ticketService.deleteTicket(id);
-        return ResponseEntity.ok().build();
+        return ApiResponse.success();
     }
 }