fix(issue-15): 修复巡检管理系统7类代码质量问题

A. 表名不一致(致命): PatrolCoreService/PatrolWoService/PatrolService使用patrol_*前缀但DDL定义pat_*前缀
   - PatrolCoreService: patrol_task→pat_task, patrol_work_order→pat_work_order, patrol_track_point→pat_track_point, patrol_device→pat_device, patrol_route→pat_route_setup
   - PatrolWoService: patrol_work_order→pat_work_order
   - PatrolService: patrol_route→pat_route_setup, patrol_task→pat_task, patrol_record→pat_record
   - PatrolProblemMapper.xml: patrol_problem→pat_problem
   - WorkOrderMapper.xml: work_order→pat_wo_detail
   - WorkOrderProcessMapper.xml: work_order_process→pat_wo_process

B. 缺失DDL表(致命): 新增V89__patrol_fix.sql
   - pat_record(巡检记录), pat_problem(巡检问题), pat_wo_detail(工单详情), pat_wo_process(工单处理记录)
   - pat_task补列: task_date, assignee_id, plan_start, plan_end, actual_start, actual_end
   - pat_route_setup补列: route_points, estim_duration, area
   - pat_track_point补列: recorded_at; pat_device补列: area
   - 创建序列: seq_patrol_problem, seq_pat_wo_detail

C. WorkOrderServiceImpl NPE Bug(高): selectByProblemId().setWorkOrderId()不持久化且可能NPE
   - 改为注入PatrolProblemMapper并调用updateStatus(id, status, workOrderId)

D. WorkOrderMapper.xml updateStatus(高): 引用#{updatedAt}但接口未传该参数
   - 改为NOW(); 同理修复updateAssignee/updateCompletion/PatrolProblemMapper.xml updateStatus

E. PatrolApplication缺@MapperScan(中): 添加@MapperScan('com.water.patrol.mapper')

F. 误放测试文件(中): 删除src/main/java/patrol/下2个无效测试(引用不存在的PatrolManager类)

G. 缺测试(中): 新增PatrolProblemWorkOrderTest(20个测试) + PatrolCoreWoServiceTest(25个测试)
   覆盖: ProblemService CRUD/统计/自动工单, WorkOrderService创建/分派/处理/完成/统计,
   PatrolCoreService总览/轨迹/台账/设备, PatrolWoService CRUD/列表/统计,
   PatrolService路线/任务/记录/问题上报/统计, PatrolOverviewService总览/月报

H. PatrolService.getRoutes: status=1(int)改为status='active'(varchar)对齐DDL

wm-patrol/src/main/java/com/water/patrol/PatrolApplication.java

 package com.water.patrol;
 
+import org.mybatis.spring.annotation.MapperScan;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
 @SpringBootApplication
+@MapperScan("com.water.patrol.mapper")
 public class PatrolApplication {
     public static void main(String[] args) {
         SpringApplication.run(PatrolApplication.class, args);

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

         LocalDate today = LocalDate.now();
         LocalDate monthStart = today.withDayOfMonth(1);
 
-        long todayTotal = countQuery("SELECT COUNT(*) FROM patrol_task WHERE task_date = ?", today);
-        long todayCompleted = countQuery("SELECT COUNT(*) FROM patrol_task WHERE task_date = ? AND status = 'completed'", today);
-        long monthTotal = countQuery("SELECT COUNT(*) FROM patrol_task WHERE task_date >= ?", monthStart);
-        long monthCompleted = countQuery("SELECT COUNT(*) FROM patrol_task WHERE task_date >= ? AND status = 'completed'", monthStart);
+        long todayTotal = countQuery("SELECT COUNT(*) FROM pat_task WHERE task_date = ?", today);
+        long todayCompleted = countQuery("SELECT COUNT(*) FROM pat_task WHERE task_date = ? AND status = 'completed'", today);
+        long monthTotal = countQuery("SELECT COUNT(*) FROM pat_task WHERE task_date >= ?", monthStart);
+        long monthCompleted = countQuery("SELECT COUNT(*) FROM pat_task WHERE task_date >= ? AND status = 'completed'", monthStart);
 
-        long pendingIssues = countQuery("SELECT COUNT(*) FROM patrol_work_order WHERE status IN ('pending','assigned','processing')");
-        long resolvedIssues = countQuery("SELECT COUNT(*) FROM patrol_work_order WHERE status = 'resolved'");
+        long pendingIssues = countQuery("SELECT COUNT(*) FROM pat_work_order WHERE status IN ('pending','assigned','processing')");
+        long resolvedIssues = countQuery("SELECT COUNT(*) FROM pat_work_order WHERE status = 'resolved'");
 
         long coverageRate = monthTotal > 0 ? Math.round(monthCompleted * 100.0 / monthTotal) : 0;
 
 
     public List<Map<String, Object>> getTodayTasks() {
         return jdbc.queryForList(
-            "SELECT pt.*, pr.route_name, pr.area FROM patrol_task pt " +
-            "LEFT JOIN patrol_route pr ON pt.route_id = pr.id " +
+            "SELECT pt.*, pr.route_name, pr.area FROM pat_task pt " +
+            "LEFT JOIN pat_route_setup pr ON pt.route_id = pr.id " +
             "WHERE pt.task_date = CURRENT_DATE ORDER BY pt.plan_start");
     }
 
     public List<Map<String, Object>> getRecentIssues(int limit) {
         return jdbc.queryForList(
-            "SELECT * FROM patrol_work_order ORDER BY created_at DESC LIMIT ?", limit);
+            "SELECT * FROM pat_work_order ORDER BY created_at DESC LIMIT ?", limit);
     }
 
     // ========== PAT-02 任务轨迹（GPS记录与回放） ==========
                                                  double lng, double lat,
                                                  double speed, double accuracy) {
         jdbc.update(
-            "INSERT INTO patrol_track_point (task_id, worker_id, lng, lat, speed, accuracy) " +
+            "INSERT INTO pat_track_point (task_id, worker_id, lng, lat, speed, accuracy) " +
             "VALUES (?,?,?,?,?,?)",
             taskId, workerId, lng, lat, speed, accuracy);
         Map<String, Object> result = new LinkedHashMap<>();
 
     public List<Map<String, Object>> getTrack(Long taskId) {
         return jdbc.queryForList(
-            "SELECT * FROM patrol_track_point WHERE task_id = ? ORDER BY recorded_at", taskId);
+            "SELECT * FROM pat_track_point WHERE task_id = ? ORDER BY recorded_at", taskId);
     }
 
     public Map<String, Object> replayTrack(Long taskId) {
     // ========== PAT-03 任务台账 ==========
 
     public Map<String, Object> getTaskLedger(String status, Long workerId, int page, int size) {
-        StringBuilder sql = new StringBuilder("SELECT * FROM patrol_task WHERE 1=1");
+        StringBuilder sql = new StringBuilder("SELECT * FROM pat_task WHERE 1=1");
         List<Object> params = new ArrayList<>();
         if (status != null && !status.isEmpty()) {
             sql.append(" AND status = ?");
 
         List<Map<String, Object>> records = jdbc.queryForList(sql.toString(), params.toArray());
 
-        StringBuilder countSql = new StringBuilder("SELECT COUNT(*) FROM patrol_task WHERE 1=1");
+        StringBuilder countSql = new StringBuilder("SELECT COUNT(*) FROM pat_task WHERE 1=1");
         List<Object> countParams = new ArrayList<>();
         if (status != null && !status.isEmpty()) {
             countSql.append(" AND status = ?");
 
     public Map<String, Object> getDeviceLedger(String deviceType, String status, String area,
                                                 int page, int size) {
-        StringBuilder sql = new StringBuilder("SELECT * FROM patrol_device WHERE 1=1");
+        StringBuilder sql = new StringBuilder("SELECT * FROM pat_device WHERE 1=1");
         List<Object> params = new ArrayList<>();
         if (deviceType != null && !deviceType.isEmpty()) {
             sql.append(" AND device_type = ?");
 
         List<Map<String, Object>> records = jdbc.queryForList(sql.toString(), params.toArray());
 
-        StringBuilder countSql = new StringBuilder("SELECT COUNT(*) FROM patrol_device WHERE 1=1");
+        StringBuilder countSql = new StringBuilder("SELECT COUNT(*) FROM pat_device WHERE 1=1");
         List<Object> countParams = new ArrayList<>();
         if (deviceType != null && !deviceType.isEmpty()) {
             countSql.append(" AND device_type = ?");
     public Map<String, Object> createDevice(String deviceNo, String deviceName, String deviceType,
                                              String location, double lng, double lat, String area) {
         jdbc.update(
-            "INSERT INTO patrol_device (device_no, device_name, device_type, location, lng, lat, area) " +
+            "INSERT INTO pat_device (device_no, device_name, device_type, location, lng, lat, area) " +
             "VALUES (?,?,?,?,?,?,?)",
             deviceNo, deviceName, deviceType, location, lng, lat, area);
         Map<String, Object> result = new LinkedHashMap<>();
     }
 
     public Map<String, Object> updateDeviceStatus(Long deviceId, String status) {
-        jdbc.update("UPDATE patrol_device SET status = ?, updated_at = NOW() WHERE id = ?",
+        jdbc.update("UPDATE pat_device SET status = ?, updated_at = NOW() WHERE id = ?",
             status, deviceId);
         return Map.of("deviceId", deviceId, "status", status, "updated", true);
     }

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

 
     // ========== 路线管理 ==========
     public Map<String, Object> createRoute(String routeName, String area, List<Map<String, Object>> points, int estimDuration) {
-        jdbc.update("INSERT INTO patrol_route (route_name, area, route_points, estim_duration) VALUES (?,?,?::jsonb,?)",
+        jdbc.update("INSERT INTO pat_route_setup (route_name, area, route_points, estim_duration) VALUES (?,?,?::jsonb,?)",
             routeName, area, points.toString(), estimDuration);
         return Map.of("routeName", routeName, "area", area, "points", points.size());
     }
 
     public List<Map<String, Object>> getRoutes(String area) {
-        return jdbc.queryForList("SELECT * FROM patrol_route WHERE area = ? AND status = 1", area);
+        return jdbc.queryForList("SELECT * FROM pat_route_setup WHERE area = ? AND status = 'active'", area);
     }
 
     // ========== 任务管理 ==========
     public Map<String, Object> createTask(Long routeId, Long assigneeId, String taskDate) {
         jdbc.update(
-            "INSERT INTO patrol_task (route_id, assignee_id, task_name, task_date, plan_start, plan_end, status) " +
+            "INSERT INTO pat_task (route_id, assignee_id, task_name, task_date, plan_start, plan_end, status) " +
             "SELECT ?, ?, route_name, ?, CAST(? AS TIMESTAMP), CAST(? AS TIMESTAMP) + (estim_duration || ' minutes')::INTERVAL, 'pending' " +
-            "FROM patrol_route WHERE id = ?",
+            "FROM pat_route_setup WHERE id = ?",
             routeId, assigneeId, taskDate, taskDate + " 09:00:00", taskDate + " 09:00:00", routeId);
         return Map.of("routeId", routeId, "assigneeId", assigneeId, "date", taskDate, "status", "created");
     }
 
     public List<Map<String, Object>> getTodayTasks(Long userId) {
         return jdbc.queryForList(
-            "SELECT pt.*, pr.route_name, pr.area FROM patrol_task pt " +
-            "LEFT JOIN patrol_route pr ON pt.route_id = pr.id " +
+            "SELECT pt.*, pr.route_name, pr.area FROM pat_task pt " +
+            "LEFT JOIN pat_route_setup pr ON pt.route_id = pr.id " +
             "WHERE pt.task_date = CURRENT_DATE AND pt.assignee_id = ? " +
             "ORDER BY pt.plan_start", userId);
     }
 
     public Map<String, Object> startTask(Long taskId) {
-        jdbc.update("UPDATE patrol_task SET status = 'in_progress', actual_start = NOW() WHERE id = ?", taskId);
+        jdbc.update("UPDATE pat_task SET status = 'in_progress', actual_start = NOW() WHERE id = ?", taskId);
         return Map.of("taskId", taskId, "status", "in_progress", "startedAt", new Date());
     }
 
     public Map<String, Object> completeTask(Long taskId, double distance) {
         jdbc.update(
-            "UPDATE patrol_task SET status = 'completed', actual_end = NOW(), distance = ? WHERE id = ?",
+            "UPDATE pat_task SET status = 'completed', actual_end = NOW(), distance = ? WHERE id = ?",
             distance, taskId);
         return Map.of("taskId", taskId, "status", "completed", "distance", distance);
     }
                                             List<Map<String, Object>> checkItems,
                                             double lng, double lat) {
         jdbc.update(
-            "INSERT INTO patrol_record (task_id, point_seq, device_id, check_items, gps_lng, gps_lat, record_time) " +
+            "INSERT INTO pat_record (task_id, point_seq, device_id, check_items, gps_lng, gps_lat, record_time) " +
             "VALUES (?,?,?,?::jsonb,?,?,NOW())",
             taskId, pointSeq, deviceId, checkItems.toString(), lng, lat);
         return Map.of("taskId", taskId, "pointSeq", pointSeq, "recorded", true);
 
     public List<Map<String, Object>> getTaskRecords(Long taskId) {
         return jdbc.queryForList(
-            "SELECT * FROM patrol_record WHERE task_id = ? ORDER BY point_seq", taskId);
+            "SELECT * FROM pat_record WHERE task_id = ? ORDER BY point_seq", taskId);
     }
 
     // ========== 问题上报（巡检APP） ==========
                                             double lng, double lat) {
         // 自动创建工单
         jdbc.update(
-            "INSERT INTO patrol_task (task_name, assignee_id, task_date, status) " +
-            "SELECT CONCAT('问题处理: ', ?), assignee_id, CURRENT_DATE, 'pending' FROM patrol_task WHERE id = ?",
+            "INSERT INTO pat_task (task_name, assignee_id, task_date, status) " +
+            "SELECT CONCAT('问题处理: ', ?), assignee_id, CURRENT_DATE, 'pending' FROM pat_task WHERE id = ?",
             issueType + ": " + description.substring(0, Math.min(description.length(), 50)), taskId);
 
         log.info("Issue reported: type={} desc={}", issueType, description);
         // 任务执行率
         stats.put("completionRate", jdbc.queryForMap(
             "SELECT COUNT(*) as total, SUM(CASE WHEN status='completed' THEN 1 ELSE 0 END) as completed " +
-            "FROM patrol_task WHERE task_date BETWEEN ? AND ?", start, end));
+            "FROM pat_task WHERE task_date BETWEEN ? AND ?", start, end));
 
         // 人员里程
         stats.put("personDistance", jdbc.queryForList(
             "SELECT u.real_name, SUM(pt.distance) as total_km " +
-            "FROM patrol_task pt JOIN sys_user u ON pt.assignee_id = u.id " +
+            "FROM pat_task pt JOIN sys_user u ON pt.assignee_id = u.id " +
             "WHERE pt.task_date BETWEEN ? AND ? GROUP BY u.id, u.real_name", start, end));
 
         // 巡检工作量
         stats.put("workload", jdbc.queryForList(
             "SELECT task_date, COUNT(*) as tasks, SUM(distance) as total_km " +
-            "FROM patrol_task WHERE task_date BETWEEN ? AND ? GROUP BY task_date ORDER BY task_date",
+            "FROM pat_task WHERE task_date BETWEEN ? AND ? GROUP BY task_date ORDER BY task_date",
             start, end));
 
         // 问题分类统计
         stats.put("issueStats", jdbc.queryForList(
             "SELECT SUBSTRING(task_name FROM '^[^:]+') as issue_type, COUNT(*) as count " +
-            "FROM patrol_task WHERE task_name LIKE '%问题处理:%' AND task_date BETWEEN ? AND ? GROUP BY 1",
+            "FROM pat_task WHERE task_name LIKE '%问题处理:%' AND task_date BETWEEN ? AND ? GROUP BY 1",
             start, end));
 
         return stats;

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

                                        String location, Double lng, Double lat, Long taskId) {
         String orderNo = "PWO-" + System.currentTimeMillis();
         jdbc.update(
-            "INSERT INTO patrol_work_order (order_no, task_id, issue_type, description, severity, " +
+            "INSERT INTO pat_work_order (order_no, task_id, issue_type, description, severity, " +
             "location, lng, lat, status) VALUES (?,?,?,?,?,?,?,?,?)",
             orderNo, taskId, issueType, description,
             severity != null ? severity : "medium",
     /** 分派工单 */
     public Map<String, Object> assign(Long woId, Long assigneeId, String assigneeName) {
         int rows = jdbc.update(
-            "UPDATE patrol_work_order SET assignee_id = ?, assignee_name = ?, status = 'assigned' " +
+            "UPDATE pat_work_order SET assignee_id = ?, assignee_name = ?, status = 'assigned' " +
             "WHERE id = ?", assigneeId, assigneeName, woId);
         return Map.of("success", rows > 0, "woId", woId);
     }
     /** 处理工单 */
     public Map<String, Object> process(Long woId, String resolution) {
         int rows = jdbc.update(
-            "UPDATE patrol_work_order SET status = 'processing', resolution = ? WHERE id = ?",
+            "UPDATE pat_work_order SET status = 'processing', resolution = ? WHERE id = ?",
             resolution, woId);
         return Map.of("success", rows > 0, "woId", woId);
     }
     /** 解决工单 */
     public Map<String, Object> resolve(Long woId) {
         int rows = jdbc.update(
-            "UPDATE patrol_work_order SET status = 'resolved', resolved_at = NOW() WHERE id = ?", woId);
+            "UPDATE pat_work_order SET status = 'resolved', resolved_at = NOW() WHERE id = ?", woId);
         return Map.of("success", rows > 0, "woId", woId);
     }
 
     /** 工单详情 */
     public Map<String, Object> getDetail(Long woId) {
         List<Map<String, Object>> rows = jdbc.queryForList(
-            "SELECT * FROM patrol_work_order WHERE id = ?", woId);
+            "SELECT * FROM pat_work_order WHERE id = ?", woId);
         return rows.isEmpty() ? null : rows.get(0);
     }
 
     /** 工单列表 */
     public Map<String, Object> list(String status, String severity, int page, int size) {
-        StringBuilder sql = new StringBuilder("SELECT * FROM patrol_work_order WHERE 1=1");
+        StringBuilder sql = new StringBuilder("SELECT * FROM pat_work_order WHERE 1=1");
         List<Object> params = new ArrayList<>();
         if (status != null && !status.isEmpty()) {
             sql.append(" AND status = ?");
 
         List<Map<String, Object>> records = jdbc.queryForList(sql.toString(), params.toArray());
 
-        StringBuilder countSql = new StringBuilder("SELECT COUNT(*) FROM patrol_work_order WHERE 1=1");
+        StringBuilder countSql = new StringBuilder("SELECT COUNT(*) FROM pat_work_order WHERE 1=1");
         List<Object> countParams = new ArrayList<>();
         if (status != null && !status.isEmpty()) {
             countSql.append(" AND status = ?");
     /** 工单统计 */
     public Map<String, Object> stats() {
         List<Map<String, Object>> rows = jdbc.queryForList(
-            "SELECT status, COUNT(*) as count FROM patrol_work_order GROUP BY status");
+            "SELECT status, COUNT(*) as count FROM pat_work_order GROUP BY status");
         Map<String, Object> result = new LinkedHashMap<>();
         for (Map<String, Object> row : rows) {
             result.put(String.valueOf(row.get("status")), ((Number) row.get("count")).longValue());

wm-patrol/src/main/java/com/water/patrol/service/impl/WorkOrderServiceImpl.java

 import com.water.patrol.entity.PatrolProblem;
 import com.water.patrol.entity.WorkOrder;
 import com.water.patrol.entity.WorkOrderProcess;
+import com.water.patrol.mapper.PatrolProblemMapper;
 import com.water.patrol.mapper.WorkOrderMapper;
 import com.water.patrol.mapper.WorkOrderProcessMapper;
 import com.water.patrol.service.WorkOrderService;
     @Autowired
     private WorkOrderProcessMapper workOrderProcessMapper;
 
+    @Autowired
+    private PatrolProblemMapper patrolProblemMapper;
+
     @Override
     @Transactional
     public boolean createFromProblem(PatrolProblem problem) {
             process.setCreatedAt(LocalDateTime.now());
             workOrderProcessMapper.insert(process);
             
-            // 更新问题状态
-            workOrderMapper.selectByProblemId(problem.getId()).setWorkOrderId(workOrder.getId());
+            // 更新问题状态 - 关联工单ID
+            patrolProblemMapper.updateStatus(problem.getId(), "processing", workOrder.getId());
             return true;
         }
         

wm-patrol/src/main/java/patrol/PatrolCoreTest.java

-package com.water.patrol;
-
-import org.junit.jupiter.api.Test;
-import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.beans.factory.annotation.Autowired;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * 巡检管理核心流程测试
- */
-@SpringBootTest
-public class PatrolCoreTest {
-
-    @Autowired
-    private PatrolCoreService patrolCoreService;
-
-    @Test
-    public void testPatrolTaskCreation() {
-        // 测试巡检任务创建
-        assertTrue(true, "巡检任务创建测试通过");
-    }
-
-    @Test
-    public void testPatrolTaskExecution() {
-        // 测试巡检任务执行
-        assertTrue(true, "巡检任务执行测试通过");
-    }
-
-    @Test
-    public void testPatrolTaskReporting() {
-        // 测试巡检任务上报
-        assertTrue(true, "巡检任务上报测试通过");
-    }
-
-    @Test
-    public void testPatrolRouteOptimization() {
-        // 测试巡检路线优化
-        assertTrue(true, "巡检路线优化测试通过");
-    }
-}

wm-patrol/src/main/java/patrol/src/test/java/com/water/patrol/PatrolCoreTest.java

-package com.water.patrol;
-
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.BeforeEach;
-import static org.junit.jupiter.api.Assertions.*;
-import java.util.List;
-import java.util.Map;
-
-/**
- * 巡检管理核心流程测试
- * 测试任务创建、执行、上报和流程管理
- */
-public class PatrolCoreTest {
-    
-    private PatrolManager patrolManager;
-    
-    @BeforeEach
-    void setUp() {
-        patrolManager = new PatrolManager();
-    }
-    
-    @Test
-    void testPatrolTaskCreation() {
-        Map<String, Object> taskData = Map.of(
-            "task_id", "patrol-001",
-            "task_name", "常规巡检",
-            "patrol_route", "route-001",
-            "assigned_user", "user-001",
-            "scheduled_time", "2026-06-16T10:00:00Z",
-            "priority", "high"
-        );
-        
-        String taskId = patrolManager.createTask(taskData);
-        assertNotNull(taskId, "任务创建应该返回ID");
-        assertFalse(taskId.isEmpty(), "ID不应该为空");
-    }
-    
-    @Test
-    void testTaskAssignment() {
-        // 先创建任务
-        Map<String, Object> taskData = Map.of(
-            "task_id", "patrol-002",
-            "task_name", "紧急巡检",
-            "patrol_route", "route-002"
-        );
-        String taskId = patrolManager.createTask(taskData);
-        
-        // 分配任务
-        boolean assigned = patrolManager.assignTask(taskId, "user-002");
-        assertTrue(assigned, "任务分配应该成功");
-        
-        // 验证分配状态
-        Map<String, Object> task = patrolManager.getTask(taskId);
-        assertEquals("user-002", task.get("assigned_user"));
-        assertEquals("assigned", task.get("status"));
-    }
-    
-    @Test
-    void testPatrolExecution() {
-        // 创建并分配任务
-        Map<String, Object> taskData = Map.of(
-            "task_id", "patrol-003",
-            "task_name", "执行巡检",
-            "patrol_route", "route-003"
-        );
-        String taskId = patrolManager.createTask(taskData);
-        patrolManager.assignTask(taskId, "user-003");
-        
-        // 执行巡检
-        Map<String, Object> executionData = Map.of(
-            "task_id", taskId,
-            "start_time", "2026-06-16T10:00:00Z",
-            "actual_route", "route-003",
-            "weather", "sunny"
-        );
-        
-        boolean executed = patrolManager.executePatrol(executionData);
-        assertTrue(executed, "巡检执行应该成功");
-        
-        // 验证执行状态
-        Map<String, Object> task = patrolManager.getTask(taskId);
-        assertEquals("in_progress", task.get("status"));
-    }
-    
-    @Test
-    void testPatrolReport() {
-        // 先执行巡检
-        Map<String, Object> taskData = Map.of(
-            "task_id", "patrol-004",
-            "task_name", "上报巡检"
-        );
-        String taskId = patrolManager.createTask(taskData);
-        patrolManager.assignTask(taskId, "user-004");
-        
-        Map<String, Object> executionData = Map.of(
-            "task_id", taskId,
-            "start_time", "2026-06-16T10:00:00Z"
-        );
-        patrolManager.executePatrol(executionData);
-        
-        // 上报巡检结果
-        Map<String, Object> reportData = Map.of(
-            "task_id", taskId,
-            "end_time", "2026-06-16T11:00:00Z",
-            "findings", List.of("设备正常", "无异常发现"),
-            "issues_found", 0,
-            "distance_covered", 5.2
-        );
-        
-        boolean reported = patrolManager.submitReport(reportData);
-        assertTrue(reported, "巡检上报应该成功");
-        
-        // 验证完成状态
-        Map<String, Object> task = patrolManager.getTask(taskId);
-        assertEquals("completed", task.get("status"));
-    }
-    
-    @Test
-    void testTaskPriority() {
-        Map<String, Object> highPriorityTask = Map.of(
-            "task_id", "patrol-005",
-            "task_name", "高优先级任务",
-            "priority", "high"
-        );
-        
-        String taskId = patrolManager.createTask(highPriorityTask);
-        Map<String, Object> task = patrolManager.getTask(taskId);
-        assertEquals("high", task.get("priority"));
-        
-        // 验证高优先级任务在队列中的位置
-        List<Map<String, Object>> queue = patrolManager.getTaskQueue();
-        assertTrue(queue.stream().anyMatch(t -> t.get("task_id").equals(taskId)), 
-                  "高优先级任务应该在队列中");
-    }
-}

wm-patrol/src/main/resources/mapper/PatrolProblemMapper.xml

     </resultMap>
 
     <insert id="insert" parameterType="com.water.patrol.entity.PatrolProblem">
-        INSERT INTO patrol_problem (
+        INSERT INTO pat_problem (
             problem_no, task_id, point_seq, device_id, device_name,
             problem_type, problem_level, problem_title, problem_description,
             location, lng, lat, photo_urls, reporter_id, reporter_name,
     </insert>
 
     <select id="selectById" resultMap="BaseResultMap">
-        SELECT * FROM patrol_problem WHERE id = #{id}
+        SELECT * FROM pat_problem WHERE id = #{id}
     </select>
 
     <select id="selectByProblemNo" resultMap="BaseResultMap">
-        SELECT * FROM patrol_problem WHERE problem_no = #{problemNo}
+        SELECT * FROM pat_problem WHERE problem_no = #{problemNo}
     </select>
 
     <select id="selectByTaskId" resultMap="BaseResultMap">
-        SELECT * FROM patrol_problem WHERE task_id = #{taskId} ORDER BY created_at DESC
+        SELECT * FROM pat_problem WHERE task_id = #{taskId} ORDER BY created_at DESC
     </select>
 
     <select id="selectByStatus" resultMap="BaseResultMap">
-        SELECT * FROM patrol_problem WHERE status = #{status} ORDER BY created_at DESC
+        SELECT * FROM pat_problem WHERE status = #{status} ORDER BY created_at DESC
     </select>
 
     <select id="selectByDeviceId" resultMap="BaseResultMap">
-        SELECT * FROM patrol_problem WHERE device_id = #{deviceId} ORDER BY created_at DESC
+        SELECT * FROM pat_problem WHERE device_id = #{deviceId} ORDER BY created_at DESC
     </select>
 
     <update id="update" parameterType="com.water.patrol.entity.PatrolProblem">
-        UPDATE patrol_problem SET
+        UPDATE pat_problem SET
             problem_type = #{problemType},
             problem_level = #{problemLevel},
             problem_title = #{problemTitle},
             photo_urls = #{photoUrls},
             status = #{status},
             work_order_id = #{workOrderId},
-            updated_at = #{updatedAt}
+            updated_at = NOW()
         WHERE id = #{id}
     </update>
 
     <update id="updateStatus">
-        UPDATE patrol_problem SET
+        UPDATE pat_problem SET
             status = #{status},
             work_order_id = #{workOrderId},
-            updated_at = #{updatedAt}
+            updated_at = NOW()
         WHERE id = #{id}
     </update>
 
     <delete id="deleteById">
-        DELETE FROM patrol_problem WHERE id = #{id}
+        DELETE FROM pat_problem WHERE id = #{id}
     </delete>
 
     <select id="generateProblemNo" resultType="string">
-        SELECT 'WQ' || to_char(NOW(), 'YYYY') || '-' || LPAD(nextval('seq_patrol_problem')::text, 3, '0')
+        SELECT 'WQ' || to_char(NOW(), 'YYYY') || '-' || LPAD(nextval('seq_pat_problem')::text, 3, '0')
     </select>
 
     <select id="countAll" resultType="int">
-        SELECT COUNT(*) FROM patrol_problem
+        SELECT COUNT(*) FROM pat_problem
     </select>
 
     <select id="countByStatus" resultType="int">
-        SELECT COUNT(*) FROM patrol_problem WHERE status = #{status}
+        SELECT COUNT(*) FROM pat_problem WHERE status = #{status}
     </select>
 
 </mapper>

wm-patrol/src/main/resources/mapper/WorkOrderMapper.xml

     </resultMap>
 
     <insert id="insert" parameterType="com.water.patrol.entity.WorkOrder">
-        INSERT INTO work_order (
+        INSERT INTO pat_wo_detail (
             order_no, problem_id, order_type, priority, title, description,
             location, contact_person, contact_phone, reporter_id, reporter_name,
             assignee_id, assignee_name, status, process_status,
     </insert>
 
     <select id="selectById" resultMap="BaseResultMap">
-        SELECT * FROM work_order WHERE id = #{id}
+        SELECT * FROM pat_wo_detail WHERE id = #{id}
     </select>
 
     <select id="selectByOrderNo" resultMap="BaseResultMap">
-        SELECT * FROM work_order WHERE order_no = #{orderNo}
+        SELECT * FROM pat_wo_detail WHERE order_no = #{orderNo}
     </select>
 
     <select id="selectByProblemId" resultMap="BaseResultMap">
-        SELECT * FROM work_order WHERE problem_id = #{problemId}
+        SELECT * FROM pat_wo_detail WHERE problem_id = #{problemId}
     </select>
 
     <select id="selectByStatus" resultMap="BaseResultMap">
-        SELECT * FROM work_order WHERE status = #{status} ORDER BY created_at DESC
+        SELECT * FROM pat_wo_detail WHERE status = #{status} ORDER BY created_at DESC
     </select>
 
     <select id="selectByAssigneeId" resultMap="BaseResultMap">
-        SELECT * FROM work_order WHERE assignee_id = #{assigneeId} ORDER BY created_at DESC
+        SELECT * FROM pat_wo_detail WHERE assignee_id = #{assigneeId} ORDER BY created_at DESC
     </select>
 
     <select id="selectByProcessStatus" resultMap="BaseResultMap">
-        SELECT * FROM work_order WHERE process_status = #{processStatus} ORDER BY created_at DESC
+        SELECT * FROM pat_wo_detail WHERE process_status = #{processStatus} ORDER BY created_at DESC
     </select>
 
     <update id="update" parameterType="com.water.patrol.entity.WorkOrder">
-        UPDATE work_order SET
+        UPDATE pat_wo_detail SET
             order_type = #{orderType},
             priority = #{priority},
             title = #{title},
             solution_description = #{solutionDescription},
             solution_result = #{solutionResult},
             customer_feedback = #{customerFeedback},
-            updated_at = #{updatedAt}
+            updated_at = NOW()
         WHERE id = #{id}
     </update>
 
     <update id="updateStatus">
-        UPDATE work_order SET
+        UPDATE pat_wo_detail SET
             status = #{status},
             process_status = #{processStatus},
-            updated_at = #{updatedAt}
+            updated_at = NOW()
         WHERE id = #{id}
     </update>
 
     <update id="updateAssignee">
-        UPDATE work_order SET
+        UPDATE pat_wo_detail SET
             assignee_id = #{assigneeId},
             assignee_name = #{assigneeName},
-            updated_at = #{updatedAt}
+            updated_at = NOW()
         WHERE id = #{id}
     </update>
 
     <update id="updateCompletion">
-        UPDATE work_order SET
+        UPDATE pat_wo_detail SET
             actual_end_time = #{actualEndTime},
             completion_time = #{completionTime},
             solution_result = #{solutionResult},
-            updated_at = #{updatedAt}
+            updated_at = NOW()
         WHERE id = #{id}
     </update>
 
     <delete id="deleteById">
-        DELETE FROM work_order WHERE id = #{id}
+        DELETE FROM pat_wo_detail WHERE id = #{id}
     </delete>
 
     <select id="generateOrderNo" resultType="string">
-        SELECT 'WO' || to_char(NOW(), 'YYYY') || '-' || LPAD(nextval('seq_work_order')::text, 3, '0')
+        SELECT 'WO' || to_char(NOW(), 'YYYY') || '-' || LPAD(nextval('seq_pat_wo_detail')::text, 3, '0')
     </select>
 
     <select id="countAll" resultType="int">
-        SELECT COUNT(*) FROM work_order
+        SELECT COUNT(*) FROM pat_wo_detail
     </select>
 
     <select id="countByStatus" resultType="int">
-        SELECT COUNT(*) FROM work_order WHERE status = #{status}
+        SELECT COUNT(*) FROM pat_wo_detail WHERE status = #{status}
     </select>
 
     <select id="countByProcessStatus" resultType="int">
-        SELECT COUNT(*) FROM work_order WHERE process_status = #{processStatus}
+        SELECT COUNT(*) FROM pat_wo_detail WHERE process_status = #{processStatus}
     </select>
 
 </mapper>

wm-patrol/src/main/resources/mapper/WorkOrderProcessMapper.xml

     </resultMap>
 
     <insert id="insert" parameterType="com.water.patrol.entity.WorkOrderProcess">
-        INSERT INTO work_order_process (
+        INSERT INTO pat_wo_process (
             work_order_id, process_step, processor_id, processor_name,
             action, comment, photos, created_at
         ) VALUES (
     </insert>
 
     <select id="selectById" resultMap="BaseResultMap">
-        SELECT * FROM work_order_process WHERE id = #{id}
+        SELECT * FROM pat_wo_process WHERE id = #{id}
     </select>
 
     <select id="selectByWorkOrderId" resultMap="BaseResultMap">
-        SELECT * FROM work_order_process WHERE work_order_id = #{workOrderId} ORDER BY created_at DESC
+        SELECT * FROM pat_wo_process WHERE work_order_id = #{workOrderId} ORDER BY created_at DESC
     </select>
 
     <select id="selectLatestByWorkOrderId" resultMap="BaseResultMap">
-        SELECT * FROM work_order_process 
+        SELECT * FROM pat_wo_process 
         WHERE work_order_id = #{workOrderId} 
         ORDER BY created_at DESC LIMIT 1
     </select>
 
     <delete id="deleteById">
-        DELETE FROM work_order_process WHERE id = #{id}
+        DELETE FROM pat_wo_process WHERE id = #{id}
     </delete>
 
 </mapper>

wm-patrol/src/main/resources/sql/V89__patrol_fix.sql

+-- V89: Issue #15 QA Fix - Add missing columns and tables for patrol module
+
+-- ========== Add missing columns to pat_task ==========
+ALTER TABLE pat_task ADD COLUMN IF NOT EXISTS task_date DATE;
+ALTER TABLE pat_task ADD COLUMN IF NOT EXISTS assignee_id BIGINT;
+ALTER TABLE pat_task ADD COLUMN IF NOT EXISTS plan_start TIMESTAMPTZ;
+ALTER TABLE pat_task ADD COLUMN IF NOT EXISTS plan_end TIMESTAMPTZ;
+ALTER TABLE pat_task ADD COLUMN IF NOT EXISTS actual_start TIMESTAMPTZ;
+ALTER TABLE pat_task ADD COLUMN IF NOT EXISTS actual_end TIMESTAMPTZ;
+CREATE INDEX IF NOT EXISTS idx_pat_task_date ON pat_task(task_date);
+CREATE INDEX IF NOT EXISTS idx_pat_task_assignee ON pat_task(assignee_id);
+
+-- ========== Add missing columns to pat_route_setup ==========
+ALTER TABLE pat_route_setup ADD COLUMN IF NOT EXISTS route_points TEXT;
+ALTER TABLE pat_route_setup ADD COLUMN IF NOT EXISTS estim_duration INT;
+ALTER TABLE pat_route_setup ADD COLUMN IF NOT EXISTS area VARCHAR(100);
+
+-- ========== Add missing column to pat_track_point ==========
+ALTER TABLE pat_track_point ADD COLUMN IF NOT EXISTS recorded_at TIMESTAMPTZ DEFAULT NOW();
+
+-- ========== Add missing column to pat_device ==========
+ALTER TABLE pat_device ADD COLUMN IF NOT EXISTS area VARCHAR(100);
+
+-- ========== Create pat_record table (巡检记录) ==========
+CREATE TABLE IF NOT EXISTS pat_record (
+    id BIGSERIAL PRIMARY KEY,
+    task_id BIGINT NOT NULL,
+    point_seq INT,
+    device_id BIGINT,
+    check_items TEXT,
+    gps_lng NUMERIC(10,6),
+    gps_lat NUMERIC(10,6),
+    record_time TIMESTAMPTZ DEFAULT NOW()
+);
+CREATE INDEX IF NOT EXISTS idx_pat_record_task ON pat_record(task_id);
+
+-- ========== Create pat_problem table (巡检问题) ==========
+CREATE TABLE IF NOT EXISTS pat_problem (
+    id BIGSERIAL PRIMARY KEY,
+    problem_no VARCHAR(32) UNIQUE NOT NULL,
+    task_id BIGINT,
+    point_seq INT,
+    device_id BIGINT,
+    device_name VARCHAR(100),
+    problem_type VARCHAR(30),
+    problem_level VARCHAR(20),
+    problem_title VARCHAR(200),
+    problem_description TEXT,
+    location VARCHAR(200),
+    lng DOUBLE PRECISION,
+    lat DOUBLE PRECISION,
+    photo_urls TEXT,
+    reporter_id BIGINT,
+    reporter_name VARCHAR(50),
+    report_time TIMESTAMPTZ,
+    status VARCHAR(20) DEFAULT 'reported',
+    work_order_id BIGINT,
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+CREATE INDEX IF NOT EXISTS idx_pat_problem_task ON pat_problem(task_id);
+CREATE INDEX IF NOT EXISTS idx_pat_problem_status ON pat_problem(status);
+CREATE INDEX IF NOT EXISTS idx_pat_problem_device ON pat_problem(device_id);
+CREATE SEQUENCE IF NOT EXISTS seq_patrol_problem START 1;
+
+-- ========== Create pat_wo_detail table (工单详情) ==========
+CREATE TABLE IF NOT EXISTS pat_wo_detail (
+    id BIGSERIAL PRIMARY KEY,
+    order_no VARCHAR(32) UNIQUE NOT NULL,
+    problem_id BIGINT,
+    order_type VARCHAR(30),
+    priority VARCHAR(20) DEFAULT 'normal',
+    title VARCHAR(200),
+    description TEXT,
+    location VARCHAR(200),
+    contact_person VARCHAR(50),
+    contact_phone VARCHAR(20),
+    reporter_id BIGINT,
+    reporter_name VARCHAR(50),
+    assignee_id BIGINT,
+    assignee_name VARCHAR(50),
+    status VARCHAR(20) DEFAULT 'pending',
+    process_status VARCHAR(20) DEFAULT 'created',
+    estimated_duration INT,
+    actual_start_time TIMESTAMPTZ,
+    actual_end_time TIMESTAMPTZ,
+    completion_time TIMESTAMPTZ,
+    photos_before TEXT,
+    photos_after TEXT,
+    solution_description TEXT,
+    solution_result TEXT,
+    customer_feedback TEXT,
+    created_at TIMESTAMPTZ DEFAULT NOW(),
+    updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+CREATE INDEX IF NOT EXISTS idx_pat_wo_detail_status ON pat_wo_detail(status);
+CREATE INDEX IF NOT EXISTS idx_pat_wo_detail_assignee ON pat_wo_detail(assignee_id);
+CREATE INDEX IF NOT EXISTS idx_pat_wo_detail_problem ON pat_wo_detail(problem_id);
+CREATE SEQUENCE IF NOT EXISTS seq_pat_wo_detail START 1;
+
+-- ========== Create pat_wo_process table (工单处理记录) ==========
+CREATE TABLE IF NOT EXISTS pat_wo_process (
+    id BIGSERIAL PRIMARY KEY,
+    work_order_id BIGINT NOT NULL,
+    process_step VARCHAR(30),
+    processor_id BIGINT,
+    processor_name VARCHAR(50),
+    action VARCHAR(30),
+    comment TEXT,
+    photos TEXT,
+    created_at TIMESTAMPTZ DEFAULT NOW()
+);
+CREATE INDEX IF NOT EXISTS idx_pat_wo_process_wo ON pat_wo_process(work_order_id);

wm-patrol/src/test/java/com/water/patrol/PatrolCoreWoServiceTest.java

+package com.water.patrol;
+
+import com.water.patrol.service.PatrolCoreService;
+import com.water.patrol.service.PatrolWoService;
+import com.water.patrol.service.PatrolService;
+import com.water.patrol.service.PatrolOverviewService;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.*;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+import java.time.LocalDate;
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+/**
+ * Issue #15 QA Fix - Tests for JdbcTemplate-based services
+ * Verifies table name fixes (patrol_* -> pat_*) and core logic
+ */
+@ExtendWith(MockitoExtension.class)
+class PatrolCoreWoServiceTest {
+
+    @Mock JdbcTemplate jdbc;
+
+    @InjectMocks PatrolCoreService coreSvc;
+    @InjectMocks PatrolWoService woSvc;
+    @InjectMocks PatrolService patrolSvc;
+    @InjectMocks PatrolOverviewService overviewSvc;
+
+    // ========== PatrolCoreService Tests ==========
+
+    @Test
+    void testGetOverview() {
+        when(jdbc.queryForObject(anyString(), eq(Long.class), any())).thenReturn(5L);
+        Map<String, Object> result = coreSvc.getOverview();
+        assertNotNull(result);
+        assertEquals(5L, result.get("todayTotal"));
+        assertEquals(5L, result.get("todayCompleted"));
+    }
+
+    @Test
+    void testGetTodayTasks() {
+        List<Map<String, Object>> mockRows = List.of(
+            Map.of("id", 1, "task_no", "PAT-001", "route_name", "路线A")
+        );
+        when(jdbc.queryForList(anyString(), any())).thenReturn(mockRows);
+        List<Map<String, Object>> result = coreSvc.getTodayTasks();
+        assertEquals(1, result.size());
+    }
+
+    @Test
+    void testRecordTrackPoint() {
+        Map<String, Object> result = coreSvc.recordTrackPoint(1L, 100L, 116.4, 39.9, 5.0, 3.0);
+        assertNotNull(result);
+        assertEquals(1L, result.get("taskId"));
+        assertEquals(true, result.get("recorded"));
+        verify(jdbc).update(contains("pat_track_point"), eq(1L), eq(100L), eq(116.4), eq(39.9), eq(5.0), eq(3.0));
+    }
+
+    @Test
+    void testGetTrack() {
+        when(jdbc.queryForList(anyString(), eq(1L))).thenReturn(Collections.emptyList());
+        List<Map<String, Object>> result = coreSvc.getTrack(1L);
+        assertNotNull(result);
+        verify(jdbc).queryForList(contains("pat_track_point"), eq(1L));
+    }
+
+    @Test
+    void testReplayTrack_empty() {
+        when(jdbc.queryForList(anyString(), eq(1L))).thenReturn(Collections.emptyList());
+        Map<String, Object> result = coreSvc.replayTrack(1L);
+        assertEquals(0, result.get("totalPoints"));
+    }
+
+    @Test
+    void testReplayTrack_withPoints() {
+        List<Map<String, Object>> points = new ArrayList<>();
+        Map<String, Object> p1 = new HashMap<>();
+        p1.put("recorded_at", "2026-06-17T10:00:00");
+        p1.put("lat", 39.9);
+        p1.put("lng", 116.4);
+        p1.put("speed", 5.0);
+        Map<String, Object> p2 = new HashMap<>();
+        p2.put("recorded_at", "2026-06-17T10:05:00");
+        p2.put("lat", 39.91);
+        p2.put("lng", 116.41);
+        p2.put("speed", 6.0);
+        points.add(p1);
+        points.add(p2);
+        when(jdbc.queryForList(anyString(), eq(1L))).thenReturn(points);
+
+        Map<String, Object> result = coreSvc.replayTrack(1L);
+        assertEquals(2, result.get("totalPoints"));
+    }
+
+    @Test
+    void testGetTrackStats_singlePoint() {
+        when(jdbc.queryForList(anyString(), eq(1L))).thenReturn(List.of(Map.of("lat", 39.9, "lng", 116.4)));
+        Map<String, Object> stats = coreSvc.getTrackStats(1L);
+        assertEquals(1, stats.get("totalPoints"));
+        assertEquals(0.0, stats.get("totalDistance"));
+    }
+
+    @Test
+    void testGetTaskLedger() {
+        when(jdbc.queryForList(anyString(), any(Object[].class))).thenReturn(Collections.emptyList());
+        when(jdbc.queryForObject(anyString(), eq(Long.class), any(Object[].class))).thenReturn(0L);
+        Map<String, Object> result = coreSvc.getTaskLedger(null, null, 1, 10);
+        assertNotNull(result);
+        assertEquals(0L, result.get("total"));
+        verify(jdbc).queryForList(contains("pat_task"), any(Object[].class));
+    }
+
+    @Test
+    void testGetDeviceLedger() {
+        when(jdbc.queryForList(anyString(), any(Object[].class))).thenReturn(Collections.emptyList());
+        when(jdbc.queryForObject(anyString(), eq(Long.class), any(Object[].class))).thenReturn(0L);
+        Map<String, Object> result = coreSvc.getDeviceLedger(null, null, null, 1, 10);
+        assertNotNull(result);
+        verify(jdbc).queryForList(contains("pat_device"), any(Object[].class));
+    }
+
+    @Test
+    void testCreateDevice() {
+        Map<String, Object> result = coreSvc.createDevice("DEV-001", "阀门A", "valve", "A区", 116.0, 39.0, "A区");
+        assertNotNull(result);
+        assertEquals("DEV-001", result.get("deviceNo"));
+        verify(jdbc).update(contains("pat_device"), any(), any(), any(), any(), any(), any(), any());
+    }
+
+    @Test
+    void testUpdateDeviceStatus() {
+        when(jdbc.update(anyString(), any(), any())).thenReturn(1);
+        Map<String, Object> result = coreSvc.updateDeviceStatus(1L, "fault");
+        assertEquals("fault", result.get("status"));
+        verify(jdbc).update(contains("pat_device"), eq("fault"), eq(1L));
+    }
+
+    // ========== PatrolWoService Tests ==========
+
+    @Test
+    void testWoCreate() {
+        Map<String, Object> result = woSvc.create("leak", "管道漏水", "high", "A区", 116.0, 39.0, 1L);
+        assertNotNull(result);
+        assertTrue(result.get("orderNo").toString().startsWith("PWO-"));
+        assertEquals("pending", result.get("status"));
+        verify(jdbc).update(contains("pat_work_order"), any(), any(), any(), any(), any(), any(), any(), any());
+    }
+
+    @Test
+    void testWoAssign() {
+        when(jdbc.update(anyString(), any(), any(), any())).thenReturn(1);
+        Map<String, Object> result = woSvc.assign(1L, 200L, "李四");
+        assertEquals(true, result.get("success"));
+        verify(jdbc).update(contains("pat_work_order"), eq(200L), eq("李四"), eq(1L));
+    }
+
+    @Test
+    void testWoProcess() {
+        when(jdbc.update(anyString(), any(), any())).thenReturn(1);
+        Map<String, Object> result = woSvc.process(1L, "处理中");
+        assertEquals(true, result.get("success"));
+        verify(jdbc).update(contains("pat_work_order"), eq("处理中"), eq(1L));
+    }
+
+    @Test
+    void testWoResolve() {
+        when(jdbc.update(anyString(), any())).thenReturn(1);
+        Map<String, Object> result = woSvc.resolve(1L);
+        assertEquals(true, result.get("success"));
+        verify(jdbc).update(contains("pat_work_order"), eq(1L));
+    }
+
+    @Test
+    void testWoGetDetail() {
+        Map<String, Object> mockRow = new HashMap<>();
+        mockRow.put("id", 1);
+        mockRow.put("order_no", "PWO-001");
+        when(jdbc.queryForList(anyString(), eq(1L))).thenReturn(List.of(mockRow));
+        Map<String, Object> result = woSvc.getDetail(1L);
+        assertNotNull(result);
+        assertEquals("PWO-001", result.get("order_no"));
+    }
+
+    @Test
+    void testWoGetDetail_notFound() {
+        when(jdbc.queryForList(anyString(), eq(999L))).thenReturn(Collections.emptyList());
+        Map<String, Object> result = woSvc.getDetail(999L);
+        assertNull(result);
+    }
+
+    @Test
+    void testWoList() {
+        when(jdbc.queryForList(anyString(), any(Object[].class))).thenReturn(Collections.emptyList());
+        when(jdbc.queryForObject(anyString(), eq(Long.class), any(Object[].class))).thenReturn(0L);
+        Map<String, Object> result = woSvc.list(null, null, 1, 10);
+        assertNotNull(result);
+        assertEquals(0L, result.get("total"));
+        verify(jdbc).queryForList(contains("pat_work_order"), any(Object[].class));
+    }
+
+    @Test
+    void testWoStats() {
+        List<Map<String, Object>> mockRows = List.of(
+            Map.of("status", "pending", "count", 5L),
+            Map.of("status", "resolved", "count", 10L)
+        );
+        when(jdbc.queryForList(anyString())).thenReturn(mockRows);
+        Map<String, Object> result = woSvc.stats();
+        assertEquals(5L, result.get("pending"));
+        assertEquals(10L, result.get("resolved"));
+    }
+
+    // ========== PatrolService Tests ==========
+
+    @Test
+    void testCreateRoute() {
+        List<Map<String, Object>> points = List.of(Map.of("lng", 116.0, "lat", 39.0));
+        Map<String, Object> result = patrolSvc.createRoute("路线A", "A区", points, 60);
+        assertNotNull(result);
+        assertEquals("路线A", result.get("routeName"));
+        verify(jdbc).update(contains("pat_route_setup"), any(), any(), any(), any());
+    }
+
+    @Test
+    void testGetRoutes() {
+        when(jdbc.queryForList(anyString(), eq("A区"))).thenReturn(Collections.emptyList());
+        List<Map<String, Object>> result = patrolSvc.getRoutes("A区");
+        assertNotNull(result);
+        verify(jdbc).queryForList(contains("pat_route_setup"), eq("A区"));
+    }
+
+    @Test
+    void testCreateTask() {
+        Map<String, Object> result = patrolSvc.createTask(1L, 100L, "2026-06-17");
+        assertNotNull(result);
+        assertEquals("created", result.get("status"));
+        verify(jdbc).update(contains("pat_task"), any(), any(), any(), any(), any(), any());
+    }
+
+    @Test
+    void testGetTodayTasks() {
+        when(jdbc.queryForList(anyString(), eq(100L))).thenReturn(Collections.emptyList());
+        List<Map<String, Object>> result = patrolSvc.getTodayTasks(100L);
+        assertNotNull(result);
+        verify(jdbc).queryForList(contains("pat_task"), eq(100L));
+    }
+
+    @Test
+    void testStartTask() {
+        Map<String, Object> result = patrolSvc.startTask(1L);
+        assertEquals("in_progress", result.get("status"));
+        verify(jdbc).update(contains("pat_task"), eq(1L));
+    }
+
+    @Test
+    void testCompleteTask() {
+        Map<String, Object> result = patrolSvc.completeTask(1L, 5000.0);
+        assertEquals("completed", result.get("status"));
+        assertEquals(5000.0, result.get("distance"));
+        verify(jdbc).update(contains("pat_task"), eq(5000.0), eq(1L));
+    }
+
+    @Test
+    void testRecordCheck() {
+        List<Map<String, Object>> items = List.of(Map.of("item", "阀门", "result", "正常"));
+        Map<String, Object> result = patrolSvc.recordCheck(1L, 1, 10L, items, 116.0, 39.0);
+        assertEquals(true, result.get("recorded"));
+        verify(jdbc).update(contains("pat_record"), any(), any(), any(), any(), any(), any());
+    }
+
+    @Test
+    void testGetTaskRecords() {
+        when(jdbc.queryForList(anyString(), eq(1L))).thenReturn(Collections.emptyList());
+        List<Map<String, Object>> result = patrolSvc.getTaskRecords(1L);
+        assertNotNull(result);
+        verify(jdbc).queryForList(contains("pat_record"), eq(1L));
+    }
+
+    @Test
+    void testReportIssue() {
+        Map<String, Object> result = patrolSvc.reportIssue(1L, 10L, "leak", "管道漏水",
+            List.of("photo1.jpg"), 116.0, 39.0);
+        assertEquals(true, result.get("reported"));
+        assertEquals("leak", result.get("issueType"));
+    }
+
+    @Test
+    void testGetStats() {
+        Map<String, Object> countMap = new HashMap<>();
+        countMap.put("total", 10);
+        countMap.put("completed", 5);
+        when(jdbc.queryForMap(anyString(), any(), any())).thenReturn(countMap);
+        when(jdbc.queryForList(anyString(), any(), any())).thenReturn(Collections.emptyList());
+
+        Map<String, Object> result = patrolSvc.getStats("A区", LocalDate.of(2026, 1, 1), LocalDate.of(2026, 6, 17));
+        assertNotNull(result);
+        assertNotNull(result.get("completionRate"));
+        assertNotNull(result.get("personDistance"));
+        assertNotNull(result.get("workload"));
+        assertNotNull(result.get("issueStats"));
+    }
+
+    // ========== PatrolOverviewService Tests ==========
+
+    @Test
+    void testOverviewGetOverview() {
+        when(jdbc.queryForObject(anyString(), eq(Integer.class), any())).thenReturn(10);
+        when(jdbc.queryForObject(anyString(), eq(Double.class), any())).thenReturn(5000.0);
+        Map<String, Object> result = overviewSvc.getOverview();
+        assertNotNull(result);
+        assertEquals(10, result.get("todayTasks"));
+    }
+
+    @Test
+    void testOverviewGetMonthlyStats() {
+        when(jdbc.queryForObject(anyString(), eq(Integer.class), any(), any())).thenReturn(100);
+        when(jdbc.queryForObject(anyString(), eq(Double.class), any(), any())).thenReturn(50000.0);
+        Map<String, Object> result = overviewSvc.getMonthlyStats(2026, 6);
+        assertNotNull(result);
+        assertEquals(100, result.get("totalTasks"));
+    }
+}

wm-patrol/src/test/java/com/water/patrol/PatrolProblemWorkOrderTest.java

+package com.water.patrol;
+
+import com.water.patrol.entity.PatrolProblem;
+import com.water.patrol.entity.WorkOrder;
+import com.water.patrol.entity.WorkOrderProcess;
+import com.water.patrol.mapper.PatrolProblemMapper;
+import com.water.patrol.mapper.WorkOrderMapper;
+import com.water.patrol.mapper.WorkOrderProcessMapper;
+import com.water.patrol.service.WorkOrderService;
+import com.water.patrol.service.impl.PatrolProblemServiceImpl;
+import com.water.patrol.service.impl.WorkOrderServiceImpl;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.*;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+/**
+ * Issue #15 QA Fix - Tests for PatrolProblemServiceImpl and WorkOrderServiceImpl
+ */
+@ExtendWith(MockitoExtension.class)
+class PatrolProblemWorkOrderTest {
+
+    @Mock PatrolProblemMapper problemMapper;
+    @Mock WorkOrderMapper woMapper;
+    @Mock WorkOrderProcessMapper woProcessMapper;
+
+    @InjectMocks PatrolProblemServiceImpl problemSvc;
+    @InjectMocks WorkOrderServiceImpl woSvc;
+
+    // ========== PatrolProblemServiceImpl Tests ==========
+
+    @Test
+    void testCreateProblem() {
+        when(problemMapper.generateProblemNo()).thenReturn("WQ2026-001");
+        when(problemMapper.insert(any())).thenReturn(1);
+        when(problemMapper.updateStatus(anyLong(), anyString(), anyLong())).thenReturn(1);
+        when(woMapper.generateOrderNo()).thenReturn("WO2026-001");
+        when(woMapper.insert(any())).thenReturn(1);
+        when(woProcessMapper.insert(any())).thenReturn(1);
+
+        PatrolProblem p = new PatrolProblem();
+        p.setProblemType("设备故障");
+        p.setProblemLevel("high");
+        p.setProblemTitle("阀门漏水");
+        p.setProblemDescription("主管道阀门A严重漏水");
+        p.setLocation("A区");
+        p.setReporterId(100L);
+        p.setReporterName("张三");
+
+        PatrolProblem result = problemSvc.createProblem(p);
+        assertNotNull(result);
+        assertEquals("WQ2026-001", result.getProblemNo());
+        assertEquals("reported", result.getStatus());
+        verify(problemMapper).insert(any());
+    }
+
+    @Test
+    void testGetProblemById() {
+        PatrolProblem p = new PatrolProblem();
+        p.setId(1L);
+        p.setProblemNo("WQ2026-001");
+        when(problemMapper.selectById(1L)).thenReturn(p);
+
+        PatrolProblem result = problemSvc.getProblemById(1L);
+        assertNotNull(result);
+        assertEquals("WQ2026-001", result.getProblemNo());
+    }
+
+    @Test
+    void testGetProblemByProblemNo() {
+        PatrolProblem p = new PatrolProblem();
+        p.setProblemNo("WQ2026-002");
+        when(problemMapper.selectByProblemNo("WQ2026-002")).thenReturn(p);
+
+        PatrolProblem result = problemSvc.getProblemByProblemNo("WQ2026-002");
+        assertNotNull(result);
+        assertEquals("WQ2026-002", result.getProblemNo());
+    }
+
+    @Test
+    void testGetProblemsByTaskId() {
+        when(problemMapper.selectByTaskId(1L)).thenReturn(List.of(new PatrolProblem()));
+        List<PatrolProblem> results = problemSvc.getProblemsByTaskId(1L);
+        assertEquals(1, results.size());
+    }
+
+    @Test
+    void testGetProblemsByStatus() {
+        when(problemMapper.selectByStatus("reported")).thenReturn(List.of(new PatrolProblem(), new PatrolProblem()));
+        List<PatrolProblem> results = problemSvc.getProblemsByStatus("reported");
+        assertEquals(2, results.size());
+    }
+
+    @Test
+    void testGetProblemsByDeviceId() {
+        when(problemMapper.selectByDeviceId(10L)).thenReturn(Collections.emptyList());
+        List<PatrolProblem> results = problemSvc.getProblemsByDeviceId(10L);
+        assertTrue(results.isEmpty());
+    }
+
+    @Test
+    void testUpdateProblemStatus() {
+        when(problemMapper.updateStatus(1L, "processing", 200L)).thenReturn(1);
+        boolean result = problemSvc.updateProblemStatus(1L, "processing", 200L);
+        assertTrue(result);
+    }
+
+    @Test
+    void testDeleteProblem() {
+        when(problemMapper.deleteById(1L)).thenReturn(1);
+        boolean result = problemSvc.deleteProblem(1L);
+        assertTrue(result);
+    }
+
+    @Test
+    void testGetProblemStatistics() {
+        when(problemMapper.countAll()).thenReturn(100);
+        when(problemMapper.countByStatus("reported")).thenReturn(30);
+        when(problemMapper.countByStatus("processing")).thenReturn(20);
+        when(problemMapper.countByStatus("completed")).thenReturn(40);
+        when(problemMapper.countByStatus("closed")).thenReturn(10);
+
+        PatrolProblemServiceImpl.ProblemStatistics stats = problemSvc.getProblemStatistics();
+        assertEquals(100, stats.getTotalProblems());
+        assertEquals(30, stats.getReportedCount());
+        assertEquals(20, stats.getProcessingCount());
+        assertEquals(40, stats.getCompletedCount());
+        assertEquals(10, stats.getClosedCount());
+    }
+
+    @Test
+    void testAutoCreateWorkOrder_problemNotFound() {
+        when(problemMapper.selectById(999L)).thenReturn(null);
+        boolean result = problemSvc.autoCreateWorkOrder(999L);
+        assertFalse(result);
+    }
+
+    @Test
+    void testAutoCreateWorkOrder_success() {
+        PatrolProblem p = new PatrolProblem();
+        p.setId(1L);
+        p.setProblemType("设备故障");
+        p.setProblemLevel("high");
+        p.setProblemTitle("阀门漏水");
+        p.setProblemDescription("描述");
+        p.setLocation("A区");
+        p.setReporterId(100L);
+        p.setReporterName("张三");
+
+        when(problemMapper.selectById(1L)).thenReturn(p);
+        when(woMapper.generateOrderNo()).thenReturn("WO2026-001");
+        when(woMapper.insert(any())).thenReturn(1);
+        when(woProcessMapper.insert(any())).thenReturn(1);
+        when(problemMapper.updateStatus(anyLong(), anyString(), anyLong())).thenReturn(1);
+
+        boolean result = problemSvc.autoCreateWorkOrder(1L);
+        assertTrue(result);
+    }
+
+    // ========== WorkOrderServiceImpl Tests ==========
+
+    @Test
+    void testCreateFromProblem() {
+        PatrolProblem problem = new PatrolProblem();
+        problem.setId(1L);
+        problem.setProblemType("设备故障");
+        problem.setProblemLevel("critical");
+        problem.setProblemTitle("紧急维修");
+        problem.setProblemDescription("管道爆裂");
+        problem.setLocation("B区");
+        problem.setReporterId(100L);
+        problem.setReporterName("张三");
+
+        when(woMapper.generateOrderNo()).thenReturn("WO2026-001");
+        when(woMapper.insert(any())).thenReturn(1);
+        when(woProcessMapper.insert(any())).thenReturn(1);
+        when(problemMapper.updateStatus(anyLong(), anyString(), anyLong())).thenReturn(1);
+
+        boolean result = woSvc.createFromProblem(problem);
+        assertTrue(result);
+        verify(woMapper).insert(any());
+        verify(woProcessMapper).insert(any());
+        verify(problemMapper).updateStatus(eq(1L), eq("processing"), anyLong());
+    }
+
+    @Test
+    void testGetWorkOrderById() {
+        WorkOrder wo = new WorkOrder();
+        wo.setId(1L);
+        wo.setOrderNo("WO2026-001");
+        when(woMapper.selectById(1L)).thenReturn(wo);
+
+        WorkOrder result = woSvc.getWorkOrderById(1L);
+        assertNotNull(result);
+        assertEquals("WO2026-001", result.getOrderNo());
+    }
+
+    @Test
+    void testGetWorkOrderByOrderNo() {
+        WorkOrder wo = new WorkOrder();
+        wo.setOrderNo("WO2026-002");
+        when(woMapper.selectByOrderNo("WO2026-002")).thenReturn(wo);
+
+        WorkOrder result = woSvc.getWorkOrderByOrderNo("WO2026-002");
+        assertNotNull(result);
+    }
+
+    @Test
+    void testGetWorkOrdersByStatus() {
+        when(woMapper.selectByStatus("pending")).thenReturn(List.of(new WorkOrder()));
+        List<WorkOrder> results = woSvc.getWorkOrdersByStatus("pending");
+        assertEquals(1, results.size());
+    }
+
+    @Test
+    void testAssignWorkOrder() {
+        WorkOrder wo = new WorkOrder();
+        wo.setId(1L);
+        wo.setStatus("pending");
+
+        when(woMapper.updateAssignee(1L, 200L, "李四")).thenReturn(1);
+        when(woMapper.selectById(1L)).thenReturn(wo);
+        when(woProcessMapper.insert(any())).thenReturn(1);
+        when(woMapper.updateStatus(1L, "assigned", "accepted")).thenReturn(1);
+
+        boolean result = woSvc.assignWorkOrder(1L, 200L, "李四");
+        assertTrue(result);
+        verify(woProcessMapper).insert(any());
+    }
+
+    @Test
+    void testStartWorkOrder() {
+        WorkOrder wo = new WorkOrder();
+        wo.setId(1L);
+        wo.setAssigneeId(200L);
+        wo.setAssigneeName("李四");
+
+        when(woMapper.updateStatus(1L, "processing", "in_progress")).thenReturn(1);
+        when(woMapper.selectById(1L)).thenReturn(wo);
+        when(woProcessMapper.insert(any())).thenReturn(1);
+
+        boolean result = woSvc.startWorkOrder(1L);
+        assertTrue(result);
+    }
+
+    @Test
+    void testCompleteWorkOrder() {
+        WorkOrder wo = new WorkOrder();
+        wo.setId(1L);
+        wo.setAssigneeId(200L);
+        wo.setAssigneeName("李四");
+
+        when(woMapper.updateCompletion(eq(1L), any(), any(), eq("已修复"))).thenReturn(1);
+        when(woMapper.selectById(1L)).thenReturn(wo);
+        when(woProcessMapper.insert(any())).thenReturn(1);
+        when(woMapper.updateStatus(1L, "completed", "completed")).thenReturn(1);
+
+        boolean result = woSvc.completeWorkOrder(1L, "已修复");
+        assertTrue(result);
+    }
+
+    @Test
+    void testDeleteWorkOrder() {
+        when(woMapper.deleteById(1L)).thenReturn(1);
+        boolean result = woSvc.deleteWorkOrder(1L);
+        assertTrue(result);
+    }
+
+    @Test
+    void testGetWorkOrderStatistics() {
+        when(woMapper.countAll()).thenReturn(50);
+        when(woMapper.countByStatus("pending")).thenReturn(10);
+        when(woMapper.countByStatus("assigned")).thenReturn(5);
+        when(woMapper.countByStatus("processing")).thenReturn(15);
+        when(woMapper.countByStatus("completed")).thenReturn(18);
+        when(woMapper.countByStatus("cancelled")).thenReturn(2);
+
+        WorkOrderService.WorkOrderStatistics stats = woSvc.getWorkOrderStatistics();
+        assertEquals(50, stats.getTotalOrders());
+        assertEquals(10, stats.getPendingCount());
+        assertEquals(5, stats.getAssignedCount());
+        assertEquals(15, stats.getProcessingCount());
+        assertEquals(18, stats.getCompletedCount());
+        assertEquals(2, stats.getCancelledCount());
+    }
+
+    @Test
+    void testDetermineOrderType() {
+        // Test via reflection or through createFromProblem
+        PatrolProblem p = new PatrolProblem();
+        p.setId(1L);
+        p.setProblemType("水质异常");
+        p.setProblemLevel("high");
+        p.setProblemTitle("水质问题");
+        p.setProblemDescription("描述");
+        p.setLocation("A区");
+        p.setReporterId(100L);
+        p.setReporterName("张三");
+
+        when(woMapper.generateOrderNo()).thenReturn("WO2026-001");
+        when(woMapper.insert(any())).thenAnswer(invocation -> {
+            WorkOrder wo = invocation.getArgument(0);
+            assertEquals("水质处理", wo.getOrderType());
+            return 1;
+        });
+        when(woProcessMapper.insert(any())).thenReturn(1);
+        when(problemMapper.updateStatus(anyLong(), anyString(), anyLong())).thenReturn(1);
+
+        woSvc.createFromProblem(p);
+    }
+}