feat(wm-patrol): #77 问题上报与工单联动

wm-patrol/src/main/java/com/water/patrol/controller/IssueController.java

@@ -0,0 +1,196 @@
+package com.water.patrol.controller;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.water.common.core.result.R;
+import com.water.patrol.entity.IssueCategory;
+import com.water.patrol.entity.IssueWorkOrder;
+import com.water.patrol.entity.PatrolIssue;
+import com.water.patrol.entity.dto.*;
+import com.water.patrol.service.IssueReportService;
+import com.water.patrol.service.IssueStatsService;
+import com.water.patrol.service.IssueTrackingService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 问题上报 + 工单联动 REST API
+ */
+@Tag(name = "问题上报与工单联动")
+@RestController
+@RequestMapping("/api/patrol/issue")
+@RequiredArgsConstructor
+public class IssueController {
+
+    private final IssueReportService issueReportService;
+    private final IssueTrackingService issueTrackingService;
+    private final IssueStatsService issueStatsService;
+
+    // ==================== 问题上报 ====================
+
+    @Operation(summary = "上报问题")
+    @PostMapping("/report")
+    public R<PatrolIssue> reportIssue(@RequestBody IssueReportRequest request) {
+        return R.ok(issueReportService.reportIssue(request));
+    }
+
+    @Operation(summary = "获取问题详情(含工单)")
+    @GetMapping("/{issueId}")
+    public R<IssueReportVO> getIssueDetail(@PathVariable Long issueId) {
+        return R.ok(issueReportService.getIssueDetail(issueId));
+    }
+
+    @Operation(summary = "分页查询问题列表")
+    @GetMapping("/page")
+    public R<Page<PatrolIssue>> pageIssues(
+            @RequestParam(defaultValue = "1") int current,
+            @RequestParam(defaultValue = "10") int size,
+            @RequestParam(required = false) String issueType,
+            @RequestParam(required = false) String handleStatus,
+            @RequestParam(required = false) String severity,
+            @RequestParam(required = false) Long categoryId,
+            @RequestParam(required = false) Long executionId) {
+        return R.ok(issueReportService.pageIssues(current, size, issueType, handleStatus,
+                severity, categoryId, executionId));
+    }
+
+    @Operation(summary = "关闭问题")
+    @PutMapping("/{issueId}/close")
+    public R<PatrolIssue> closeIssue(@PathVariable Long issueId,
+                                      @RequestParam(required = false) String remark) {
+        return R.ok(issueReportService.closeIssue(issueId, remark));
+    }
+
+    // ==================== 工单联动 ====================
+
+    @Operation(summary = "创建工单")
+    @PostMapping("/work-order")
+    public R<IssueWorkOrder> createWorkOrder(@RequestBody WorkOrderCreateRequest request) {
+        return R.ok(issueTrackingService.createWorkOrder(request));
+    }
+
+    @Operation(summary = "问题自动生成工单")
+    @PostMapping("/{issueId}/auto-work-order")
+    public R<IssueWorkOrder> autoCreateWorkOrder(@PathVariable Long issueId) {
+        return R.ok(issueTrackingService.autoCreateWorkOrder(issueId));
+    }
+
+    @Operation(summary = "获取工单详情")
+    @GetMapping("/work-order/{workOrderId}")
+    public R<IssueWorkOrder> getWorkOrder(@PathVariable Long workOrderId) {
+        return R.ok(issueTrackingService.getWorkOrder(workOrderId));
+    }
+
+    @Operation(summary = "派单(指派处理人)")
+    @PutMapping("/work-order/{workOrderId}/dispatch")
+    public R<IssueWorkOrder> dispatchWorkOrder(@PathVariable Long workOrderId,
+                                                @RequestParam Long assigneeId,
+                                                @RequestParam String assigneeName) {
+        return R.ok(issueTrackingService.dispatchWorkOrder(workOrderId, assigneeId, assigneeName));
+    }
+
+    @Operation(summary = "更新工单状态")
+    @PutMapping("/work-order/{workOrderId}/status")
+    public R<IssueWorkOrder> updateWorkOrderStatus(@PathVariable Long workOrderId,
+                                                    @RequestParam String status) {
+        return R.ok(issueTrackingService.updateWorkOrderStatus(workOrderId, status));
+    }
+
+    @Operation(summary = "工单完成回执")
+    @PutMapping("/work-order/{workOrderId}/complete")
+    public R<IssueWorkOrder> completeWorkOrder(@PathVariable Long workOrderId,
+                                                @RequestBody WorkOrderCompleteRequest request) {
+        return R.ok(issueTrackingService.completeWorkOrder(workOrderId, request));
+    }
+
+    @Operation(summary = "取消工单")
+    @PutMapping("/work-order/{workOrderId}/cancel")
+    public R<IssueWorkOrder> cancelWorkOrder(@PathVariable Long workOrderId,
+                                              @RequestParam(required = false) String reason) {
+        return R.ok(issueTrackingService.cancelWorkOrder(workOrderId, reason));
+    }
+
+    @Operation(summary = "获取问题的所有工单")
+    @GetMapping("/{issueId}/work-orders")
+    public R<List<IssueWorkOrder>> getWorkOrdersByIssue(@PathVariable Long issueId) {
+        return R.ok(issueTrackingService.getWorkOrdersByIssueId(issueId));
+    }
+
+    @Operation(summary = "分页查询工单列表")
+    @GetMapping("/work-order/page")
+    public R<Page<IssueWorkOrder>> pageWorkOrders(
+            @RequestParam(defaultValue = "1") int current,
+            @RequestParam(defaultValue = "10") int size,
+            @RequestParam(required = false) String status,
+            @RequestParam(required = false) Long assigneeId) {
+        return R.ok(issueTrackingService.pageWorkOrders(current, size, status, assigneeId));
+    }
+
+    // ==================== 分类管理 ====================
+
+    @Operation(summary = "获取分类树")
+    @GetMapping("/category/tree")
+    public R<List<IssueCategory>> getCategoryTree() {
+        return R.ok(issueReportService.getCategoryTree());
+    }
+
+    @Operation(summary = "获取子分类")
+    @GetMapping("/category/{parentId}/children")
+    public R<List<IssueCategory>> getSubCategories(@PathVariable Long parentId) {
+        return R.ok(issueReportService.getSubCategories(parentId));
+    }
+
+    @Operation(summary = "创建分类")
+    @PostMapping("/category")
+    public R<IssueCategory> createCategory(@RequestBody IssueCategory category) {
+        return R.ok(issueReportService.createCategory(category));
+    }
+
+    @Operation(summary = "更新分类")
+    @PutMapping("/category/{id}")
+    public R<String> updateCategory(@PathVariable Long id, @RequestBody IssueCategory category) {
+        return issueReportService.updateCategory(id, category) ? R.ok("更新成功") : R.fail("更新失败");
+    }
+
+    @Operation(summary = "删除分类")
+    @DeleteMapping("/category/{id}")
+    public R<String> deleteCategory(@PathVariable Long id) {
+        return issueReportService.deleteCategory(id) ? R.ok("删除成功") : R.fail("删除失败");
+    }
+
+    // ==================== 统计分析 ====================
+
+    @Operation(summary = "问题分类分布")
+    @GetMapping("/stats/category-distribution")
+    public R<List<Map<String, Object>>> getCategoryDistribution(
+            @RequestParam(required = false) String startDate,
+            @RequestParam(required = false) String endDate) {
+        return R.ok(issueStatsService.getCategoryDistribution(startDate, endDate));
+    }
+
+    @Operation(summary = "问题趋势(按日)")
+    @GetMapping("/stats/trend")
+    public R<List<Map<String, Object>>> getDailyTrend(
+            @RequestParam String startDate,
+            @RequestParam String endDate) {
+        return R.ok(issueStatsService.getDailyTrend(startDate, endDate));
+    }
+
+    @Operation(summary = "严重程度分布")
+    @GetMapping("/stats/severity-distribution")
+    public R<List<Map<String, Object>>> getSeverityDistribution() {
+        return R.ok(issueStatsService.getSeverityDistribution());
+    }
+
+    @Operation(summary = "综合统计看板")
+    @GetMapping("/stats/dashboard")
+    public R<Map<String, Object>> getDashboard(
+            @RequestParam(required = false) String startDate,
+            @RequestParam(required = false) String endDate) {
+        return R.ok(issueStatsService.getDashboard(startDate, endDate));
+    }
+}

wm-patrol/src/main/java/com/water/patrol/entity/IssueCategory.java

@@ -0,0 +1,47 @@
+package com.water.patrol.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.water.common.core.entity.BaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+@TableName("issue_category")
+public class IssueCategory extends BaseEntity {
+
+    /**
+     * 分类名称
+     */
+    private String name;
+
+    /**
+     * 分类编码
+     */
+    private String code;
+
+    /**
+     * 父分类ID (0=顶级分类)
+     */
+    private Long parentId;
+
+    /**
+     * 图标标识
+     */
+    private String icon;
+
+    /**
+     * 分类描述
+     */
+    private String description;
+
+    /**
+     * 排序号
+     */
+    private Integer sort;
+
+    /**
+     * 状态: 1=启用 0=停用
+     */
+    private Integer status;
+}

wm-patrol/src/main/java/com/water/patrol/entity/IssueWorkOrder.java

@@ -0,0 +1,84 @@
+package com.water.patrol.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import com.water.common.core.entity.BaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.time.LocalDateTime;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+@TableName("issue_work_order")
+public class IssueWorkOrder extends BaseEntity {
+
+    /**
+     * 关联问题ID
+     */
+    private Long issueId;
+
+    /**
+     * 工单编号
+     */
+    private String orderNo;
+
+    /**
+     * 工单标题
+     */
+    private String title;
+
+    /**
+     * 工单描述
+     */
+    private String description;
+
+    /**
+     * 问题分类ID
+     */
+    private Long categoryId;
+
+    /**
+     * 优先级: low/medium/high/urgent
+     */
+    private String priority;
+
+    /**
+     * 工单状态: pending/dispatched/in_progress/completed/cancelled
+     */
+    private String status;
+
+    /**
+     * 处理人ID
+     */
+    private Long assigneeId;
+
+    /**
+     * 处理人姓名
+     */
+    private String assigneeName;
+
+    /**
+     * 期望完成时间
+     */
+    private LocalDateTime expectedCompleteTime;
+
+    /**
+     * 实际完成时间
+     */
+    private LocalDateTime actualCompleteTime;
+
+    /**
+     * 处理结果
+     */
+    private String result;
+
+    /**
+     * 处理结果照片(JSON数组)
+     */
+    private String resultPhotos;
+
+    /**
+     * 备注
+     */
+    private String remark;
+}

wm-patrol/src/main/java/com/water/patrol/entity/PatrolIssue.java

@@ -81,4 +81,29 @@ public class PatrolIssue extends BaseEntity {
      * 上报时间
      */
     private LocalDateTime reportTime;
+
+    /**
+     * 问题分类ID
+     */
+    private Long categoryId;
+
+    /**
+     * 处理备注
+     */
+    private String handleRemark;
+
+    /**
+     * 处理完成时间
+     */
+    private LocalDateTime handleTime;
+
+    /**
+     * 处理人ID
+     */
+    private Long handlerId;
+
+    /**
+     * 处理人姓名
+     */
+    private String handlerName;
 }

wm-patrol/src/main/java/com/water/patrol/entity/dto/IssueReportRequest.java

@@ -0,0 +1,62 @@
+package com.water.patrol.entity.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 问题上报请求 DTO
+ */
+@Data
+public class IssueReportRequest {
+
+    /**
+     * 关联执行ID
+     */
+    private Long executionId;
+
+    /**
+     * 关联检查项记录ID(可选)
+     */
+    private Long checkRecordId;
+
+    /**
+     * 问题分类ID
+     */
+    private Long categoryId;
+
+    /**
+     * 问题类型: leak/damage/pollution/illegal/other
+     */
+    private String issueType;
+
+    /**
+     * 严重程度: low/medium/high/critical
+     */
+    private String severity;
+
+    /**
+     * 问题描述
+     */
+    private String description;
+
+    /**
+     * 照片URL列表
+     */
+    private List<String> photoUrls;
+
+    /**
+     * 经度
+     */
+    private Double lng;
+
+    /**
+     * 纬度
+     */
+    private Double lat;
+
+    /**
+     * 地址描述
+     */
+    private String address;
+}

wm-patrol/src/main/java/com/water/patrol/entity/dto/IssueReportVO.java

@@ -0,0 +1,42 @@
+package com.water.patrol.entity.dto;
+
+import com.water.patrol.entity.IssueWorkOrder;
+import com.water.patrol.entity.PatrolIssue;
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 问题上报详情 VO (包含工单联动信息)
+ */
+@Data
+public class IssueReportVO {
+
+    /**
+     * 问题信息
+     */
+    private PatrolIssue issue;
+
+    /**
+     * 分类名称
+     */
+    private String categoryName;
+
+    /**
+     * 关联工单
+     */
+    private IssueWorkOrder workOrder;
+
+    /**
+     * 处理进度时间线
+     */
+    private List<IssueTimelineItem> timeline;
+
+    @Data
+    public static class IssueTimelineItem {
+        private String time;
+        private String action;
+        private String operator;
+        private String remark;
+    }
+}

wm-patrol/src/main/java/com/water/patrol/entity/dto/PatrolIssueRequest.java

@@ -12,6 +12,11 @@ public class PatrolIssueRequest {
      */
     private Long checkRecordId;
 
+    /**
+     * 问题分类ID
+     */
+    private Long categoryId;
+
     /**
      * 问题类型: leak/damage/pollution/illegal/other
      */

wm-patrol/src/main/java/com/water/patrol/entity/dto/WorkOrderCompleteRequest.java

@@ -0,0 +1,27 @@
+package com.water.patrol.entity.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 工单完成回执请求 DTO
+ */
+@Data
+public class WorkOrderCompleteRequest {
+
+    /**
+     * 处理结果描述
+     */
+    private String result;
+
+    /**
+     * 处理结果照片URL列表
+     */
+    private List<String> resultPhotos;
+
+    /**
+     * 备注
+     */
+    private String remark;
+}

wm-patrol/src/main/java/com/water/patrol/entity/dto/WorkOrderCreateRequest.java

@@ -0,0 +1,52 @@
+package com.water.patrol.entity.dto;
+
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 工单创建请求 DTO
+ */
+@Data
+public class WorkOrderCreateRequest {
+
+    /**
+     * 关联问题ID
+     */
+    private Long issueId;
+
+    /**
+     * 工单标题
+     */
+    private String title;
+
+    /**
+     * 工单描述
+     */
+    private String description;
+
+    /**
+     * 优先级: low/medium/high/urgent
+     */
+    private String priority;
+
+    /**
+     * 处理人ID
+     */
+    private Long assigneeId;
+
+    /**
+     * 处理人姓名
+     */
+    private String assigneeName;
+
+    /**
+     * 期望完成时间
+     */
+    private LocalDateTime expectedCompleteTime;
+
+    /**
+     * 备注
+     */
+    private String remark;
+}

wm-patrol/src/main/java/com/water/patrol/mapper/IssueCategoryMapper.java

@@ -0,0 +1,19 @@
+package com.water.patrol.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.patrol.entity.IssueCategory;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+import java.util.List;
+
+@Mapper
+public interface IssueCategoryMapper extends BaseMapper<IssueCategory> {
+
+    @Select("SELECT * FROM issue_category WHERE parent_id = #{parentId} AND deleted = 0 ORDER BY sort ASC")
+    List<IssueCategory> selectByParentId(@Param("parentId") Long parentId);
+
+    @Select("SELECT * FROM issue_category WHERE deleted = 0 ORDER BY sort ASC")
+    List<IssueCategory> selectAllActive();
+}

wm-patrol/src/main/java/com/water/patrol/mapper/IssueWorkOrderMapper.java

@@ -0,0 +1,25 @@
+package com.water.patrol.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.patrol.entity.IssueWorkOrder;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+import java.util.List;
+import java.util.Map;
+
+@Mapper
+public interface IssueWorkOrderMapper extends BaseMapper<IssueWorkOrder> {
+
+    @Select("SELECT * FROM issue_work_order WHERE issue_id = #{issueId} AND deleted = 0 ORDER BY created_at DESC")
+    List<IssueWorkOrder> selectByIssueId(@Param("issueId") Long issueId);
+
+    @Select("SELECT status, COUNT(*) as count FROM issue_work_order " +
+            "WHERE deleted = 0 GROUP BY status")
+    List<Map<String, Object>> selectStatusDistribution();
+
+    @Select("SELECT COUNT(*) FROM issue_work_order WHERE assignee_id = #{assigneeId} " +
+            "AND status IN ('pending', 'dispatched', 'in_progress') AND deleted = 0")
+    int countActiveByAssignee(@Param("assigneeId") Long assigneeId);
+}

wm-patrol/src/main/java/com/water/patrol/mapper/PatrolIssueMapper.java

@@ -15,4 +15,27 @@ public interface PatrolIssueMapper extends BaseMapper<PatrolIssue> {
     @Select("SELECT issue_type, severity, COUNT(*) as count FROM patrol_issue " +
             "WHERE execution_id = #{executionId} AND deleted = 0 GROUP BY issue_type, severity")
     List<Map<String, Object>> selectIssueSummary(@Param("executionId") Long executionId);
+
+    @Select("SELECT COALESCE(c.name, '未分类') as category, COUNT(*) as count " +
+            "FROM patrol_issue i LEFT JOIN issue_category c ON i.category_id = c.id " +
+            "WHERE i.deleted = 0 AND i.report_time >= #{startDate} AND i.report_time <= #{endDate} " +
+            "GROUP BY c.name ORDER BY count DESC")
+    List<Map<String, Object>> selectCategoryDistribution(@Param("startDate") String startDate,
+                                                          @Param("endDate") String endDate);
+
+    @Select("SELECT COALESCE(c.name, '未分类') as category, COUNT(*) as count " +
+            "FROM patrol_issue i LEFT JOIN issue_category c ON i.category_id = c.id " +
+            "WHERE i.deleted = 0 GROUP BY c.name ORDER BY count DESC")
+    List<Map<String, Object>> selectCategoryDistributionAll();
+
+    @Select("SELECT DATE_TRUNC('day', report_time) as date, COUNT(*) as count " +
+            "FROM patrol_issue WHERE deleted = 0 " +
+            "AND report_time >= #{startDate} AND report_time <= #{endDate} " +
+            "GROUP BY DATE_TRUNC('day', report_time) ORDER BY date")
+    List<Map<String, Object>> selectDailyTrend(@Param("startDate") String startDate,
+                                                @Param("endDate") String endDate);
+
+    @Select("SELECT severity, COUNT(*) as count FROM patrol_issue " +
+            "WHERE deleted = 0 GROUP BY severity")
+    List<Map<String, Object>> selectSeverityDistribution();
 }

wm-patrol/src/main/java/com/water/patrol/service/IssueReportService.java

@@ -0,0 +1,247 @@
+package com.water.patrol.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.water.patrol.entity.IssueCategory;
+import com.water.patrol.entity.IssueWorkOrder;
+import com.water.patrol.entity.PatrolExecution;
+import com.water.patrol.entity.PatrolIssue;
+import com.water.patrol.entity.dto.IssueReportRequest;
+import com.water.patrol.entity.dto.IssueReportVO;
+import com.water.patrol.mapper.IssueCategoryMapper;
+import com.water.patrol.mapper.IssueWorkOrderMapper;
+import com.water.patrol.mapper.PatrolIssueMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class IssueReportService {
+
+    private final PatrolIssueMapper issueMapper;
+    private final IssueCategoryMapper categoryMapper;
+    private final IssueWorkOrderMapper workOrderMapper;
+    private final ExecutionService executionService;
+
+    /**
+     * 上报问题(增强版，支持分类)
+     */
+    @Transactional
+    public PatrolIssue reportIssue(IssueReportRequest request) {
+        Long executionId = request.getExecutionId();
+        if (executionId == null) {
+            throw new RuntimeException("执行ID不能为空");
+        }
+
+        PatrolExecution execution = executionService.getExecution(executionId);
+        if (!"in_progress".equals(execution.getStatus())) {
+            throw new RuntimeException("巡检执行不在进行中状态，无法上报问题");
+        }
+
+        PatrolIssue issue = new PatrolIssue();
+        issue.setExecutionId(executionId);
+        issue.setCheckRecordId(request.getCheckRecordId());
+        issue.setCategoryId(request.getCategoryId());
+        issue.setIssueType(request.getIssueType());
+        issue.setSeverity(request.getSeverity());
+        issue.setDescription(request.getDescription());
+        issue.setLng(request.getLng());
+        issue.setLat(request.getLat());
+        issue.setAddress(request.getAddress());
+        issue.setHandleStatus("pending");
+        issue.setReporterId(execution.getInspectorId());
+        issue.setReporterName(execution.getInspectorName());
+        issue.setReportTime(LocalDateTime.now());
+
+        if (request.getPhotoUrls() != null && !request.getPhotoUrls().isEmpty()) {
+            issue.setPhotoUrls(String.join(",", request.getPhotoUrls()));
+        }
+
+        issueMapper.insert(issue);
+        executionService.incrementIssueCount(executionId);
+
+        log.info("Issue reported: executionId={}, type={}, severity={}, categoryId={}",
+                executionId, request.getIssueType(), request.getSeverity(), request.getCategoryId());
+        return issue;
+    }
+
+    /**
+     * 获取问题详情(含工单信息)
+     */
+    public IssueReportVO getIssueDetail(Long issueId) {
+        PatrolIssue issue = issueMapper.selectById(issueId);
+        if (issue == null) {
+            throw new RuntimeException("问题不存在: " + issueId);
+        }
+
+        IssueReportVO vo = new IssueReportVO();
+        vo.setIssue(issue);
+
+        // 填充分类名称
+        if (issue.getCategoryId() != null) {
+            IssueCategory category = categoryMapper.selectById(issue.getCategoryId());
+            if (category != null) {
+                vo.setCategoryName(category.getName());
+            }
+        }
+
+        // 填充关联工单
+        List<IssueWorkOrder> workOrders = workOrderMapper.selectByIssueId(issueId);
+        if (!workOrders.isEmpty()) {
+            vo.setWorkOrder(workOrders.get(0)); // 取最新的工单
+        }
+
+        // 构建时间线
+        vo.setTimeline(buildTimeline(issue, workOrders));
+
+        return vo;
+    }
+
+    /**
+     * 分页查询问题列表
+     */
+    public Page<PatrolIssue> pageIssues(int current, int size, String issueType,
+                                         String handleStatus, String severity,
+                                         Long categoryId, Long executionId) {
+        LambdaQueryWrapper<PatrolIssue> wrapper = new LambdaQueryWrapper<>();
+        if (issueType != null && !issueType.isEmpty()) {
+            wrapper.eq(PatrolIssue::getIssueType, issueType);
+        }
+        if (handleStatus != null && !handleStatus.isEmpty()) {
+            wrapper.eq(PatrolIssue::getHandleStatus, handleStatus);
+        }
+        if (severity != null && !severity.isEmpty()) {
+            wrapper.eq(PatrolIssue::getSeverity, severity);
+        }
+        if (categoryId != null) {
+            wrapper.eq(PatrolIssue::getCategoryId, categoryId);
+        }
+        if (executionId != null) {
+            wrapper.eq(PatrolIssue::getExecutionId, executionId);
+        }
+        wrapper.orderByDesc(PatrolIssue::getReportTime);
+        return issueMapper.selectPage(new Page<>(current, size), wrapper);
+    }
+
+    /**
+     * 关闭问题
+     */
+    @Transactional
+    public PatrolIssue closeIssue(Long issueId, String remark) {
+        PatrolIssue issue = issueMapper.selectById(issueId);
+        if (issue == null) {
+            throw new RuntimeException("问题不存在: " + issueId);
+        }
+        issue.setHandleStatus("closed");
+        issue.setHandleRemark(remark);
+        issue.setHandleTime(LocalDateTime.now());
+        issueMapper.updateById(issue);
+        log.info("Issue closed: id={}, remark={}", issueId, remark);
+        return issue;
+    }
+
+    // ==================== 分类管理 ====================
+
+    /**
+     * 获取分类树
+     */
+    public List<IssueCategory> getCategoryTree() {
+        return categoryMapper.selectAllActive();
+    }
+
+    /**
+     * 获取子分类
+     */
+    public List<IssueCategory> getSubCategories(Long parentId) {
+        return categoryMapper.selectByParentId(parentId);
+    }
+
+    /**
+     * 创建分类
+     */
+    public IssueCategory createCategory(IssueCategory category) {
+        categoryMapper.insert(category);
+        log.info("Issue category created: name={}, code={}", category.getName(), category.getCode());
+        return category;
+    }
+
+    /**
+     * 更新分类
+     */
+    public boolean updateCategory(Long id, IssueCategory category) {
+        category.setId(id);
+        return categoryMapper.updateById(category) > 0;
+    }
+
+    /**
+     * 删除分类(逻辑删除)
+     */
+    public boolean deleteCategory(Long id) {
+        return categoryMapper.deleteById(id) > 0;
+    }
+
+    // ==================== 内部方法 ====================
+
+    private List<IssueReportVO.IssueTimelineItem> buildTimeline(PatrolIssue issue, List<IssueWorkOrder> workOrders) {
+        List<IssueReportVO.IssueTimelineItem> timeline = new ArrayList<>();
+
+        // 上报
+        IssueReportVO.IssueTimelineItem reportItem = new IssueReportVO.IssueTimelineItem();
+        reportItem.setTime(issue.getReportTime() != null ? issue.getReportTime().toString() : "");
+        reportItem.setAction("上报问题");
+        reportItem.setOperator(issue.getReporterName());
+        reportItem.setRemark(issue.getDescription());
+        timeline.add(reportItem);
+
+        // 工单创建
+        if (!workOrders.isEmpty()) {
+            IssueWorkOrder wo = workOrders.get(0);
+
+            IssueReportVO.IssueTimelineItem createItem = new IssueReportVO.IssueTimelineItem();
+            createItem.setTime(wo.getCreatedAt() != null ? wo.getCreatedAt().toString() : "");
+            createItem.setAction("创建工单");
+            createItem.setOperator("系统");
+            createItem.setRemark("工单编号: " + wo.getOrderNo());
+            timeline.add(createItem);
+
+            // 派单
+            if (wo.getAssigneeName() != null && !"pending".equals(wo.getStatus())) {
+                IssueReportVO.IssueTimelineItem dispatchItem = new IssueReportVO.IssueTimelineItem();
+                dispatchItem.setTime(wo.getCreatedAt() != null ? wo.getCreatedAt().toString() : "");
+                dispatchItem.setAction("派单");
+                dispatchItem.setOperator("系统");
+                dispatchItem.setRemark("处理人: " + wo.getAssigneeName());
+                timeline.add(dispatchItem);
+            }
+
+            // 完成
+            if ("completed".equals(wo.getStatus()) && wo.getActualCompleteTime() != null) {
+                IssueReportVO.IssueTimelineItem completeItem = new IssueReportVO.IssueTimelineItem();
+                completeItem.setTime(wo.getActualCompleteTime().toString());
+                completeItem.setAction("工单完成");
+                completeItem.setOperator(wo.getAssigneeName());
+                completeItem.setRemark(wo.getResult());
+                timeline.add(completeItem);
+            }
+        }
+
+        // 问题关闭
+        if ("closed".equals(issue.getHandleStatus()) && issue.getHandleTime() != null) {
+            IssueReportVO.IssueTimelineItem closeItem = new IssueReportVO.IssueTimelineItem();
+            closeItem.setTime(issue.getHandleTime().toString());
+            closeItem.setAction("关闭问题");
+            closeItem.setOperator(issue.getHandlerName());
+            closeItem.setRemark(issue.getHandleRemark());
+            timeline.add(closeItem);
+        }
+
+        return timeline;
+    }
+}

wm-patrol/src/main/java/com/water/patrol/service/IssueService.java

@@ -36,6 +36,7 @@ public class IssueService {
         PatrolIssue issue = new PatrolIssue();
         issue.setExecutionId(executionId);
         issue.setCheckRecordId(request.getCheckRecordId());
+        issue.setCategoryId(request.getCategoryId());
         issue.setIssueType(request.getIssueType());
         issue.setSeverity(request.getSeverity());
         issue.setDescription(request.getDescription());

wm-patrol/src/main/java/com/water/patrol/service/IssueStatsService.java

@@ -0,0 +1,63 @@
+package com.water.patrol.service;
+
+import com.water.patrol.mapper.IssueWorkOrderMapper;
+import com.water.patrol.mapper.PatrolIssueMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class IssueStatsService {
+
+    private final PatrolIssueMapper issueMapper;
+    private final IssueWorkOrderMapper workOrderMapper;
+
+    /**
+     * 问题分类分布统计
+     */
+    public List<Map<String, Object>> getCategoryDistribution(String startDate, String endDate) {
+        if (startDate != null && endDate != null) {
+            return issueMapper.selectCategoryDistribution(startDate, endDate);
+        }
+        return issueMapper.selectCategoryDistributionAll();
+    }
+
+    /**
+     * 问题趋势(按日)
+     */
+    public List<Map<String, Object>> getDailyTrend(String startDate, String endDate) {
+        return issueMapper.selectDailyTrend(startDate, endDate);
+    }
+
+    /**
+     * 问题严重程度分布
+     */
+    public List<Map<String, Object>> getSeverityDistribution() {
+        return issueMapper.selectSeverityDistribution();
+    }
+
+    /**
+     * 工单状态分布
+     */
+    public List<Map<String, Object>> getWorkOrderStatusDistribution() {
+        return workOrderMapper.selectStatusDistribution();
+    }
+
+    /**
+     * 综合统计看板
+     */
+    public Map<String, Object> getDashboard(String startDate, String endDate) {
+        Map<String, Object> dashboard = new HashMap<>();
+        dashboard.put("categoryDistribution", getCategoryDistribution(startDate, endDate));
+        dashboard.put("dailyTrend", getDailyTrend(startDate, endDate));
+        dashboard.put("severityDistribution", getSeverityDistribution());
+        dashboard.put("workOrderStatusDistribution", getWorkOrderStatusDistribution());
+        return dashboard;
+    }
+}

wm-patrol/src/main/java/com/water/patrol/service/IssueTrackingService.java

@@ -0,0 +1,254 @@
+package com.water.patrol.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.water.patrol.entity.IssueWorkOrder;
+import com.water.patrol.entity.PatrolIssue;
+import com.water.patrol.entity.dto.WorkOrderCompleteRequest;
+import com.water.patrol.entity.dto.WorkOrderCreateRequest;
+import com.water.patrol.mapper.IssueWorkOrderMapper;
+import com.water.patrol.mapper.PatrolIssueMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class IssueTrackingService {
+
+    private final IssueWorkOrderMapper workOrderMapper;
+    private final PatrolIssueMapper issueMapper;
+
+    /**
+     * 问题自动生成工单
+     */
+    @Transactional
+    public IssueWorkOrder createWorkOrder(WorkOrderCreateRequest request) {
+        Long issueId = request.getIssueId();
+        PatrolIssue issue = issueMapper.selectById(issueId);
+        if (issue == null) {
+            throw new RuntimeException("问题不存在: " + issueId);
+        }
+
+        // 检查是否已有活跃工单
+        List<IssueWorkOrder> existingOrders = workOrderMapper.selectByIssueId(issueId);
+        boolean hasActiveOrder = existingOrders.stream()
+                .anyMatch(wo -> !"completed".equals(wo.getStatus()) && !"cancelled".equals(wo.getStatus()));
+        if (hasActiveOrder) {
+            throw new RuntimeException("该问题已有进行中的工单，无法重复创建");
+        }
+
+        IssueWorkOrder workOrder = new IssueWorkOrder();
+        workOrder.setIssueId(issueId);
+        workOrder.setOrderNo(generateOrderNo());
+        workOrder.setTitle(request.getTitle() != null ? request.getTitle() :
+                "巡检问题处理 - " + issue.getIssueType());
+        workOrder.setDescription(request.getDescription() != null ? request.getDescription() :
+                issue.getDescription());
+        workOrder.setCategoryId(issue.getCategoryId());
+        workOrder.setPriority(request.getPriority() != null ? request.getPriority() :
+                mapSeverityToPriority(issue.getSeverity()));
+        workOrder.setStatus("pending");
+        workOrder.setAssigneeId(request.getAssigneeId());
+        workOrder.setAssigneeName(request.getAssigneeName());
+        workOrder.setExpectedCompleteTime(request.getExpectedCompleteTime());
+        workOrder.setRemark(request.getRemark());
+        workOrderMapper.insert(workOrder);
+
+        // 同步问题状态为处理中
+        issue.setHandleStatus("processing");
+        issue.setWorkOrderId(workOrder.getId());
+        issueMapper.updateById(issue);
+
+        log.info("Work order created: orderNo={}, issueId={}, priority={}",
+                workOrder.getOrderNo(), issueId, workOrder.getPriority());
+        return workOrder;
+    }
+
+    /**
+     * 自动根据问题创建工单(问题上报后自动触发)
+     */
+    @Transactional
+    public IssueWorkOrder autoCreateWorkOrder(Long issueId) {
+        PatrolIssue issue = issueMapper.selectById(issueId);
+        if (issue == null) {
+            throw new RuntimeException("问题不存在: " + issueId);
+        }
+
+        WorkOrderCreateRequest request = new WorkOrderCreateRequest();
+        request.setIssueId(issueId);
+        request.setTitle("巡检问题自动工单 - " + issue.getIssueType());
+        request.setDescription(issue.getDescription());
+        request.setPriority(mapSeverityToPriority(issue.getSeverity()));
+        return createWorkOrder(request);
+    }
+
+    /**
+     * 派单(指派处理人)
+     */
+    @Transactional
+    public IssueWorkOrder dispatchWorkOrder(Long workOrderId, Long assigneeId, String assigneeName) {
+        IssueWorkOrder workOrder = getWorkOrder(workOrderId);
+        if (!"pending".equals(workOrder.getStatus())) {
+            throw new RuntimeException("只有待处理工单才能派单");
+        }
+        workOrder.setAssigneeId(assigneeId);
+        workOrder.setAssigneeName(assigneeName);
+        workOrder.setStatus("dispatched");
+        workOrderMapper.updateById(workOrder);
+
+        log.info("Work order dispatched: id={}, assignee={}", workOrderId, assigneeName);
+        return workOrder;
+    }
+
+    /**
+     * 更新工单状态
+     */
+    @Transactional
+    public IssueWorkOrder updateWorkOrderStatus(Long workOrderId, String status) {
+        IssueWorkOrder workOrder = getWorkOrder(workOrderId);
+        workOrder.setStatus(status);
+        workOrderMapper.updateById(workOrder);
+
+        // 同步问题状态
+        syncIssueStatus(workOrder.getIssueId(), status);
+
+        log.info("Work order status updated: id={}, status={}", workOrderId, status);
+        return workOrder;
+    }
+
+    /**
+     * 工单完成回执
+     */
+    @Transactional
+    public IssueWorkOrder completeWorkOrder(Long workOrderId, WorkOrderCompleteRequest request) {
+        IssueWorkOrder workOrder = getWorkOrder(workOrderId);
+        if ("completed".equals(workOrder.getStatus())) {
+            throw new RuntimeException("工单已完成，无需重复操作");
+        }
+        if ("cancelled".equals(workOrder.getStatus())) {
+            throw new RuntimeException("工单已取消，无法完成");
+        }
+
+        workOrder.setStatus("completed");
+        workOrder.setActualCompleteTime(LocalDateTime.now());
+        workOrder.setResult(request.getResult());
+        workOrder.setRemark(request.getRemark());
+
+        if (request.getResultPhotos() != null && !request.getResultPhotos().isEmpty()) {
+            workOrder.setResultPhotos(String.join(",", request.getResultPhotos()));
+        }
+
+        workOrderMapper.updateById(workOrder);
+
+        // 同步问题状态为已解决
+        syncIssueStatus(workOrder.getIssueId(), "completed");
+
+        log.info("Work order completed: id={}, result={}", workOrderId, request.getResult());
+        return workOrder;
+    }
+
+    /**
+     * 取消工单
+     */
+    @Transactional
+    public IssueWorkOrder cancelWorkOrder(Long workOrderId, String reason) {
+        IssueWorkOrder workOrder = getWorkOrder(workOrderId);
+        if ("completed".equals(workOrder.getStatus())) {
+            throw new RuntimeException("已完成的工单无法取消");
+        }
+        workOrder.setStatus("cancelled");
+        workOrder.setRemark(reason);
+        workOrderMapper.updateById(workOrder);
+        log.info("Work order cancelled: id={}, reason={}", workOrderId, reason);
+        return workOrder;
+    }
+
+    /**
+     * 获取工单详情
+     */
+    public IssueWorkOrder getWorkOrder(Long workOrderId) {
+        IssueWorkOrder workOrder = workOrderMapper.selectById(workOrderId);
+        if (workOrder == null) {
+            throw new RuntimeException("工单不存在: " + workOrderId);
+        }
+        return workOrder;
+    }
+
+    /**
+     * 获取问题的所有工单
+     */
+    public List<IssueWorkOrder> getWorkOrdersByIssueId(Long issueId) {
+        return workOrderMapper.selectByIssueId(issueId);
+    }
+
+    /**
+     * 分页查询工单列表
+     */
+    public Page<IssueWorkOrder> pageWorkOrders(int current, int size, String status, Long assigneeId) {
+        LambdaQueryWrapper<IssueWorkOrder> wrapper = new LambdaQueryWrapper<>();
+        if (status != null && !status.isEmpty()) {
+            wrapper.eq(IssueWorkOrder::getStatus, status);
+        }
+        if (assigneeId != null) {
+            wrapper.eq(IssueWorkOrder::getAssigneeId, assigneeId);
+        }
+        wrapper.orderByDesc(IssueWorkOrder::getCreatedAt);
+        return workOrderMapper.selectPage(new Page<>(current, size), wrapper);
+    }
+
+    /**
+     * 获取处理人活跃工单数
+     */
+    public int getActiveWorkOrderCount(Long assigneeId) {
+        return workOrderMapper.countActiveByAssignee(assigneeId);
+    }
+
+    // ==================== 内部方法 ====================
+
+    private String generateOrderNo() {
+        String prefix = "WO";
+        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
+        String random = String.valueOf((int) (Math.random() * 10000));
+        return prefix + timestamp + random;
+    }
+
+    private String mapSeverityToPriority(String severity) {
+        if (severity == null) return "medium";
+        switch (severity) {
+            case "critical": return "urgent";
+            case "high": return "high";
+            case "medium": return "medium";
+            case "low": return "low";
+            default: return "medium";
+        }
+    }
+
+    private void syncIssueStatus(Long issueId, String workOrderStatus) {
+        PatrolIssue issue = issueMapper.selectById(issueId);
+        if (issue == null) return;
+
+        switch (workOrderStatus) {
+            case "dispatched":
+            case "in_progress":
+                issue.setHandleStatus("processing");
+                break;
+            case "completed":
+                issue.setHandleStatus("resolved");
+                issue.setHandleTime(LocalDateTime.now());
+                break;
+            case "cancelled":
+                issue.setHandleStatus("pending");
+                break;
+            default:
+                break;
+        }
+        issueMapper.updateById(issue);
+    }
+}

wm-patrol/src/main/resources/db/V3__patrol_issue.sql

@@ -0,0 +1,71 @@
+-- ============================================================
+-- 问题上报 + 工单联动 DDL (V3)
+-- ============================================================
+
+-- 问题分类表
+CREATE TABLE IF NOT EXISTS issue_category (
+    id          BIGSERIAL PRIMARY KEY,
+    name        VARCHAR(100) NOT NULL,
+    code        VARCHAR(50)  NOT NULL,
+    parent_id   BIGINT       DEFAULT 0,
+    icon        VARCHAR(255),
+    description TEXT,
+    sort        INT          DEFAULT 0,
+    status      INT          DEFAULT 1,        -- 1=启用 0=停用
+    created_at  TIMESTAMP    DEFAULT NOW(),
+    updated_at  TIMESTAMP    DEFAULT NOW(),
+    deleted     INT          DEFAULT 0
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_category_code ON issue_category(code) WHERE deleted = 0;
+
+-- 初始分类数据
+INSERT INTO issue_category (name, code, parent_id, icon, description, sort, status) VALUES
+    ('管道问题', 'PIPE',      0, 'pipe',      '管道相关问题', 1, 1),
+    ('漏水',     'LEAK',      1, 'leak',      '管道漏水/渗水', 1, 1),
+    ('爆管',     'BURST',     1, 'burst',     '管道爆裂', 2, 1),
+    ('堵塞',     'BLOCKAGE',  1, 'blockage',  '管道堵塞', 3, 1),
+    ('设施损坏', 'FACILITY',  0, 'facility',  '设施设备损坏', 2, 1),
+    ('阀门故障', 'VALVE',     5, 'valve',     '阀门损坏或故障', 1, 1),
+    ('水表故障', 'METER',     5, 'meter',     '水表损坏或读数异常', 2, 1),
+    ('环境问题', 'ENV',       0, 'env',       '环境相关问题', 3, 1),
+    ('水质污染', 'POLLUTION', 8, 'pollution', '水质异常或污染', 1, 1),
+    ('违规排放', 'ILLEGAL',   8, 'illegal',   '违规排水/排污', 2, 1),
+    ('其他问题', 'OTHER',     0, 'other',     '其他未分类问题', 99, 1)
+ON CONFLICT DO NOTHING;
+
+-- 工单关联表
+CREATE TABLE IF NOT EXISTS issue_work_order (
+    id                    BIGSERIAL PRIMARY KEY,
+    issue_id              BIGINT       NOT NULL REFERENCES patrol_issue(id),
+    order_no              VARCHAR(50)  NOT NULL,
+    title                 VARCHAR(200) NOT NULL,
+    description           TEXT,
+    category_id           BIGINT,
+    priority              VARCHAR(20)  DEFAULT 'medium',   -- low/medium/high/urgent
+    status                VARCHAR(20)  DEFAULT 'pending',  -- pending/dispatched/in_progress/completed/cancelled
+    assignee_id           BIGINT,
+    assignee_name         VARCHAR(50),
+    expected_complete_time TIMESTAMP,
+    actual_complete_time  TIMESTAMP,
+    result                TEXT,                            -- 处理结果描述
+    result_photos         TEXT,                            -- JSON数组: 处理结果照片
+    remark                TEXT,
+    created_at            TIMESTAMP    DEFAULT NOW(),
+    updated_at            TIMESTAMP    DEFAULT NOW(),
+    deleted               INT          DEFAULT 0
+);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_work_order_no ON issue_work_order(order_no) WHERE deleted = 0;
+CREATE INDEX IF NOT EXISTS idx_work_order_issue ON issue_work_order(issue_id);
+CREATE INDEX IF NOT EXISTS idx_work_order_status ON issue_work_order(status);
+CREATE INDEX IF NOT EXISTS idx_work_order_assignee ON issue_work_order(assignee_id);
+
+-- 给 patrol_issue 表增强字段
+ALTER TABLE patrol_issue ADD COLUMN IF NOT EXISTS category_id    BIGINT;
+ALTER TABLE patrol_issue ADD COLUMN IF NOT EXISTS handle_remark  TEXT;
+ALTER TABLE patrol_issue ADD COLUMN IF NOT EXISTS handle_time    TIMESTAMP;
+ALTER TABLE patrol_issue ADD COLUMN IF NOT EXISTS handler_id     BIGINT;
+ALTER TABLE patrol_issue ADD COLUMN IF NOT EXISTS handler_name   VARCHAR(50);
+
+CREATE INDEX IF NOT EXISTS idx_issue_category ON patrol_issue(category_id);
+CREATE INDEX IF NOT EXISTS idx_issue_report_time ON patrol_issue(report_time);
+CREATE INDEX IF NOT EXISTS idx_issue_reporter ON patrol_issue(reporter_id);

wm-patrol/src/test/java/com/water/patrol/service/IssueReportServiceTest.java

@@ -0,0 +1,181 @@
+package com.water.patrol.service;
+
+import com.water.patrol.entity.IssueCategory;
+import com.water.patrol.entity.IssueWorkOrder;
+import com.water.patrol.entity.PatrolExecution;
+import com.water.patrol.entity.PatrolIssue;
+import com.water.patrol.entity.dto.IssueReportRequest;
+import com.water.patrol.entity.dto.IssueReportVO;
+import com.water.patrol.mapper.IssueCategoryMapper;
+import com.water.patrol.mapper.IssueWorkOrderMapper;
+import com.water.patrol.mapper.PatrolIssueMapper;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class IssueReportServiceTest {
+
+    @Mock
+    private PatrolIssueMapper issueMapper;
+
+    @Mock
+    private IssueCategoryMapper categoryMapper;
+
+    @Mock
+    private IssueWorkOrderMapper workOrderMapper;
+
+    @Mock
+    private ExecutionService executionService;
+
+    @InjectMocks
+    private IssueReportService issueReportService;
+
+    @Test
+    @DisplayName("上报问题 - 带分类的正常上报")
+    void reportIssue_withCategory_success() {
+        PatrolExecution execution = buildInProgressExecution();
+        when(executionService.getExecution(1L)).thenReturn(execution);
+        when(issueMapper.insert(any(PatrolIssue.class))).thenReturn(1);
+
+        IssueReportRequest request = new IssueReportRequest();
+        request.setExecutionId(1L);
+        request.setCategoryId(2L);
+        request.setIssueType("leak");
+        request.setSeverity("high");
+        request.setDescription("发现管道漏水");
+        request.setLng(86.6135);
+        request.setLat(44.8257);
+        request.setAddress("XX路");
+        request.setPhotoUrls(Arrays.asList("http://img.example.com/1.jpg"));
+
+        PatrolIssue result = issueReportService.reportIssue(request);
+
+        assertNotNull(result);
+        assertEquals(2L, result.getCategoryId());
+        assertEquals("leak", result.getIssueType());
+        assertEquals("high", result.getSeverity());
+        assertEquals("pending", result.getHandleStatus());
+        verify(executionService).incrementIssueCount(1L);
+    }
+
+    @Test
+    @DisplayName("上报问题 - 执行ID为空应抛异常")
+    void reportIssue_nullExecutionId_throwsException() {
+        IssueReportRequest request = new IssueReportRequest();
+        request.setIssueType("leak");
+
+        RuntimeException ex = assertThrows(RuntimeException.class,
+                () -> issueReportService.reportIssue(request));
+        assertTrue(ex.getMessage().contains("执行ID不能为空"));
+    }
+
+    @Test
+    @DisplayName("获取问题详情 - 含分类和工单信息")
+    void getIssueDetail_withCategoryAndWorkOrder() {
+        PatrolIssue issue = buildSampleIssue();
+        when(issueMapper.selectById(1L)).thenReturn(issue);
+
+        IssueCategory category = new IssueCategory();
+        category.setId(2L);
+        category.setName("漏水");
+        when(categoryMapper.selectById(2L)).thenReturn(category);
+
+        IssueWorkOrder workOrder = new IssueWorkOrder();
+        workOrder.setId(1L);
+        workOrder.setIssueId(1L);
+        workOrder.setOrderNo("WO202606140001");
+        workOrder.setStatus("in_progress");
+        when(workOrderMapper.selectByIssueId(1L)).thenReturn(Collections.singletonList(workOrder));
+
+        IssueReportVO vo = issueReportService.getIssueDetail(1L);
+
+        assertNotNull(vo);
+        assertEquals(issue, vo.getIssue());
+        assertEquals("漏水", vo.getCategoryName());
+        assertNotNull(vo.getWorkOrder());
+        assertEquals("WO202606140001", vo.getWorkOrder().getOrderNo());
+        assertNotNull(vo.getTimeline());
+        assertTrue(vo.getTimeline().size() >= 2);
+    }
+
+    @Test
+    @DisplayName("关闭问题 - 状态更新为closed")
+    void closeIssue_success() {
+        PatrolIssue issue = buildSampleIssue();
+        issue.setHandleStatus("resolved");
+        when(issueMapper.selectById(1L)).thenReturn(issue);
+        when(issueMapper.updateById(any(PatrolIssue.class))).thenReturn(1);
+
+        PatrolIssue result = issueReportService.closeIssue(1L, "已处理完毕");
+
+        assertEquals("closed", result.getHandleStatus());
+        assertEquals("已处理完毕", result.getHandleRemark());
+        assertNotNull(result.getHandleTime());
+    }
+
+    @Test
+    @DisplayName("获取分类树 - 返回所有启用的分类")
+    void getCategoryTree_success() {
+        IssueCategory cat1 = new IssueCategory();
+        cat1.setId(1L);
+        cat1.setName("管道问题");
+        cat1.setParentId(0L);
+
+        IssueCategory cat2 = new IssueCategory();
+        cat2.setId(2L);
+        cat2.setName("漏水");
+        cat2.setParentId(1L);
+
+        when(categoryMapper.selectAllActive()).thenReturn(Arrays.asList(cat1, cat2));
+
+        List<IssueCategory> tree = issueReportService.getCategoryTree();
+
+        assertNotNull(tree);
+        assertEquals(2, tree.size());
+        assertEquals("管道问题", tree.get(0).getName());
+    }
+
+    private PatrolExecution buildInProgressExecution() {
+        PatrolExecution execution = new PatrolExecution();
+        execution.setId(1L);
+        execution.setTaskId(1L);
+        execution.setInspectorId(100L);
+        execution.setInspectorName("张三");
+        execution.setStatus("in_progress");
+        execution.setStartTime(LocalDateTime.now());
+        execution.setTotalCheckItems(10);
+        execution.setCompletedCheckItems(0);
+        execution.setIssueCount(0);
+        execution.setTotalDistance(BigDecimal.ZERO);
+        return execution;
+    }
+
+    private PatrolIssue buildSampleIssue() {
+        PatrolIssue issue = new PatrolIssue();
+        issue.setId(1L);
+        issue.setExecutionId(1L);
+        issue.setCategoryId(2L);
+        issue.setIssueType("leak");
+        issue.setSeverity("high");
+        issue.setDescription("发现管道漏水");
+        issue.setHandleStatus("processing");
+        issue.setReporterId(100L);
+        issue.setReporterName("张三");
+        issue.setReportTime(LocalDateTime.now());
+        return issue;
+    }
+}

wm-patrol/src/test/java/com/water/patrol/service/IssueStatsServiceTest.java

@@ -0,0 +1,77 @@
+package com.water.patrol.service;
+
+import com.water.patrol.mapper.IssueWorkOrderMapper;
+import com.water.patrol.mapper.PatrolIssueMapper;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class IssueStatsServiceTest {
+
+    @Mock
+    private PatrolIssueMapper issueMapper;
+
+    @Mock
+    private IssueWorkOrderMapper workOrderMapper;
+
+    @InjectMocks
+    private IssueStatsService issueStatsService;
+
+    @Test
+    @DisplayName("分类分布 - 带日期范围")
+    void getCategoryDistribution_withDateRange() {
+        List<Map<String, Object>> mockData = new ArrayList<>();
+        Map<String, Object> item = new HashMap<>();
+        item.put("category", "管道问题");
+        item.put("count", 15L);
+        mockData.add(item);
+
+        when(issueMapper.selectCategoryDistribution("2026-01-01", "2026-06-30"))
+                .thenReturn(mockData);
+
+        List<Map<String, Object>> result = issueStatsService.getCategoryDistribution("2026-01-01", "2026-06-30");
+
+        assertNotNull(result);
+        assertEquals(1, result.size());
+        assertEquals("管道问题", result.get(0).get("category"));
+        assertEquals(15L, result.get(0).get("count"));
+    }
+
+    @Test
+    @DisplayName("分类分布 - 无日期范围查全部")
+    void getCategoryDistribution_withoutDateRange() {
+        List<Map<String, Object>> mockData = new ArrayList<>();
+        when(issueMapper.selectCategoryDistributionAll()).thenReturn(mockData);
+
+        List<Map<String, Object>> result = issueStatsService.getCategoryDistribution(null, null);
+
+        assertNotNull(result);
+        verify(issueMapper).selectCategoryDistributionAll();
+    }
+
+    @Test
+    @DisplayName("综合看板 - 包含所有统计维度")
+    void getDashboard_containsAllDimensions() {
+        when(issueMapper.selectCategoryDistributionAll()).thenReturn(Collections.emptyList());
+        when(issueMapper.selectDailyTrend(anyString(), anyString())).thenReturn(Collections.emptyList());
+        when(issueMapper.selectSeverityDistribution()).thenReturn(Collections.emptyList());
+        when(workOrderMapper.selectStatusDistribution()).thenReturn(Collections.emptyList());
+
+        Map<String, Object> dashboard = issueStatsService.getDashboard(null, null);
+
+        assertNotNull(dashboard);
+        assertTrue(dashboard.containsKey("categoryDistribution"));
+        assertTrue(dashboard.containsKey("dailyTrend"));
+        assertTrue(dashboard.containsKey("severityDistribution"));
+        assertTrue(dashboard.containsKey("workOrderStatusDistribution"));
+    }
+}

wm-patrol/src/test/java/com/water/patrol/service/IssueTrackingServiceTest.java

@@ -0,0 +1,197 @@
+package com.water.patrol.service;
+
+import com.water.patrol.entity.IssueWorkOrder;
+import com.water.patrol.entity.PatrolIssue;
+import com.water.patrol.entity.dto.WorkOrderCompleteRequest;
+import com.water.patrol.entity.dto.WorkOrderCreateRequest;
+import com.water.patrol.mapper.IssueWorkOrderMapper;
+import com.water.patrol.mapper.PatrolIssueMapper;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.time.LocalDateTime;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class IssueTrackingServiceTest {
+
+    @Mock
+    private IssueWorkOrderMapper workOrderMapper;
+
+    @Mock
+    private PatrolIssueMapper issueMapper;
+
+    @InjectMocks
+    private IssueTrackingService issueTrackingService;
+
+    @Test
+    @DisplayName("创建工单 - 正常创建并关联问题")
+    void createWorkOrder_success() {
+        PatrolIssue issue = buildSampleIssue();
+        when(issueMapper.selectById(1L)).thenReturn(issue);
+        when(workOrderMapper.selectByIssueId(1L)).thenReturn(Collections.emptyList());
+        when(workOrderMapper.insert(any(IssueWorkOrder.class))).thenReturn(1);
+        when(issueMapper.updateById(any(PatrolIssue.class))).thenReturn(1);
+
+        WorkOrderCreateRequest request = new WorkOrderCreateRequest();
+        request.setIssueId(1L);
+        request.setTitle("管道漏水维修");
+        request.setDescription("XX路管道漏水");
+        request.setPriority("high");
+        request.setAssigneeId(200L);
+        request.setAssigneeName("李四");
+
+        IssueWorkOrder result = issueTrackingService.createWorkOrder(request);
+
+        assertNotNull(result);
+        assertEquals(1L, result.getIssueId());
+        assertEquals("管道漏水维修", result.getTitle());
+        assertEquals("high", result.getPriority());
+        assertEquals("pending", result.getStatus());
+        assertNotNull(result.getOrderNo());
+        assertTrue(result.getOrderNo().startsWith("WO"));
+
+        // 验证问题状态已同步
+        ArgumentCaptor<PatrolIssue> issueCaptor = ArgumentCaptor.forClass(PatrolIssue.class);
+        verify(issueMapper).updateById(issueCaptor.capture());
+        assertEquals("processing", issueCaptor.getValue().getHandleStatus());
+    }
+
+    @Test
+    @DisplayName("创建工单 - 已有活跃工单应拒绝")
+    void createWorkOrder_hasActiveOrder_throwsException() {
+        PatrolIssue issue = buildSampleIssue();
+        when(issueMapper.selectById(1L)).thenReturn(issue);
+
+        IssueWorkOrder existingOrder = new IssueWorkOrder();
+        existingOrder.setId(1L);
+        existingOrder.setIssueId(1L);
+        existingOrder.setStatus("in_progress");
+        when(workOrderMapper.selectByIssueId(1L)).thenReturn(Collections.singletonList(existingOrder));
+
+        WorkOrderCreateRequest request = new WorkOrderCreateRequest();
+        request.setIssueId(1L);
+
+        RuntimeException ex = assertThrows(RuntimeException.class,
+                () -> issueTrackingService.createWorkOrder(request));
+        assertTrue(ex.getMessage().contains("已有进行中的工单"));
+    }
+
+    @Test
+    @DisplayName("派单 - 状态更新为dispatched")
+    void dispatchWorkOrder_success() {
+        IssueWorkOrder workOrder = buildPendingWorkOrder();
+        when(workOrderMapper.selectById(1L)).thenReturn(workOrder);
+        when(workOrderMapper.updateById(any(IssueWorkOrder.class))).thenReturn(1);
+
+        IssueWorkOrder result = issueTrackingService.dispatchWorkOrder(1L, 200L, "李四");
+
+        assertEquals("dispatched", result.getStatus());
+        assertEquals(200L, result.getAssigneeId());
+        assertEquals("李四", result.getAssigneeName());
+    }
+
+    @Test
+    @DisplayName("派单 - 非待处理工单应拒绝")
+    void dispatchWorkOrder_notPending_throwsException() {
+        IssueWorkOrder workOrder = buildPendingWorkOrder();
+        workOrder.setStatus("in_progress");
+        when(workOrderMapper.selectById(1L)).thenReturn(workOrder);
+
+        RuntimeException ex = assertThrows(RuntimeException.class,
+                () -> issueTrackingService.dispatchWorkOrder(1L, 200L, "李四"));
+        assertTrue(ex.getMessage().contains("只有待处理工单才能派单"));
+    }
+
+    @Test
+    @DisplayName("工单完成回执 - 状态同步到问题")
+    void completeWorkOrder_syncsIssueStatus() {
+        IssueWorkOrder workOrder = buildPendingWorkOrder();
+        workOrder.setStatus("in_progress");
+        when(workOrderMapper.selectById(1L)).thenReturn(workOrder);
+        when(workOrderMapper.updateById(any(IssueWorkOrder.class))).thenReturn(1);
+
+        PatrolIssue issue = buildSampleIssue();
+        when(issueMapper.selectById(1L)).thenReturn(issue);
+        when(issueMapper.updateById(any(PatrolIssue.class))).thenReturn(1);
+
+        WorkOrderCompleteRequest request = new WorkOrderCompleteRequest();
+        request.setResult("已修复漏水管道");
+        request.setResultPhotos(Arrays.asList("http://img.example.com/fixed.jpg"));
+
+        IssueWorkOrder result = issueTrackingService.completeWorkOrder(1L, request);
+
+        assertEquals("completed", result.getStatus());
+        assertEquals("已修复漏水管道", result.getResult());
+        assertNotNull(result.getActualCompleteTime());
+
+        // 验证问题状态同步为resolved
+        ArgumentCaptor<PatrolIssue> issueCaptor = ArgumentCaptor.forClass(PatrolIssue.class);
+        verify(issueMapper).updateById(issueCaptor.capture());
+        assertEquals("resolved", issueCaptor.getValue().getHandleStatus());
+    }
+
+    @Test
+    @DisplayName("取消工单 - 已完成工单不可取消")
+    void cancelWorkOrder_completed_throwsException() {
+        IssueWorkOrder workOrder = buildPendingWorkOrder();
+        workOrder.setStatus("completed");
+        when(workOrderMapper.selectById(1L)).thenReturn(workOrder);
+
+        RuntimeException ex = assertThrows(RuntimeException.class,
+                () -> issueTrackingService.cancelWorkOrder(1L, "不需要了"));
+        assertTrue(ex.getMessage().contains("已完成的工单无法取消"));
+    }
+
+    @Test
+    @DisplayName("自动创建工单 - 根据问题severity映射priority")
+    void autoCreateWorkOrder_mapsPriority() {
+        PatrolIssue issue = buildSampleIssue();
+        issue.setSeverity("critical");
+        when(issueMapper.selectById(1L)).thenReturn(issue);
+        when(workOrderMapper.selectByIssueId(1L)).thenReturn(Collections.emptyList());
+        when(workOrderMapper.insert(any(IssueWorkOrder.class))).thenReturn(1);
+        when(issueMapper.updateById(any(PatrolIssue.class))).thenReturn(1);
+
+        IssueWorkOrder result = issueTrackingService.autoCreateWorkOrder(1L);
+
+        assertNotNull(result);
+        assertEquals("urgent", result.getPriority());
+    }
+
+    private PatrolIssue buildSampleIssue() {
+        PatrolIssue issue = new PatrolIssue();
+        issue.setId(1L);
+        issue.setExecutionId(1L);
+        issue.setIssueType("leak");
+        issue.setSeverity("high");
+        issue.setDescription("发现管道漏水");
+        issue.setHandleStatus("pending");
+        issue.setReporterId(100L);
+        issue.setReporterName("张三");
+        issue.setReportTime(LocalDateTime.now());
+        return issue;
+    }
+
+    private IssueWorkOrder buildPendingWorkOrder() {
+        IssueWorkOrder workOrder = new IssueWorkOrder();
+        workOrder.setId(1L);
+        workOrder.setIssueId(1L);
+        workOrder.setOrderNo("WO202606140001");
+        workOrder.setTitle("管道漏水维修");
+        workOrder.setStatus("pending");
+        workOrder.setPriority("high");
+        return workOrder;
+    }
+}