feat(wm-patrol): #77 巡检问题上报 + 工单联动（基于 master 真实表）

用 Java 在 wm-patrol 模块实现，替代原放错技术栈的 Python 实现(src/patrol/*.py)。

核心改动：

- PatrolIssueLinkageService: 问题上报→自动创建维修工单(workOrderId回填) + 状态同步 + 分类统计 + 处理时效分析

- PatrolIssueLinkageController: GET /api/patrol/issue-linkage/{by-work-order,stats/by-type,stats/processing-time}

- PatrolAppIssueService.submit 增强: 上报后自动联动创建工单

- 复用 master 现有 PatrolWorkOrderService/PatrolIssueReportMapper/真实表 pat_issue_report+pat_work_order

- 专项单元测试 PatrolIssueLinkageServiceTest: 联动创建+严重度映射+状态同步+统计+时效分析(覆盖 PM 反复要求的巡检/工单专项测试)

分支重建为基于 master 的干净单提交，清除了原 30b24863(Python) 及 3 个无关 IoT/AI 污染提交。符合设计文档 7.2。

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

+package com.water.patrol.controller;
+
+import com.water.common.core.result.R;
+import com.water.patrol.entity.PatrolIssueReport;
+import com.water.patrol.entity.PatrolWorkOrder;
+import com.water.patrol.service.PatrolIssueLinkageService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.Map;
+
+/**
+ * 巡检问题↔工单联动 API（对应 Issue #77）。
+ *
+ * 提供按工单查关联问题、问题分类统计、处理时效分析等端点。
+ */
+@Tag(name = "巡检问题-工单联动")
+@RestController
+@RequestMapping("/api/patrol/issue-linkage")
+@RequiredArgsConstructor
+public class PatrolIssueLinkageController {
+
+    private final PatrolIssueLinkageService linkageService;
+
+    @Operation(summary = "按工单ID查询关联的巡检问题")
+    @GetMapping("/by-work-order/{workOrderId}")
+    public R<PatrolIssueReport> byWorkOrder(@PathVariable Long workOrderId) {
+        return R.ok(linkageService.findByWorkOrder(workOrderId));
+    }
+
+    @Operation(summary = "问题分类统计")
+    @GetMapping("/stats/by-type")
+    public R<Map<String, Long>> statsByType() {
+        return R.ok(linkageService.countByType());
+    }
+
+    @Operation(summary = "处理时效分析（平均/最大处理时长）")
+    @GetMapping("/stats/processing-time")
+    public R<Map<String, Object>> processingTimeStats() {
+        return R.ok(linkageService.processingTimeStats());
+    }
+}

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

 @Slf4j @Service @RequiredArgsConstructor
 public class PatrolAppIssueService {
     private final PatrolIssueReportMapper mapper;
+    private final PatrolIssueLinkageService linkageService;
     public PatrolIssueReport submit(Long taskId, Long reporterId, String reporterName,
             String issueType, String description, String photos, String videos,
             BigDecimal lng, BigDecimal lat, String address, String severity) {
         r.setLng(lng); r.setLat(lat); r.setAddress(address);
         r.setSeverity(severity != null ? severity : "medium");
         r.setStatus("submitted");
-        mapper.insert(r); return r;
+        mapper.insert(r);
+        // Issue #77：问题上报后自动联动创建维修工单
+        try {
+            linkageService.linkAndCreateWorkOrder(r);
+        } catch (Exception e) {
+            log.warn("问题 {} 自动创建工单失败: {}", r.getId(), e.getMessage());
+        }
+        return r;
     }
     public Map<String, Object> myReports(Long reporterId) {
         Map<String, Object> r = new LinkedHashMap<>();

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

+package com.water.patrol.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.water.patrol.entity.PatrolIssueReport;
+import com.water.patrol.entity.PatrolWorkOrder;
+import com.water.patrol.mapper.PatrolIssueReportMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 巡检问题上报 ↔ 工单联动服务（对应 Issue #77）。
+ *
+ * <p>核心职责：
+ * <ul>
+ *   <li>问题上报时自动创建维修工单（issue_report.work_order_id 回填）</li>
+ *   <li>工单状态变更同步回问题状态</li>
+ *   <li>问题分类统计 + 处理时效分析</li>
+ * </ul>
+ *
+ * <p>基于 master 真实表 pat_issue_report / pat_work_order，复用已存在的
+ * {@link PatrolWorkOrderService} 与 {@link PatrolIssueReportMapper}。
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class PatrolIssueLinkageService {
+
+    private final PatrolIssueReportMapper issueMapper;
+    private final PatrolWorkOrderService workOrderService;
+
+    /**
+     * 为已上报的问题自动创建维修工单，并把工单ID回填到问题记录。
+     *
+     * @param issue 已插入的问题上报记录
+     * @return 关联的工单（issue.workOrderId 已回填）
+     */
+    public PatrolWorkOrder linkAndCreateWorkOrder(PatrolIssueReport issue) {
+        if (issue == null) {
+            throw new IllegalArgumentException("问题记录不能为空");
+        }
+        if (issue.getWorkOrderId() != null) {
+            log.info("问题 {} 已关联工单 {}，跳过自动创建", issue.getId(), issue.getWorkOrderId());
+            return workOrderService.getDetail(issue.getWorkOrderId());
+        }
+
+        // 根据问题级别映射工单严重度
+        String severity = mapSeverity(issue.getSeverity());
+        PatrolWorkOrder wo = workOrderService.create(
+                issue.getTaskId(),
+                issue.getIssueType(),
+                issue.getDescription(),
+                issue.getPhotos(),
+                severity);
+
+        // 回填工单ID，状态流转为处理中
+        issue.setWorkOrderId(wo.getId());
+        issue.setStatus("processing");
+        issueMapper.updateById(issue);
+
+        log.info("问题 {} 已自动创建工单 {}", issue.getId(), wo.getOrderNo());
+        return wo;
+    }
+
+    /**
+     * 工单状态变更后同步问题状态。
+     *
+     * @param workOrderId 工单ID
+     * @param woStatus    工单新状态
+     */
+    public void syncIssueStatus(Long workOrderId, String woStatus) {
+        if (workOrderId == null) {
+            return;
+        }
+        PatrolIssueReport issue = findByWorkOrder(workOrderId);
+        if (issue == null) {
+            return;
+        }
+        String issueStatus = mapWorkOrderStatusToIssue(woStatus);
+        if (issueStatus != null && !issueStatus.equals(issue.getStatus())) {
+            issue.setStatus(issueStatus);
+            issueMapper.updateById(issue);
+            log.info("工单 {} 状态 {} 已同步至问题 {}", workOrderId, woStatus, issue.getId());
+        }
+    }
+
+    /**
+     * 根据工单ID查询关联的问题。
+     */
+    public PatrolIssueReport findByWorkOrder(Long workOrderId) {
+        LambdaQueryWrapper<PatrolIssueReport> w = new LambdaQueryWrapper<>();
+        w.eq(PatrolIssueReport::getWorkOrderId, workOrderId).last("LIMIT 1");
+        return issueMapper.selectOne(w);
+    }
+
+    /**
+     * 问题分类统计（按 issueType 分组计数）。
+     */
+    public Map<String, Long> countByType() {
+        Map<String, Long> result = new LinkedHashMap<>();
+        List<PatrolIssueReport> all = issueMapper.selectList(new LambdaQueryWrapper<>());
+        for (PatrolIssueReport issue : all) {
+            String type = issue.getIssueType() != null ? issue.getIssueType() : "unknown";
+            result.merge(type, 1L, Long::sum);
+        }
+        return result;
+    }
+
+    /**
+     * 处理时效分析：已关联工单且工单已解决的问题，统计平均处理时长（小时）。
+     *
+     * @return {count, avgHours, maxHours}
+     */
+    public Map<String, Object> processingTimeStats() {
+        LambdaQueryWrapper<PatrolIssueReport> w = new LambdaQueryWrapper<>();
+        w.isNotNull(PatrolIssueReport::getWorkOrderId);
+        List<PatrolIssueReport> linked = issueMapper.selectList(w);
+
+        long count = 0;
+        long totalSeconds = 0;
+        long maxSeconds = 0;
+        for (PatrolIssueReport issue : linked) {
+            PatrolWorkOrder wo = workOrderService.getDetail(issue.getWorkOrderId());
+            if (wo == null || wo.getResolvedAt() == null || issue.getCreatedAt() == null) {
+                continue;
+            }
+            long seconds = Duration.between(issue.getCreatedAt(), wo.getResolvedAt()).getSeconds();
+            totalSeconds += seconds;
+            maxSeconds = Math.max(maxSeconds, seconds);
+            count++;
+        }
+
+        Map<String, Object> stats = new LinkedHashMap<>();
+        stats.put("resolvedCount", count);
+        stats.put("avgHours", count == 0 ? 0.0 : totalSeconds / 3600.0 / count);
+        stats.put("maxHours", maxSeconds / 3600.0);
+        return stats;
+    }
+
+    /** 问题严重度 → 工单严重度映射（统一为中/英小写口径） */
+    private String mapSeverity(String issueSeverity) {
+        if (issueSeverity == null) {
+            return "medium";
+        }
+        return switch (issueSeverity.toLowerCase()) {
+            case "low" -> "low";
+            case "high", "urgent" -> "high";
+            default -> "medium";
+        };
+    }
+
+    /** 工单状态 → 问题状态映射 */
+    private String mapWorkOrderStatusToIssue(String woStatus) {
+        if (woStatus == null) {
+            return null;
+        }
+        return switch (woStatus) {
+            case "pending", "assigned" -> "processing";
+            case "in_progress" -> "processing";
+            case "resolved" -> "resolved";
+            case "closed" -> "closed";
+            default -> null;
+        };
+    }
+
+    // 提供给测试使用的当前时间点（便于扩展，此处直接用实体上的 createdAt）
+    LocalDateTime nowForTest() {
+        return LocalDateTime.now();
+    }
+}

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

+package com.water.patrol.service;
+
+import com.baomidou.mybatisplus.core.conditions.Wrapper;
+import com.water.patrol.entity.PatrolIssueReport;
+import com.water.patrol.entity.PatrolWorkOrder;
+import com.water.patrol.mapper.PatrolIssueReportMapper;
+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.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.*;
+
+/**
+ * PatrolIssueLinkageService 专项测试（对应 Issue #77，PM 反复要求的巡检/工单专项测试）。
+ *
+ * 覆盖：联动创建工单 + workOrderId 回填 + 状态同步 + 分类统计 + 时效分析。
+ */
+@ExtendWith(MockitoExtension.class)
+class PatrolIssueLinkageServiceTest {
+
+    @Mock PatrolIssueReportMapper issueMapper;
+    @Mock PatrolWorkOrderService workOrderService;
+
+    @InjectMocks PatrolIssueLinkageService service;
+
+    private PatrolIssueReport issue(Long id, String severity, Long workOrderId) {
+        PatrolIssueReport i = new PatrolIssueReport();
+        i.setId(id);
+        i.setTaskId(10L);
+        i.setIssueType("water_leak");
+        i.setDescription("管道漏水");
+        i.setSeverity(severity);
+        i.setWorkOrderId(workOrderId);
+        i.setStatus("submitted");
+        i.setCreatedAt(LocalDateTime.now().minusHours(2));
+        return i;
+    }
+
+    private PatrolWorkOrder wo(Long id, String status, LocalDateTime resolvedAt) {
+        PatrolWorkOrder w = new PatrolWorkOrder();
+        w.setId(id);
+        w.setOrderNo("PWO-" + id);
+        w.setStatus(status);
+        w.setResolvedAt(resolvedAt);
+        return w;
+    }
+
+    // ---------- 联动创建工单 ----------
+
+    @Test
+    void linkAndCreateWorkOrder_createsOrderAndBackfillsId() {
+        PatrolIssueReport i = issue(1L, "high", null);
+        PatrolWorkOrder created = wo(500L, "pending", null);
+        when(workOrderService.create(eq(10L), eq("water_leak"), eq("管道漏水"), isNull(), eq("high")))
+                .thenReturn(created);
+
+        PatrolWorkOrder result = service.linkAndCreateWorkOrder(i);
+
+        assertSame(created, result);
+        // workOrderId 被回填
+        assertEquals(500L, i.getWorkOrderId());
+        // 状态流转为处理中
+        assertEquals("processing", i.getStatus());
+        // 工单创建 + 问题更新均被调用
+        verify(workOrderService).create(any(), any(), any(), any(), any());
+        verify(issueMapper).updateById(i);
+    }
+
+    @Test
+    void linkAndCreateWorkOrder_severityMapping_urgentToHigh() {
+        PatrolIssueReport i = issue(2L, "urgent", null);
+        when(workOrderService.create(any(), any(), any(), any(), eq("high"))).thenReturn(wo(1L, "pending", null));
+
+        service.linkAndCreateWorkOrder(i);
+        // urgent 映射为 high
+        verify(workOrderService).create(any(), any(), any(), any(), eq("high"));
+    }
+
+    @Test
+    void linkAndCreateWorkOrder_severityMapping_lowStaysLow() {
+        PatrolIssueReport i = issue(3L, "low", null);
+        when(workOrderService.create(any(), any(), any(), any(), eq("low"))).thenReturn(wo(1L, "pending", null));
+
+        service.linkAndCreateWorkOrder(i);
+        verify(workOrderService).create(any(), any(), any(), any(), eq("low"));
+    }
+
+    @Test
+    void linkAndCreateWorkOrder_skipsIfAlreadyLinked() {
+        PatrolIssueReport i = issue(4L, "high", 999L); // 已有工单
+        when(workOrderService.getDetail(999L)).thenReturn(wo(999L, "assigned", null));
+
+        PatrolWorkOrder result = service.linkAndCreateWorkOrder(i);
+
+        assertEquals(999L, result.getId());
+        // 不应再创建新工单
+        verify(workOrderService, never()).create(any(), any(), any(), any(), any());
+        verify(issueMapper, never()).updateById(any());
+    }
+
+    @Test
+    void linkAndCreateWorkOrder_nullIssueThrows() {
+        assertThrows(IllegalArgumentException.class, () -> service.linkAndCreateWorkOrder(null));
+    }
+
+    // ---------- 状态同步 ----------
+
+    @Test
+    void syncIssueStatus_updatesIssueWhenWorkOrderResolved() {
+        PatrolIssueReport i = issue(5L, "high", 50L);
+        i.setStatus("processing");
+        when(issueMapper.selectOne(any(Wrapper.class))).thenReturn(i);
+
+        service.syncIssueStatus(50L, "resolved");
+
+        assertEquals("resolved", i.getStatus());
+        verify(issueMapper).updateById(i);
+    }
+
+    @Test
+    void syncIssueStatus_noopWhenNoLinkedIssue() {
+        when(issueMapper.selectOne(any(Wrapper.class))).thenReturn(null);
+        service.syncIssueStatus(999L, "resolved");
+        verify(issueMapper, never()).updateById(any());
+    }
+
+    // ---------- 分类统计 ----------
+
+    @Test
+    @SuppressWarnings("unchecked")
+    void countByType_groupsByIssueType() {
+        PatrolIssueReport a = issue(1L, "high", null); a.setIssueType("water_leak");
+        PatrolIssueReport b = issue(2L, "low", null); b.setIssueType("water_leak");
+        PatrolIssueReport c = issue(3L, "medium", null); c.setIssueType("equipment_failure");
+        when(issueMapper.selectList(any(Wrapper.class))).thenReturn(List.of(a, b, c));
+
+        Map<String, Long> stats = service.countByType();
+
+        assertEquals(2L, stats.get("water_leak"));
+        assertEquals(1L, stats.get("equipment_failure"));
+    }
+
+    // ---------- 时效分析 ----------
+
+    @Test
+    @SuppressWarnings("unchecked")
+    void processingTimeStats_computesAvgAndMax() {
+        LocalDateTime base = LocalDateTime.now().minusHours(5);
+        PatrolIssueReport i1 = issue(1L, "high", 100L);
+        i1.setCreatedAt(base);
+        PatrolIssueReport i2 = issue(2L, "low", 200L);
+        i2.setCreatedAt(base);
+
+        when(issueMapper.selectList(any(Wrapper.class))).thenReturn(List.of(i1, i2));
+        // 工单1：创建后2小时解决；工单2：创建后4小时解决
+        when(workOrderService.getDetail(100L)).thenReturn(wo(100L, "resolved", base.plusHours(2)));
+        when(workOrderService.getDetail(200L)).thenReturn(wo(200L, "resolved", base.plusHours(4)));
+
+        Map<String, Object> stats = service.processingTimeStats();
+
+        assertEquals(2L, stats.get("resolvedCount"));
+        // 平均 = (2+4)/2 = 3 小时
+        assertEquals(3.0, (double) stats.get("avgHours"), 0.01);
+        // 最大 = 4 小时
+        assertEquals(4.0, (double) stats.get("maxHours"), 0.01);
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    void processingTimeStats_skipsUnresolved() {
+        PatrolIssueReport i = issue(1L, "high", 100L);
+        when(issueMapper.selectList(any(Wrapper.class))).thenReturn(List.of(i));
+        // 工单未解决（resolvedAt=null）
+        when(workOrderService.getDetail(100L)).thenReturn(wo(100L, "in_progress", null));
+
+        Map<String, Object> stats = service.processingTimeStats();
+
+        assertEquals(0L, stats.get("resolvedCount"));
+        assertEquals(0.0, (double) stats.get("avgHours"), 0.01);
+    }
+}