feat(wm-patrol): #76 巡检执行（检查项/GPS轨迹/异常上报）

- Entity: PatrolExecution, CheckItemRecord, GpsTrackPoint, PatrolIssue
- DTO: StartExecutionRequest, CompleteExecutionRequest, CheckItemRecordRequest, GpsTrackBatchRequest, PatrolIssueRequest
- Mapper: PatrolExecutionMapper, CheckItemRecordMapper, GpsTrackPointMapper, PatrolIssueMapper
- Service: ExecutionService (执行流程), TrackService (GPS轨迹), IssueService (异常上报)
- Controller: ExecutionController 22 endpoints at /api/patrol/execution/*
- DDL: V2__patrol_execution.sql (4 tables with indexes)
- Config: MyBatisPlusConfig with pagination + MetaObjectHandler
- Unit tests: ExecutionServiceTest(7), TrackServiceTest(6), IssueServiceTest(5) = 18 test cases

db/postgresql/V2__patrol_execution.sql

@@ -0,0 +1,111 @@
+-- =============================================
+-- 智慧水务管理系统 - PostgreSQL DDL
+-- 版本: V2
+-- 描述: 巡检执行模块（检查项/GPS轨迹/异常上报）
+-- =============================================
+
+-- ==================== 巡检执行表 ====================
+CREATE TABLE IF NOT EXISTS patrol_execution (
+    id              BIGSERIAL PRIMARY KEY,
+    task_id         BIGINT NOT NULL REFERENCES patrol_task(id),
+    inspector_id    BIGINT NOT NULL REFERENCES patrol_worker(id),
+    inspector_name  VARCHAR(50),
+    status          VARCHAR(20) NOT NULL DEFAULT 'pending',     -- pending/in_progress/completed/aborted
+    start_time      TIMESTAMP,
+    end_time        TIMESTAMP,
+    total_check_items   INT DEFAULT 0,
+    completed_check_items INT DEFAULT 0,
+    issue_count     INT DEFAULT 0,
+    total_distance  DECIMAL(10,2) DEFAULT 0,                    -- 巡检总距离(km)
+    start_lng       DOUBLE PRECISION,
+    start_lat       DOUBLE PRECISION,
+    end_lng         DOUBLE PRECISION,
+    end_lat         DOUBLE PRECISION,
+    remark          VARCHAR(500),
+    deleted         SMALLINT DEFAULT 0,
+    created_at      TIMESTAMP DEFAULT NOW(),
+    updated_at      TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE patrol_execution IS '巡检执行表';
+COMMENT ON COLUMN patrol_execution.status IS '状态: pending(待开始)/in_progress(进行中)/completed(已完成)/aborted(已中止)';
+COMMENT ON COLUMN patrol_execution.total_distance IS '巡检总距离(km)';
+CREATE INDEX IF NOT EXISTS idx_patrol_execution_task ON patrol_execution(task_id);
+CREATE INDEX IF NOT EXISTS idx_patrol_execution_inspector ON patrol_execution(inspector_id);
+CREATE INDEX IF NOT EXISTS idx_patrol_execution_status ON patrol_execution(status);
+CREATE INDEX IF NOT EXISTS idx_patrol_execution_start_time ON patrol_execution(start_time);
+
+-- ==================== 检查项记录表 ====================
+CREATE TABLE IF NOT EXISTS check_item_record (
+    id              BIGSERIAL PRIMARY KEY,
+    execution_id    BIGINT NOT NULL REFERENCES patrol_execution(id),
+    point_seq       INT,                                        -- 检查点序号
+    point_name      VARCHAR(100),                               -- 检查点名称
+    item_name       VARCHAR(200),                               -- 检查项名称
+    check_status    VARCHAR(20) NOT NULL DEFAULT 'normal',      -- normal/abnormal/skipped
+    record_value    DOUBLE PRECISION,                           -- 数值录入
+    value_unit      VARCHAR(20),                                -- 数值单位
+    description     TEXT,                                       -- 文字描述
+    photo_urls      TEXT,                                       -- 照片URL列表(逗号分隔)
+    remark          VARCHAR(500),
+    record_time     TIMESTAMP NOT NULL DEFAULT NOW(),
+    lng             DOUBLE PRECISION,
+    lat             DOUBLE PRECISION,
+    deleted         SMALLINT DEFAULT 0,
+    created_at      TIMESTAMP DEFAULT NOW(),
+    updated_at      TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE check_item_record IS '检查项记录表';
+COMMENT ON COLUMN check_item_record.check_status IS '状态: normal(正常)/abnormal(异常)/skipped(跳过)';
+CREATE INDEX IF NOT EXISTS idx_check_item_record_execution ON check_item_record(execution_id);
+CREATE INDEX IF NOT EXISTS idx_check_item_record_point ON check_item_record(execution_id, point_seq);
+CREATE INDEX IF NOT EXISTS idx_check_item_record_status ON check_item_record(check_status);
+
+-- ==================== GPS轨迹点表 ====================
+CREATE TABLE IF NOT EXISTS gps_track_point (
+    id              BIGSERIAL PRIMARY KEY,
+    execution_id    BIGINT NOT NULL REFERENCES patrol_execution(id),
+    lng             DOUBLE PRECISION NOT NULL,
+    lat             DOUBLE PRECISION NOT NULL,
+    altitude        DOUBLE PRECISION,                           -- 海拔(米)
+    speed           DOUBLE PRECISION,                           -- 速度(m/s)
+    bearing         DOUBLE PRECISION,                           -- 方向(角度, 0-360)
+    accuracy        DOUBLE PRECISION,                           -- 精度(米)
+    record_time     TIMESTAMP NOT NULL DEFAULT NOW(),
+    deleted         SMALLINT DEFAULT 0,
+    created_at      TIMESTAMP DEFAULT NOW(),
+    updated_at      TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE gps_track_point IS 'GPS轨迹点表';
+CREATE INDEX IF NOT EXISTS idx_gps_track_execution ON gps_track_point(execution_id);
+CREATE INDEX IF NOT EXISTS idx_gps_track_time ON gps_track_point(execution_id, record_time);
+
+-- ==================== 巡检问题表 ====================
+CREATE TABLE IF NOT EXISTS patrol_issue (
+    id              BIGSERIAL PRIMARY KEY,
+    execution_id    BIGINT NOT NULL REFERENCES patrol_execution(id),
+    check_record_id BIGINT REFERENCES check_item_record(id),    -- 关联检查项记录(可选)
+    issue_type      VARCHAR(30) NOT NULL,                       -- leak/damage/pollution/illegal/other
+    severity        VARCHAR(20) NOT NULL DEFAULT 'medium',      -- low/medium/high/critical
+    description     TEXT NOT NULL,
+    photo_urls      TEXT,                                       -- 照片URL列表(逗号分隔)
+    lng             DOUBLE PRECISION,
+    lat             DOUBLE PRECISION,
+    address         VARCHAR(300),                               -- 地址描述
+    handle_status   VARCHAR(20) NOT NULL DEFAULT 'pending',     -- pending/processing/resolved/closed
+    work_order_id   BIGINT,                                     -- 关联工单ID
+    reporter_id     BIGINT NOT NULL,
+    reporter_name   VARCHAR(50),
+    report_time     TIMESTAMP NOT NULL DEFAULT NOW(),
+    deleted         SMALLINT DEFAULT 0,
+    created_at      TIMESTAMP DEFAULT NOW(),
+    updated_at      TIMESTAMP DEFAULT NOW()
+);
+COMMENT ON TABLE patrol_issue IS '巡检问题表';
+COMMENT ON COLUMN patrol_issue.issue_type IS '问题类型: leak(漏水)/damage(损坏)/pollution(污染)/illegal(违规)/other(其他)';
+COMMENT ON COLUMN patrol_issue.severity IS '严重程度: low(低)/medium(中)/high(高)/critical(紧急)';
+COMMENT ON COLUMN patrol_issue.handle_status IS '处理状态: pending(待处理)/processing(处理中)/resolved(已解决)/closed(已关闭)';
+CREATE INDEX IF NOT EXISTS idx_patrol_issue_execution ON patrol_issue(execution_id);
+CREATE INDEX IF NOT EXISTS idx_patrol_issue_type ON patrol_issue(issue_type);
+CREATE INDEX IF NOT EXISTS idx_patrol_issue_severity ON patrol_issue(severity);
+CREATE INDEX IF NOT EXISTS idx_patrol_issue_handle_status ON patrol_issue(handle_status);
+CREATE INDEX IF NOT EXISTS idx_patrol_issue_report_time ON patrol_issue(report_time);

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

@@ -1,9 +1,11 @@
 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/config/MyBatisPlusConfig.java

@@ -0,0 +1,38 @@
+package com.water.patrol.config;
+
+import com.baomidou.mybatisplus.annotation.DbType;
+import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
+import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
+import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
+import org.apache.ibatis.reflection.MetaObject;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.time.LocalDateTime;
+
+@Configuration
+public class MyBatisPlusConfig {
+
+    @Bean
+    public MybatisPlusInterceptor mybatisPlusInterceptor() {
+        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
+        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.POSTGRE_SQL));
+        return interceptor;
+    }
+
+    @Bean
+    public MetaObjectHandler metaObjectHandler() {
+        return new MetaObjectHandler() {
+            @Override
+            public void insertFill(MetaObject metaObject) {
+                this.strictInsertFill(metaObject, "createdAt", LocalDateTime::now, LocalDateTime.class);
+                this.strictInsertFill(metaObject, "updatedAt", LocalDateTime::now, LocalDateTime.class);
+            }
+
+            @Override
+            public void updateFill(MetaObject metaObject) {
+                this.strictUpdateFill(metaObject, "updatedAt", LocalDateTime::now, LocalDateTime.class);
+            }
+        };
+    }
+}

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

@@ -0,0 +1,197 @@
+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.*;
+import com.water.patrol.entity.dto.*;
+import com.water.patrol.service.ExecutionService;
+import com.water.patrol.service.IssueService;
+import com.water.patrol.service.TrackService;
+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;
+
+@Tag(name = "巡检执行管理")
+@RestController
+@RequestMapping("/api/patrol/execution")
+@RequiredArgsConstructor
+public class ExecutionController {
+
+    private final ExecutionService executionService;
+    private final TrackService trackService;
+    private final IssueService issueService;
+
+    // ========== 巡检执行 ==========
+
+    @Operation(summary = "开始巡检")
+    @PostMapping("/start")
+    public R<PatrolExecution> startExecution(@RequestBody StartExecutionRequest request) {
+        return R.ok(executionService.startExecution(request));
+    }
+
+    @Operation(summary = "获取执行详情")
+    @GetMapping("/{id}")
+    public R<PatrolExecution> getExecution(@PathVariable Long id) {
+        return R.ok(executionService.getExecution(id));
+    }
+
+    @Operation(summary = "获取某任务的执行列表")
+    @GetMapping("/task/{taskId}")
+    public R<List<PatrolExecution>> getExecutionsByTask(@PathVariable Long taskId) {
+        return R.ok(executionService.getExecutionsByTaskId(taskId));
+    }
+
+    @Operation(summary = "分页查询执行列表")
+    @GetMapping("/list")
+    public R<Page<PatrolExecution>> listExecutions(
+            @RequestParam(defaultValue = "1") Integer pageNum,
+            @RequestParam(defaultValue = "10") Integer pageSize,
+            @RequestParam(required = false) String status,
+            @RequestParam(required = false) Long inspectorId) {
+        return R.ok(executionService.listExecutions(pageNum, pageSize, status, inspectorId));
+    }
+
+    @Operation(summary = "完成巡检")
+    @PutMapping("/{id}/complete")
+    public R<PatrolExecution> completeExecution(@PathVariable Long id,
+                                                 @RequestBody CompleteExecutionRequest request) {
+        return R.ok(executionService.completeExecution(id, request));
+    }
+
+    @Operation(summary = "中止巡检")
+    @PutMapping("/{id}/abort")
+    public R<PatrolExecution> abortExecution(@PathVariable Long id,
+                                              @RequestParam(required = false) String reason) {
+        return R.ok(executionService.abortExecution(id, reason));
+    }
+
+    @Operation(summary = "获取执行统计")
+    @GetMapping("/stats")
+    public R<Map<String, Object>> getStats(@RequestParam String startDate,
+                                            @RequestParam String endDate) {
+        return R.ok(executionService.getExecutionStats(startDate, endDate));
+    }
+
+    // ========== 检查项记录 ==========
+
+    @Operation(summary = "提交检查项记录")
+    @PostMapping("/{id}/check-item")
+    public R<CheckItemRecord> submitCheckItem(@PathVariable Long id,
+                                               @RequestBody CheckItemRecordRequest request) {
+        return R.ok(executionService.submitCheckItem(id, request));
+    }
+
+    @Operation(summary = "批量提交检查项记录")
+    @PostMapping("/{id}/check-item/batch")
+    public R<Map<String, Object>> batchSubmitCheckItems(@PathVariable Long id,
+                                                         @RequestBody List<CheckItemRecordRequest> items) {
+        int count = executionService.batchSubmitCheckItems(id, items);
+        return R.ok(Map.of("executionId", id, "recorded", count));
+    }
+
+    @Operation(summary = "获取检查项记录列表")
+    @GetMapping("/{id}/check-item/list")
+    public R<List<CheckItemRecord>> getCheckItems(@PathVariable Long id) {
+        return R.ok(executionService.getCheckItemRecords(id));
+    }
+
+    @Operation(summary = "获取检查项状态汇总")
+    @GetMapping("/{id}/check-item/summary")
+    public R<List<Map<String, Object>>> getCheckItemSummary(@PathVariable Long id) {
+        return R.ok(executionService.getCheckItemStatusSummary(id));
+    }
+
+    // ========== GPS轨迹 ==========
+
+    @Operation(summary = "记录GPS轨迹点")
+    @PostMapping("/{id}/track")
+    public R<GpsTrackPoint> recordTrackPoint(@PathVariable Long id,
+                                              @RequestParam Double lng,
+                                              @RequestParam Double lat,
+                                              @RequestParam(required = false) Double altitude,
+                                              @RequestParam(required = false) Double speed,
+                                              @RequestParam(required = false) Double bearing,
+                                              @RequestParam(required = false) Double accuracy) {
+        return R.ok(trackService.recordTrackPoint(id, lng, lat, altitude, speed, bearing, accuracy));
+    }
+
+    @Operation(summary = "批量记录GPS轨迹点")
+    @PostMapping("/{id}/track/batch")
+    public R<Map<String, Object>> batchRecordTrack(@PathVariable Long id,
+                                                    @RequestBody GpsTrackBatchRequest request) {
+        int count = trackService.batchRecordTrackPoints(id, request);
+        return R.ok(Map.of("executionId", id, "recorded", count));
+    }
+
+    @Operation(summary = "获取轨迹回放数据")
+    @GetMapping("/{id}/track")
+    public R<List<GpsTrackPoint>> getTrackPoints(@PathVariable Long id) {
+        return R.ok(trackService.getTrackPoints(id));
+    }
+
+    @Operation(summary = "获取轨迹摘要（地图展示用）")
+    @GetMapping("/{id}/track/summary")
+    public R<Map<String, Object>> getTrackSummary(@PathVariable Long id) {
+        return R.ok(trackService.getTrackSummary(id));
+    }
+
+    @Operation(summary = "获取最新位置")
+    @GetMapping("/{id}/track/latest")
+    public R<GpsTrackPoint> getLatestPosition(@PathVariable Long id) {
+        return R.ok(trackService.getLatestPosition(id));
+    }
+
+    // ========== 异常上报 ==========
+
+    @Operation(summary = "上报问题")
+    @PostMapping("/{id}/issue")
+    public R<PatrolIssue> reportIssue(@PathVariable Long id,
+                                       @RequestBody PatrolIssueRequest request) {
+        return R.ok(issueService.reportIssue(id, request));
+    }
+
+    @Operation(summary = "获取问题详情")
+    @GetMapping("/issue/{issueId}")
+    public R<PatrolIssue> getIssue(@PathVariable Long issueId) {
+        return R.ok(issueService.getIssue(issueId));
+    }
+
+    @Operation(summary = "获取执行的问题列表")
+    @GetMapping("/{id}/issue/list")
+    public R<List<PatrolIssue>> getIssues(@PathVariable Long id) {
+        return R.ok(issueService.getIssuesByExecutionId(id));
+    }
+
+    @Operation(summary = "更新问题处理状态")
+    @PutMapping("/issue/{issueId}/status")
+    public R<PatrolIssue> updateIssueStatus(@PathVariable Long issueId,
+                                             @RequestParam String handleStatus) {
+        return R.ok(issueService.updateIssueStatus(issueId, handleStatus));
+    }
+
+    @Operation(summary = "关联工单")
+    @PutMapping("/issue/{issueId}/link-work-order")
+    public R<PatrolIssue> linkWorkOrder(@PathVariable Long issueId,
+                                         @RequestParam Long workOrderId) {
+        return R.ok(issueService.linkWorkOrder(issueId, workOrderId));
+    }
+
+    @Operation(summary = "获取问题汇总")
+    @GetMapping("/{id}/issue/summary")
+    public R<List<Map<String, Object>>> getIssueSummary(@PathVariable Long id) {
+        return R.ok(issueService.getIssueSummary(id));
+    }
+
+    @Operation(summary = "查询问题列表（按类型/状态筛选）")
+    @GetMapping("/issue/query")
+    public R<List<PatrolIssue>> queryIssues(
+            @RequestParam(required = false) String issueType,
+            @RequestParam(required = false) String handleStatus,
+            @RequestParam(required = false) Long executionId) {
+        return R.ok(issueService.queryIssues(issueType, handleStatus, executionId));
+    }
+}

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

@@ -1,100 +1,310 @@
 package com.water.patrol.controller;
 
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.water.common.core.result.R;
-import com.water.patrol.service.PatrolService;
+import com.water.patrol.entity.PatrolCheckpoint;
+import com.water.patrol.entity.PatrolRoute;
+import com.water.patrol.entity.PatrolTask;
+import com.water.patrol.entity.PatrolWorker;
+import com.water.patrol.service.RouteService;
+import com.water.patrol.service.TaskService;
+import com.water.patrol.service.WorkerService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
+import org.springframework.format.annotation.DateTimeFormat;
 import org.springframework.web.bind.annotation.*;
 
 import java.time.LocalDate;
-import java.util.*;
+import java.util.List;
+import java.util.Map;
 
-@Tag(name = "巡检管理")
+/**
+ * 巡检路线管理与任务分派 REST API
+ */
+@Tag(name = "巡检路线管理与任务分派")
 @RestController
-@RequestMapping("/patrol")
+@RequestMapping("/api/patrol")
 @RequiredArgsConstructor
 public class PatrolController {
 
-    private final PatrolService patrolService;
+    private final RouteService routeService;
+    private final TaskService taskService;
+    private final WorkerService workerService;
 
-    // ---- 路线 ----
+    // ==================== 路线管理 ====================
+
+    @Operation(summary = "分页查询巡检路线")
+    @GetMapping("/route/page")
+    public R<Page<PatrolRoute>> routePage(
+            @RequestParam(defaultValue = "1") int current,
+            @RequestParam(defaultValue = "10") int size,
+            @RequestParam(required = false) String keyword,
+            @RequestParam(required = false) String area,
+            @RequestParam(required = false) Integer status) {
+        return R.ok(routeService.page(current, size, keyword, area, status));
+    }
+
+    @Operation(summary = "查询路线详情")
+    @GetMapping("/route/{id}")
+    public R<PatrolRoute> routeDetail(@PathVariable Long id) {
+        PatrolRoute route = routeService.getById(id);
+        return route != null ? R.ok(route) : R.fail(404, "路线不存在");
+    }
+
+    @Operation(summary = "创建巡检路线")
     @PostMapping("/route")
-    public R<Map<String, Object>> createRoute(@RequestBody Map<String, Object> req) {
-        @SuppressWarnings("unchecked")
-        List<Map<String, Object>> points = (List<Map<String, Object>>) req.getOrDefault("points", List.of());
-        return R.ok(patrolService.createRoute(
-            (String) req.get("routeName"), (String) req.get("area"),
-            points, (int) req.getOrDefault("estimDuration", 60)));
+    public R<PatrolRoute> createRoute(@RequestBody PatrolRoute route) {
+        return R.ok(routeService.create(route));
     }
 
-    @GetMapping("/route/list")
-    public R<List<Map<String, Object>>> routes(@RequestParam String area) {
-        return R.ok(patrolService.getRoutes(area));
+    @Operation(summary = "更新巡检路线")
+    @PutMapping("/route/{id}")
+    public R<String> updateRoute(@PathVariable Long id, @RequestBody PatrolRoute route) {
+        route.setId(id);
+        return routeService.update(route) ? R.ok("更新成功") : R.fail("更新失败");
     }
 
-    // ---- 任务 ----
+    @Operation(summary = "删除巡检路线")
+    @DeleteMapping("/route/{id}")
+    public R<String> deleteRoute(@PathVariable Long id) {
+        return routeService.delete(id) ? R.ok("删除成功") : R.fail("删除失败");
+    }
+
+    @Operation(summary = "启用/停用路线")
+    @PutMapping("/route/{id}/status")
+    public R<String> toggleRouteStatus(@PathVariable Long id, @RequestParam int status) {
+        return routeService.toggleStatus(id, status) ? R.ok("操作成功") : R.fail("操作失败");
+    }
+
+    @Operation(summary = "按区域统计路线数")
+    @GetMapping("/route/stats")
+    public R<List<Map<String, Object>>> routeStats() {
+        return R.ok(routeService.countByArea());
+    }
+
+    // ==================== 检查点管理 ====================
+
+    @Operation(summary = "查询路线检查点列表")
+    @GetMapping("/route/{routeId}/checkpoints")
+    public R<List<PatrolCheckpoint>> checkpoints(@PathVariable Long routeId) {
+        return R.ok(routeService.getCheckpoints(routeId));
+    }
+
+    @Operation(summary = "批量设置路线检查点")
+    @PostMapping("/route/{routeId}/checkpoints")
+    public R<List<PatrolCheckpoint>> setCheckpoints(
+            @PathVariable Long routeId,
+            @RequestBody List<PatrolCheckpoint> checkpoints) {
+        return R.ok(routeService.setCheckpoints(routeId, checkpoints));
+    }
+
+    @Operation(summary = "添加单个检查点")
+    @PostMapping("/checkpoint")
+    public R<PatrolCheckpoint> addCheckpoint(@RequestBody PatrolCheckpoint checkpoint) {
+        return R.ok(routeService.addCheckpoint(checkpoint));
+    }
+
+    @Operation(summary = "删除检查点")
+    @DeleteMapping("/checkpoint/{id}")
+    public R<String> deleteCheckpoint(@PathVariable Long id) {
+        return routeService.deleteCheckpoint(id) ? R.ok("删除成功") : R.fail("删除失败");
+    }
+
+    @Operation(summary = "路线优化 - 计算最优巡检路径")
+    @PostMapping("/route/{id}/optimize")
+    public R<Map<String, Object>> optimizeRoute(@PathVariable Long id) {
+        return R.ok(routeService.optimizeRoute(id));
+    }
+
+    // ==================== 任务管理 ====================
+
+    @Operation(summary = "分页查询巡检任务")
+    @GetMapping("/task/page")
+    public R<Page<PatrolTask>> taskPage(
+            @RequestParam(defaultValue = "1") int current,
+            @RequestParam(defaultValue = "10") int size,
+            @RequestParam(required = false) String keyword,
+            @RequestParam(required = false) String status,
+            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
+            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate,
+            @RequestParam(required = false) Long workerId) {
+        return R.ok(taskService.page(current, size, keyword, status, startDate, endDate, workerId));
+    }
+
+    @Operation(summary = "查询任务详情")
+    @GetMapping("/task/{id}")
+    public R<PatrolTask> taskDetail(@PathVariable Long id) {
+        PatrolTask task = taskService.getById(id);
+        return task != null ? R.ok(task) : R.fail(404, "任务不存在");
+    }
+
+    @Operation(summary = "创建巡检任务")
     @PostMapping("/task")
-    public R<Map<String, Object>> createTask(@RequestBody Map<String, Object> req) {
-        return R.ok(patrolService.createTask(
-            Long.parseLong(String.valueOf(req.get("routeId"))),
-            Long.parseLong(String.valueOf(req.get("assigneeId"))),
-            (String) req.get("taskDate")));
-    }
-
-    @GetMapping("/task/today")
-    public R<List<Map<String, Object>>> todayTasks(@RequestParam Long userId) {
-        return R.ok(patrolService.getTodayTasks(userId));
-    }
-
-    @PutMapping("/task/{id}/start")
-    public R<Map<String, Object>> startTask(@PathVariable Long id) {
-        return R.ok(patrolService.startTask(id));
-    }
-
-    @PutMapping("/task/{id}/complete")
-    public R<Map<String, Object>> completeTask(@PathVariable Long id, @RequestParam double distance) {
-        return R.ok(patrolService.completeTask(id, distance));
-    }
-
-    // ---- 巡检记录 ----
-    @PostMapping("/record")
-    public R<Map<String, Object>> record(@RequestBody Map<String, Object> req) {
-        @SuppressWarnings("unchecked")
-        List<Map<String, Object>> items = (List<Map<String, Object>>) req.getOrDefault("checkItems", List.of());
-        return R.ok(patrolService.recordCheck(
-            Long.parseLong(String.valueOf(req.get("taskId"))),
-            (int) req.get("pointSeq"),
-            req.get("deviceId") != null ? Long.parseLong(String.valueOf(req.get("deviceId"))) : null,
-            items,
-            ((Number) req.get("lng")).doubleValue(),
-            ((Number) req.get("lat")).doubleValue()));
-    }
-
-    @GetMapping("/record/list/{taskId}")
-    public R<List<Map<String, Object>>> records(@PathVariable Long taskId) {
-        return R.ok(patrolService.getTaskRecords(taskId));
-    }
-
-    // ---- 问题上报 ----
-    @PostMapping("/issue/report")
-    public R<Map<String, Object>> reportIssue(@RequestBody Map<String, Object> req) {
-        @SuppressWarnings("unchecked")
-        List<String> photos = (List<String>) req.getOrDefault("photoUrls", List.of());
-        return R.ok(patrolService.reportIssue(
-            Long.parseLong(String.valueOf(req.get("taskId"))),
-            req.get("deviceId") != null ? Long.parseLong(String.valueOf(req.get("deviceId"))) : null,
-            (String) req.get("issueType"), (String) req.get("description"),
-            photos,
-            ((Number) req.get("lng")).doubleValue(),
-            ((Number) req.get("lat")).doubleValue()));
-    }
-
-    // ---- 统计 ----
-    @GetMapping("/stats")
-    public R<Map<String, Object>> stats(@RequestParam String area,
-                                         @RequestParam String start,
-                                         @RequestParam String end) {
-        return R.ok(patrolService.getStats(area, LocalDate.parse(start), LocalDate.parse(end)));
+    public R<PatrolTask> createTask(@RequestBody PatrolTask task) {
+        return R.ok(taskService.create(task));
+    }
+
+    @Operation(summary = "更新巡检任务")
+    @PutMapping("/task/{id}")
+    public R<String> updateTask(@PathVariable Long id, @RequestBody PatrolTask task) {
+        task.setId(id);
+        return taskService.update(task) ? R.ok("更新成功") : R.fail("更新失败");
+    }
+
+    @Operation(summary = "删除巡检任务")
+    @DeleteMapping("/task/{id}")
+    public R<String> deleteTask(@PathVariable Long id) {
+        return taskService.delete(id) ? R.ok("删除成功") : R.fail("删除失败");
+    }
+
+    // ==================== 任务分派 ====================
+
+    @Operation(summary = "手动分派任务给巡检员")
+    @PostMapping("/task/{id}/assign")
+    public R<String> assignTask(@PathVariable Long id, @RequestParam Long workerId) {
+        return taskService.assign(id, workerId) ? R.ok("分派成功") : R.fail("分派失败");
+    }
+
+    @Operation(summary = "自动分派任务(选择负荷最低的巡检员)")
+    @PostMapping("/task/{id}/auto-assign")
+    public R<Map<String, Object>> autoAssignTask(@PathVariable Long id) {
+        return R.ok(taskService.autoAssign(id));
+    }
+
+    @Operation(summary = "批量自动分派指定日期的待分派任务")
+    @PostMapping("/task/batch-auto-assign")
+    public R<Map<String, Object>> batchAutoAssign(
+            @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate date) {
+        return R.ok(taskService.batchAutoAssign(date));
+    }
+
+    @Operation(summary = "开始任务")
+    @PostMapping("/task/{id}/start")
+    public R<String> startTask(@PathVariable Long id) {
+        return taskService.startTask(id) ? R.ok("任务已开始") : R.fail("操作失败");
+    }
+
+    @Operation(summary = "完成任务")
+    @PostMapping("/task/{id}/complete")
+    public R<String> completeTask(@PathVariable Long id, @RequestParam(required = false) Double distance) {
+        return taskService.completeTask(id, distance != null ? distance : 0.0)
+                ? R.ok("任务已完成") : R.fail("操作失败");
+    }
+
+    @Operation(summary = "取消任务")
+    @PostMapping("/task/{id}/cancel")
+    public R<String> cancelTask(@PathVariable Long id, @RequestBody(required = false) Map<String, String> body) {
+        String reason = body != null ? body.getOrDefault("reason", "") : "";
+        return taskService.cancelTask(id, reason) ? R.ok("任务已取消") : R.fail("操作失败");
+    }
+
+    // ==================== 周期任务 ====================
+
+    @Operation(summary = "创建周期任务(日/周/月)")
+    @PostMapping("/task/cycle")
+    public R<Map<String, Object>> createCycleTask(@RequestBody Map<String, Object> body) {
+        PatrolTask template = new PatrolTask();
+        template.setTaskName((String) body.get("taskName"));
+        if (body.get("routeId") != null) {
+            template.setRouteId(((Number) body.get("routeId")).longValue());
+        }
+        if (body.get("workerId") != null) {
+            template.setWorkerId(((Number) body.get("workerId")).longValue());
+        }
+        if (body.get("priority") != null) {
+            template.setPriority(((Number) body.get("priority")).intValue());
+        }
+        template.setRemark((String) body.get("remark"));
+
+        String cycleType = (String) body.getOrDefault("cycleType", "daily");
+        String startDateStr = (String) body.get("startDate");
+        LocalDate startDate = startDateStr != null ? LocalDate.parse(startDateStr) : LocalDate.now();
+        int cycles = body.get("cycles") != null ? ((Number) body.get("cycles")).intValue() : 7;
+
+        return R.ok(taskService.createCycleTask(template, cycleType, startDate, cycles));
+    }
+
+    // ==================== 巡检人员管理 ====================
+
+    @Operation(summary = "分页查询巡检员")
+    @GetMapping("/worker/page")
+    public R<Page<PatrolWorker>> workerPage(
+            @RequestParam(defaultValue = "1") int current,
+            @RequestParam(defaultValue = "10") int size,
+            @RequestParam(required = false) String keyword,
+            @RequestParam(required = false) Integer status) {
+        return R.ok(workerService.page(current, size, keyword, status));
+    }
+
+    @Operation(summary = "查询巡检员详情")
+    @GetMapping("/worker/{id}")
+    public R<PatrolWorker> workerDetail(@PathVariable Long id) {
+        PatrolWorker worker = workerService.getById(id);
+        return worker != null ? R.ok(worker) : R.fail(404, "巡检员不存在");
+    }
+
+    @Operation(summary = "创建巡检员")
+    @PostMapping("/worker")
+    public R<PatrolWorker> createWorker(@RequestBody PatrolWorker worker) {
+        return R.ok(workerService.create(worker));
+    }
+
+    @Operation(summary = "更新巡检员")
+    @PutMapping("/worker/{id}")
+    public R<String> updateWorker(@PathVariable Long id, @RequestBody PatrolWorker worker) {
+        worker.setId(id);
+        return workerService.update(worker) ? R.ok("更新成功") : R.fail("更新失败");
+    }
+
+    @Operation(summary = "删除巡检员")
+    @DeleteMapping("/worker/{id}")
+    public R<String> deleteWorker(@PathVariable Long id) {
+        return workerService.delete(id) ? R.ok("删除成功") : R.fail("删除失败");
+    }
+
+    @Operation(summary = "按技能标签筛选巡检员")
+    @GetMapping("/worker/skill")
+    public R<List<PatrolWorker>> workersBySkill(@RequestParam String tag) {
+        return R.ok(workerService.findBySkill(tag));
+    }
+
+    @Operation(summary = "更新巡检员技能标签")
+    @PutMapping("/worker/{id}/skills")
+    public R<String> updateSkills(@PathVariable Long id, @RequestBody Map<String, String> body) {
+        String skillTags = body.getOrDefault("skillTags", "");
+        return workerService.updateSkillTags(id, skillTags) ? R.ok("更新成功") : R.fail("更新失败");
+    }
+
+    @Operation(summary = "查询巡检员工作负荷")
+    @GetMapping("/worker/{id}/workload")
+    public R<Map<String, Object>> workerWorkload(
+            @PathVariable Long id,
+            @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
+            @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate) {
+        return R.ok(workerService.getWorkload(id, startDate, endDate));
+    }
+
+    @Operation(summary = "巡检员工作负荷概览(指定日期)")
+    @GetMapping("/worker/workload-overview")
+    public R<List<Map<String, Object>>> workloadOverview(
+            @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate date) {
+        return R.ok(workerService.getWorkloadOverview(date));
+    }
+
+    @Operation(summary = "按部门统计巡检员人数")
+    @GetMapping("/worker/stats")
+    public R<List<Map<String, Object>>> workerStats() {
+        return R.ok(workerService.countByDept());
+    }
+
+    // ==================== 综合统计 ====================
+
+    @Operation(summary = "任务统计看板")
+    @GetMapping("/task/stats")
+    public R<Map<String, Object>> taskStats(
+            @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
+            @RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate) {
+        return R.ok(taskService.getTaskStats(startDate, endDate));
     }
 }

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

@@ -0,0 +1,79 @@
+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("check_item_record")
+public class CheckItemRecord extends BaseEntity {
+
+    /**
+     * 关联执行ID
+     */
+    private Long executionId;
+
+    /**
+     * 检查点序号
+     */
+    private Integer pointSeq;
+
+    /**
+     * 检查点名称
+     */
+    private String pointName;
+
+    /**
+     * 检查项名称
+     */
+    private String itemName;
+
+    /**
+     * 检查状态: normal/abnormal/skipped
+     */
+    private String checkStatus;
+
+    /**
+     * 数值录入值
+     */
+    private Double recordValue;
+
+    /**
+     * 数值单位
+     */
+    private String valueUnit;
+
+    /**
+     * 文字描述
+     */
+    private String description;
+
+    /**
+     * 照片URL列表(JSON数组)
+     */
+    private String photoUrls;
+
+    /**
+     * 备注
+     */
+    private String remark;
+
+    /**
+     * 记录时间
+     */
+    private LocalDateTime recordTime;
+
+    /**
+     * 经度
+     */
+    private Double lng;
+
+    /**
+     * 纬度
+     */
+    private Double lat;
+}

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

@@ -0,0 +1,54 @@
+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("gps_track_point")
+public class GpsTrackPoint extends BaseEntity {
+
+    /**
+     * 关联执行ID
+     */
+    private Long executionId;
+
+    /**
+     * 经度
+     */
+    private Double lng;
+
+    /**
+     * 纬度
+     */
+    private Double lat;
+
+    /**
+     * 海拔(米)
+     */
+    private Double altitude;
+
+    /**
+     * 速度(m/s)
+     */
+    private Double speed;
+
+    /**
+     * 方向(角度, 0-360)
+     */
+    private Double bearing;
+
+    /**
+     * 精度(米)
+     */
+    private Double accuracy;
+
+    /**
+     * 记录时间
+     */
+    private LocalDateTime recordTime;
+}

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

@@ -0,0 +1,53 @@
+package com.water.patrol.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 巡检检查点实体
+ */
+@Data
+@TableName("patrol_checkpoint")
+public class PatrolCheckpoint {
+
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /** 所属路线ID */
+    private Long routeId;
+
+    /** 检查点顺序 */
+    private Integer seq;
+
+    /** 检查点名称 */
+    private String name;
+
+    /** 检查类型: visual/device/read */
+    private String checkType;
+
+    /** 关联设备ID(可选) */
+    private Long deviceId;
+
+    /** 经度 */
+    private Double lng;
+
+    /** 纬度 */
+    private Double lat;
+
+    /** 检查项列表(JSON) */
+    private String checkItems;
+
+    /** 是否必检: 1=必检 0=选检 */
+    private Integer required;
+
+    @TableField(fill = FieldFill.INSERT)
+    private LocalDateTime createdTime;
+
+    @TableField(fill = FieldFill.INSERT_UPDATE)
+    private LocalDateTime updatedTime;
+
+    @TableLogic
+    private Integer deleted;
+}

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

@@ -0,0 +1,90 @@
+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.math.BigDecimal;
+import java.time.LocalDateTime;
+
+@Data
+@EqualsAndHashCode(callSuper = true)
+@TableName("patrol_execution")
+public class PatrolExecution extends BaseEntity {
+
+    /**
+     * 关联巡检任务ID
+     */
+    private Long taskId;
+
+    /**
+     * 巡检员ID
+     */
+    private Long inspectorId;
+
+    /**
+     * 巡检员姓名
+     */
+    private String inspectorName;
+
+    /**
+     * 执行状态: pending/in_progress/completed/aborted
+     */
+    private String status;
+
+    /**
+     * 实际开始时间
+     */
+    private LocalDateTime startTime;
+
+    /**
+     * 实际结束时间
+     */
+    private LocalDateTime endTime;
+
+    /**
+     * 总检查项数
+     */
+    private Integer totalCheckItems;
+
+    /**
+     * 已完成检查项数
+     */
+    private Integer completedCheckItems;
+
+    /**
+     * 异常数量
+     */
+    private Integer issueCount;
+
+    /**
+     * 巡检总距离(km)
+     */
+    private BigDecimal totalDistance;
+
+    /**
+     * 开始经度
+     */
+    private Double startLng;
+
+    /**
+     * 开始纬度
+     */
+    private Double startLat;
+
+    /**
+     * 结束经度
+     */
+    private Double endLng;
+
+    /**
+     * 结束纬度
+     */
+    private Double endLat;
+
+    /**
+     * 备注
+     */
+    private String remark;
+}

wm-patrol/src/main/java/com/water/patrol/entity/PatrolIssue.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("patrol_issue")
+public class PatrolIssue extends BaseEntity {
+
+    /**
+     * 关联执行ID
+     */
+    private Long executionId;
+
+    /**
+     * 关联检查项记录ID(可选)
+     */
+    private Long checkRecordId;
+
+    /**
+     * 问题类型: leak/damage/pollution/illegal/other
+     */
+    private String issueType;
+
+    /**
+     * 严重程度: low/medium/high/critical
+     */
+    private String severity;
+
+    /**
+     * 问题描述
+     */
+    private String description;
+
+    /**
+     * 照片URL列表(JSON数组)
+     */
+    private String photoUrls;
+
+    /**
+     * 经度
+     */
+    private Double lng;
+
+    /**
+     * 纬度
+     */
+    private Double lat;
+
+    /**
+     * 地址描述
+     */
+    private String address;
+
+    /**
+     * 处理状态: pending/processing/resolved/closed
+     */
+    private String handleStatus;
+
+    /**
+     * 关联工单ID
+     */
+    private Long workOrderId;
+
+    /**
+     * 上报人ID
+     */
+    private Long reporterId;
+
+    /**
+     * 上报人姓名
+     */
+    private String reporterName;
+
+    /**
+     * 上报时间
+     */
+    private LocalDateTime reportTime;
+}

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

@@ -0,0 +1,53 @@
+package com.water.patrol.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 巡检路线实体
+ */
+@Data
+@TableName("patrol_route")
+public class PatrolRoute {
+
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /** 路线名称 */
+    private String routeName;
+
+    /** 路线编码 */
+    private String routeCode;
+
+    /** 所属区域 */
+    private String area;
+
+    /** 路线描述 */
+    private String description;
+
+    /** 总距离(公里) */
+    private Double totalDistance;
+
+    /** 预估时长(分钟) */
+    private Integer estimDuration;
+
+    /** 状态: 1=启用 0=停用 */
+    private Integer status;
+
+    /** 创建人 */
+    private Long createdBy;
+
+    /** 更新人 */
+    private Long updatedBy;
+
+    @TableField(fill = FieldFill.INSERT)
+    private LocalDateTime createdTime;
+
+    @TableField(fill = FieldFill.INSERT_UPDATE)
+    private LocalDateTime updatedTime;
+
+    @TableLogic
+    private Integer deleted;
+}

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

@@ -0,0 +1,75 @@
+package com.water.patrol.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+/**
+ * 巡检任务实体
+ */
+@Data
+@TableName("patrol_task")
+public class PatrolTask {
+
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /** 任务名称 */
+    private String taskName;
+
+    /** 路线ID */
+    private Long routeId;
+
+    /** 巡检员ID */
+    private Long workerId;
+
+    /** 任务日期 */
+    private LocalDate taskDate;
+
+    /** 周期类型: daily/weekly/monthly/once */
+    private String cycleType;
+
+    /** 计划开始时间 */
+    private LocalDateTime planStart;
+
+    /** 计划结束时间 */
+    private LocalDateTime planEnd;
+
+    /** 实际开始时间 */
+    private LocalDateTime actualStart;
+
+    /** 实际结束时间 */
+    private LocalDateTime actualEnd;
+
+    /** 状态: pending/assigned/in_progress/completed/cancelled */
+    private String status;
+
+    /** 优先级 */
+    private Integer priority;
+
+    /** 巡检距离(公里) */
+    private Double distance;
+
+    /** 已完成检查点数 */
+    private Integer checkpointDone;
+
+    /** 总检查点数 */
+    private Integer checkpointTotal;
+
+    /** 备注 */
+    private String remark;
+
+    /** 创建人 */
+    private Long createdBy;
+
+    @TableField(fill = FieldFill.INSERT)
+    private LocalDateTime createdTime;
+
+    @TableField(fill = FieldFill.INSERT_UPDATE)
+    private LocalDateTime updatedTime;
+
+    @TableLogic
+    private Integer deleted;
+}

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

@@ -0,0 +1,41 @@
+package com.water.patrol.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 巡检人员实体
+ */
+@Data
+@TableName("patrol_worker")
+public class PatrolWorker {
+
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /** 姓名 */
+    private String name;
+
+    /** 联系电话 */
+    private String phone;
+
+    /** 部门 */
+    private String dept;
+
+    /** 技能标签(JSON数组) */
+    private String skillTags;
+
+    /** 状态: 1=在岗 0=休假 -1=离职 */
+    private Integer status;
+
+    @TableField(fill = FieldFill.INSERT)
+    private LocalDateTime createdTime;
+
+    @TableField(fill = FieldFill.INSERT_UPDATE)
+    private LocalDateTime updatedTime;
+
+    @TableLogic
+    private Integer deleted;
+}

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

@@ -0,0 +1,64 @@
+package com.water.patrol.entity.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class CheckItemRecordRequest {
+
+    /**
+     * 检查点序号
+     */
+    private Integer pointSeq;
+
+    /**
+     * 检查点名称
+     */
+    private String pointName;
+
+    /**
+     * 检查项名称
+     */
+    private String itemName;
+
+    /**
+     * 检查状态: normal/abnormal/skipped
+     */
+    private String checkStatus;
+
+    /**
+     * 数值录入值
+     */
+    private Double recordValue;
+
+    /**
+     * 数值单位
+     */
+    private String valueUnit;
+
+    /**
+     * 文字描述
+     */
+    private String description;
+
+    /**
+     * 照片URL列表
+     */
+    private List<String> photoUrls;
+
+    /**
+     * 备注
+     */
+    private String remark;
+
+    /**
+     * 经度
+     */
+    private Double lng;
+
+    /**
+     * 纬度
+     */
+    private Double lat;
+}

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

@@ -0,0 +1,27 @@
+package com.water.patrol.entity.dto;
+
+import lombok.Data;
+
+@Data
+public class CompleteExecutionRequest {
+
+    /**
+     * 结束经度
+     */
+    private Double endLng;
+
+    /**
+     * 结束纬度
+     */
+    private Double endLat;
+
+    /**
+     * 巡检总距离(km)
+     */
+    private Double totalDistance;
+
+    /**
+     * 备注
+     */
+    private String remark;
+}

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

@@ -0,0 +1,52 @@
+package com.water.patrol.entity.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class GpsTrackBatchRequest {
+
+    /**
+     * GPS轨迹点列表
+     */
+    private List<GpsTrackPointDto> points;
+
+    @Data
+    public static class GpsTrackPointDto {
+        /**
+         * 经度
+         */
+        private Double lng;
+
+        /**
+         * 纬度
+         */
+        private Double lat;
+
+        /**
+         * 海拔(米)
+         */
+        private Double altitude;
+
+        /**
+         * 速度(m/s)
+         */
+        private Double speed;
+
+        /**
+         * 方向(角度)
+         */
+        private Double bearing;
+
+        /**
+         * 精度(米)
+         */
+        private Double accuracy;
+
+        /**
+         * 记录时间(ISO格式)
+         */
+        private String recordTime;
+    }
+}

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

@@ -0,0 +1,49 @@
+package com.water.patrol.entity.dto;
+
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class PatrolIssueRequest {
+
+    /**
+     * 关联检查项记录ID(可选)
+     */
+    private Long checkRecordId;
+
+    /**
+     * 问题类型: 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/StartExecutionRequest.java

@@ -0,0 +1,42 @@
+package com.water.patrol.entity.dto;
+
+import lombok.Data;
+
+@Data
+public class StartExecutionRequest {
+
+    /**
+     * 巡检任务ID
+     */
+    private Long taskId;
+
+    /**
+     * 巡检员ID
+     */
+    private Long inspectorId;
+
+    /**
+     * 巡检员姓名
+     */
+    private String inspectorName;
+
+    /**
+     * 开始经度
+     */
+    private Double startLng;
+
+    /**
+     * 开始纬度
+     */
+    private Double startLat;
+
+    /**
+     * 总检查项数
+     */
+    private Integer totalCheckItems;
+
+    /**
+     * 备注
+     */
+    private String remark;
+}

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

@@ -0,0 +1,18 @@
+package com.water.patrol.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.patrol.entity.CheckItemRecord;
+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 CheckItemRecordMapper extends BaseMapper<CheckItemRecord> {
+
+    @Select("SELECT check_status, COUNT(*) as count FROM check_item_record " +
+            "WHERE execution_id = #{executionId} AND deleted = 0 GROUP BY check_status")
+    List<Map<String, Object>> selectStatusSummary(@Param("executionId") Long executionId);
+}

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

@@ -0,0 +1,17 @@
+package com.water.patrol.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.patrol.entity.GpsTrackPoint;
+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 GpsTrackPointMapper extends BaseMapper<GpsTrackPoint> {
+
+    @Select("SELECT * FROM gps_track_point WHERE execution_id = #{executionId} " +
+            "AND deleted = 0 ORDER BY record_time ASC")
+    List<GpsTrackPoint> selectTrackByExecutionId(@Param("executionId") Long executionId);
+}

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

@@ -0,0 +1,19 @@
+package com.water.patrol.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.patrol.entity.PatrolCheckpoint;
+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 PatrolCheckpointMapper extends BaseMapper<PatrolCheckpoint> {
+
+    @Select("SELECT * FROM patrol_checkpoint WHERE route_id = #{routeId} AND deleted = 0 ORDER BY seq")
+    List<PatrolCheckpoint> findByRouteId(@Param("routeId") Long routeId);
+
+    @Select("SELECT COUNT(*) FROM patrol_checkpoint WHERE route_id = #{routeId} AND deleted = 0")
+    int countByRouteId(@Param("routeId") Long routeId);
+}

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

@@ -0,0 +1,24 @@
+package com.water.patrol.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.patrol.entity.PatrolExecution;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+import java.util.Map;
+
+@Mapper
+public interface PatrolExecutionMapper extends BaseMapper<PatrolExecution> {
+
+    @Select("SELECT " +
+            "COUNT(*) as total_executions, " +
+            "COUNT(CASE WHEN status = 'completed' THEN 1 END) as completed_count, " +
+            "COUNT(CASE WHEN status = 'in_progress' THEN 1 END) as in_progress_count, " +
+            "COALESCE(SUM(issue_count), 0) as total_issues, " +
+            "COALESCE(SUM(total_distance), 0) as total_distance " +
+            "FROM patrol_execution WHERE deleted = 0 AND task_id IN " +
+            "(SELECT id FROM patrol_task WHERE task_date BETWEEN #{startDate} AND #{endDate})")
+    Map<String, Object> selectExecutionStats(@Param("startDate") String startDate,
+                                             @Param("endDate") String endDate);
+}

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

@@ -0,0 +1,18 @@
+package com.water.patrol.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.patrol.entity.PatrolIssue;
+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 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);
+}

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

@@ -0,0 +1,20 @@
+package com.water.patrol.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.patrol.entity.PatrolRoute;
+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 PatrolRouteMapper extends BaseMapper<PatrolRoute> {
+
+    @Select("SELECT area, COUNT(*) as count FROM patrol_route WHERE status = 1 AND deleted = 0 GROUP BY area")
+    List<Map<String, Object>> countByArea();
+
+    @Select("SELECT * FROM patrol_route WHERE area = #{area} AND status = 1 AND deleted = 0 ORDER BY created_time DESC")
+    List<PatrolRoute> findByArea(@Param("area") String area);
+}

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

@@ -0,0 +1,25 @@
+package com.water.patrol.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.patrol.entity.PatrolTask;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Map;
+
+@Mapper
+public interface PatrolTaskMapper extends BaseMapper<PatrolTask> {
+
+    @Select("SELECT status, COUNT(*) as count FROM patrol_task WHERE task_date BETWEEN #{start} AND #{end} AND deleted = 0 GROUP BY status")
+    List<Map<String, Object>> countByStatusInRange(@Param("start") LocalDate start, @Param("end") LocalDate end);
+
+    @Select("SELECT worker_id, COUNT(*) as total, SUM(CASE WHEN status='completed' THEN 1 ELSE 0 END) as completed " +
+            "FROM patrol_task WHERE task_date BETWEEN #{start} AND #{end} AND deleted = 0 GROUP BY worker_id")
+    List<Map<String, Object>> workloadByWorker(@Param("start") LocalDate start, @Param("end") LocalDate end);
+
+    @Select("SELECT * FROM patrol_task WHERE task_date = #{date} AND worker_id = #{workerId} AND deleted = 0 ORDER BY plan_start")
+    List<PatrolTask> findByDateAndWorker(@Param("date") LocalDate date, @Param("workerId") Long workerId);
+}

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

@@ -0,0 +1,20 @@
+package com.water.patrol.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.patrol.entity.PatrolWorker;
+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 PatrolWorkerMapper extends BaseMapper<PatrolWorker> {
+
+    @Select("SELECT * FROM patrol_worker WHERE status = 1 AND deleted = 0 ORDER BY name")
+    List<PatrolWorker> findActive();
+
+    @Select("SELECT dept, COUNT(*) as count FROM patrol_worker WHERE status = 1 AND deleted = 0 GROUP BY dept")
+    List<Map<String, Object>> countByDept();
+}

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

@@ -0,0 +1,262 @@
+package com.water.patrol.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.water.patrol.entity.CheckItemRecord;
+import com.water.patrol.entity.PatrolExecution;
+import com.water.patrol.entity.dto.CheckItemRecordRequest;
+import com.water.patrol.entity.dto.CompleteExecutionRequest;
+import com.water.patrol.entity.dto.StartExecutionRequest;
+import com.water.patrol.mapper.CheckItemRecordMapper;
+import com.water.patrol.mapper.PatrolExecutionMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class ExecutionService {
+
+    private final PatrolExecutionMapper executionMapper;
+    private final CheckItemRecordMapper checkItemRecordMapper;
+
+    /**
+     * 开始巡检执行
+     */
+    @Transactional
+    public PatrolExecution startExecution(StartExecutionRequest request) {
+        // Check if there's already an active execution for this task
+        LambdaQueryWrapper<PatrolExecution> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(PatrolExecution::getTaskId, request.getTaskId())
+               .in(PatrolExecution::getStatus, "pending", "in_progress");
+        PatrolExecution existing = executionMapper.selectOne(wrapper);
+        if (existing != null) {
+            throw new RuntimeException("该任务已有进行中的巡检执行(ID:" + existing.getId() + ")");
+        }
+
+        PatrolExecution execution = new PatrolExecution();
+        execution.setTaskId(request.getTaskId());
+        execution.setInspectorId(request.getInspectorId());
+        execution.setInspectorName(request.getInspectorName());
+        execution.setStatus("in_progress");
+        execution.setStartTime(LocalDateTime.now());
+        execution.setTotalCheckItems(request.getTotalCheckItems() != null ? request.getTotalCheckItems() : 0);
+        execution.setCompletedCheckItems(0);
+        execution.setIssueCount(0);
+        execution.setTotalDistance(BigDecimal.ZERO);
+        execution.setStartLng(request.getStartLng());
+        execution.setStartLat(request.getStartLat());
+        execution.setRemark(request.getRemark());
+        executionMapper.insert(execution);
+
+        log.info("Patrol execution started: id={}, taskId={}, inspector={}",
+                execution.getId(), execution.getTaskId(), execution.getInspectorName());
+        return execution;
+    }
+
+    /**
+     * 获取执行详情
+     */
+    public PatrolExecution getExecution(Long executionId) {
+        PatrolExecution execution = executionMapper.selectById(executionId);
+        if (execution == null) {
+            throw new RuntimeException("巡检执行不存在: " + executionId);
+        }
+        return execution;
+    }
+
+    /**
+     * 获取某任务的执行列表
+     */
+    public List<PatrolExecution> getExecutionsByTaskId(Long taskId) {
+        LambdaQueryWrapper<PatrolExecution> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(PatrolExecution::getTaskId, taskId)
+               .orderByDesc(PatrolExecution::getStartTime);
+        return executionMapper.selectList(wrapper);
+    }
+
+    /**
+     * 分页查询执行列表
+     */
+    public Page<PatrolExecution> listExecutions(Integer pageNum, Integer pageSize,
+                                                  String status, Long inspectorId) {
+        LambdaQueryWrapper<PatrolExecution> wrapper = new LambdaQueryWrapper<>();
+        if (status != null && !status.isEmpty()) {
+            wrapper.eq(PatrolExecution::getStatus, status);
+        }
+        if (inspectorId != null) {
+            wrapper.eq(PatrolExecution::getInspectorId, inspectorId);
+        }
+        wrapper.orderByDesc(PatrolExecution::getStartTime);
+        return executionMapper.selectPage(new Page<>(pageNum, pageSize), wrapper);
+    }
+
+    /**
+     * 提交检查项记录
+     */
+    @Transactional
+    public CheckItemRecord submitCheckItem(Long executionId, CheckItemRecordRequest request) {
+        PatrolExecution execution = getExecution(executionId);
+        if (!"in_progress".equals(execution.getStatus())) {
+            throw new RuntimeException("巡检执行不在进行中状态");
+        }
+
+        CheckItemRecord record = new CheckItemRecord();
+        record.setExecutionId(executionId);
+        record.setPointSeq(request.getPointSeq());
+        record.setPointName(request.getPointName());
+        record.setItemName(request.getItemName());
+        record.setCheckStatus(request.getCheckStatus());
+        record.setRecordValue(request.getRecordValue());
+        record.setValueUnit(request.getValueUnit());
+        record.setDescription(request.getDescription());
+        record.setRemark(request.getRemark());
+        record.setLng(request.getLng());
+        record.setLat(request.getLat());
+        record.setRecordTime(LocalDateTime.now());
+
+        // Serialize photo URLs
+        if (request.getPhotoUrls() != null && !request.getPhotoUrls().isEmpty()) {
+            record.setPhotoUrls(String.join(",", request.getPhotoUrls()));
+        }
+
+        checkItemRecordMapper.insert(record);
+
+        // Update completed check items count
+        execution.setCompletedCheckItems(execution.getCompletedCheckItems() + 1);
+        executionMapper.updateById(execution);
+
+        log.info("Check item recorded: executionId={}, point={}, item={}, status={}",
+                executionId, request.getPointName(), request.getItemName(), request.getCheckStatus());
+        return record;
+    }
+
+    /**
+     * 批量提交检查项记录
+     */
+    @Transactional
+    public int batchSubmitCheckItems(Long executionId, List<CheckItemRecordRequest> items) {
+        PatrolExecution execution = getExecution(executionId);
+        if (!"in_progress".equals(execution.getStatus())) {
+            throw new RuntimeException("巡检执行不在进行中状态");
+        }
+
+        int count = 0;
+        for (CheckItemRecordRequest request : items) {
+            CheckItemRecord record = new CheckItemRecord();
+            record.setExecutionId(executionId);
+            record.setPointSeq(request.getPointSeq());
+            record.setPointName(request.getPointName());
+            record.setItemName(request.getItemName());
+            record.setCheckStatus(request.getCheckStatus());
+            record.setRecordValue(request.getRecordValue());
+            record.setValueUnit(request.getValueUnit());
+            record.setDescription(request.getDescription());
+            record.setRemark(request.getRemark());
+            record.setLng(request.getLng());
+            record.setLat(request.getLat());
+            record.setRecordTime(LocalDateTime.now());
+            if (request.getPhotoUrls() != null && !request.getPhotoUrls().isEmpty()) {
+                record.setPhotoUrls(String.join(",", request.getPhotoUrls()));
+            }
+            checkItemRecordMapper.insert(record);
+            count++;
+        }
+
+        // Update count
+        execution.setCompletedCheckItems(execution.getCompletedCheckItems() + count);
+        executionMapper.updateById(execution);
+        return count;
+    }
+
+    /**
+     * 获取执行的检查项记录列表
+     */
+    public List<CheckItemRecord> getCheckItemRecords(Long executionId) {
+        LambdaQueryWrapper<CheckItemRecord> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(CheckItemRecord::getExecutionId, executionId)
+               .orderByAsc(CheckItemRecord::getPointSeq)
+               .orderByAsc(CheckItemRecord::getRecordTime);
+        return checkItemRecordMapper.selectList(wrapper);
+    }
+
+    /**
+     * 获取检查项状态汇总
+     */
+    public List<Map<String, Object>> getCheckItemStatusSummary(Long executionId) {
+        return checkItemRecordMapper.selectStatusSummary(executionId);
+    }
+
+    /**
+     * 完成巡检执行
+     */
+    @Transactional
+    public PatrolExecution completeExecution(Long executionId, CompleteExecutionRequest request) {
+        PatrolExecution execution = getExecution(executionId);
+        if (!"in_progress".equals(execution.getStatus())) {
+            throw new RuntimeException("巡检执行不在进行中状态，无法完成");
+        }
+
+        execution.setStatus("completed");
+        execution.setEndTime(LocalDateTime.now());
+        if (request.getEndLng() != null) {
+            execution.setEndLng(request.getEndLng());
+        }
+        if (request.getEndLat() != null) {
+            execution.setEndLat(request.getEndLat());
+        }
+        if (request.getTotalDistance() != null) {
+            execution.setTotalDistance(BigDecimal.valueOf(request.getTotalDistance()));
+        }
+        if (request.getRemark() != null) {
+            execution.setRemark(request.getRemark());
+        }
+        executionMapper.updateById(execution);
+
+        log.info("Patrol execution completed: id={}, distance={}", executionId, execution.getTotalDistance());
+        return execution;
+    }
+
+    /**
+     * 中止巡检执行
+     */
+    @Transactional
+    public PatrolExecution abortExecution(Long executionId, String reason) {
+        PatrolExecution execution = getExecution(executionId);
+        if ("completed".equals(execution.getStatus())) {
+            throw new RuntimeException("已完成的巡检执行无法中止");
+        }
+
+        execution.setStatus("aborted");
+        execution.setEndTime(LocalDateTime.now());
+        execution.setRemark(reason);
+        executionMapper.updateById(execution);
+
+        log.info("Patrol execution aborted: id={}, reason={}", executionId, reason);
+        return execution;
+    }
+
+    /**
+     * 更新异常数量（由IssueService调用）
+     */
+    public void incrementIssueCount(Long executionId) {
+        PatrolExecution execution = getExecution(executionId);
+        execution.setIssueCount(execution.getIssueCount() + 1);
+        executionMapper.updateById(execution);
+    }
+
+    /**
+     * 获取执行统计
+     */
+    public Map<String, Object> getExecutionStats(String startDate, String endDate) {
+        return executionMapper.selectExecutionStats(startDate, endDate);
+    }
+}

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

@@ -0,0 +1,135 @@
+package com.water.patrol.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.water.patrol.entity.PatrolExecution;
+import com.water.patrol.entity.PatrolIssue;
+import com.water.patrol.entity.dto.PatrolIssueRequest;
+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.List;
+import java.util.Map;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class IssueService {
+
+    private final PatrolIssueMapper issueMapper;
+    private final ExecutionService executionService;
+
+    /**
+     * 上报问题
+     */
+    @Transactional
+    public PatrolIssue reportIssue(Long executionId, PatrolIssueRequest request) {
+        // Verify execution exists and is in progress
+        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.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());
+
+        // Serialize photo URLs
+        if (request.getPhotoUrls() != null && !request.getPhotoUrls().isEmpty()) {
+            issue.setPhotoUrls(String.join(",", request.getPhotoUrls()));
+        }
+
+        issueMapper.insert(issue);
+
+        // Update issue count on execution
+        executionService.incrementIssueCount(executionId);
+
+        log.info("Issue reported: executionId={}, type={}, severity={}",
+                executionId, request.getIssueType(), request.getSeverity());
+        return issue;
+    }
+
+    /**
+     * 获取问题详情
+     */
+    public PatrolIssue getIssue(Long issueId) {
+        PatrolIssue issue = issueMapper.selectById(issueId);
+        if (issue == null) {
+            throw new RuntimeException("问题不存在: " + issueId);
+        }
+        return issue;
+    }
+
+    /**
+     * 获取某执行的所有问题
+     */
+    public List<PatrolIssue> getIssuesByExecutionId(Long executionId) {
+        LambdaQueryWrapper<PatrolIssue> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(PatrolIssue::getExecutionId, executionId)
+               .orderByDesc(PatrolIssue::getReportTime);
+        return issueMapper.selectList(wrapper);
+    }
+
+    /**
+     * 更新问题处理状态
+     */
+    @Transactional
+    public PatrolIssue updateIssueStatus(Long issueId, String handleStatus) {
+        PatrolIssue issue = getIssue(issueId);
+        issue.setHandleStatus(handleStatus);
+        issueMapper.updateById(issue);
+        log.info("Issue status updated: id={}, status={}", issueId, handleStatus);
+        return issue;
+    }
+
+    /**
+     * 关联工单
+     */
+    @Transactional
+    public PatrolIssue linkWorkOrder(Long issueId, Long workOrderId) {
+        PatrolIssue issue = getIssue(issueId);
+        issue.setWorkOrderId(workOrderId);
+        issue.setHandleStatus("processing");
+        issueMapper.updateById(issue);
+        log.info("Issue linked to work order: issueId={}, workOrderId={}", issueId, workOrderId);
+        return issue;
+    }
+
+    /**
+     * 获取问题汇总
+     */
+    public List<Map<String, Object>> getIssueSummary(Long executionId) {
+        return issueMapper.selectIssueSummary(executionId);
+    }
+
+    /**
+     * 按类型和状态查询问题列表
+     */
+    public List<PatrolIssue> queryIssues(String issueType, String handleStatus, 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 (executionId != null) {
+            wrapper.eq(PatrolIssue::getExecutionId, executionId);
+        }
+        wrapper.orderByDesc(PatrolIssue::getReportTime);
+        return issueMapper.selectList(wrapper);
+    }
+}

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

@@ -1,118 +0,0 @@
-package com.water.patrol.service;
-
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.jdbc.core.JdbcTemplate;
-import org.springframework.stereotype.Service;
-
-import java.time.LocalDate;
-import java.util.*;
-
-@Slf4j
-@Service
-@RequiredArgsConstructor
-public class PatrolService {
-
-    private final JdbcTemplate jdbc;
-
-    // ========== 路线管理 ==========
-    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,?)",
-            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);
-    }
-
-    // ========== 任务管理 ==========
-    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) " +
-            "SELECT ?, ?, route_name, ?, CAST(? AS TIMESTAMP), CAST(? AS TIMESTAMP) + (estim_duration || ' minutes')::INTERVAL, 'pending' " +
-            "FROM patrol_route 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 " +
-            "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);
-        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 = ?",
-            distance, taskId);
-        return Map.of("taskId", taskId, "status", "completed", "distance", distance);
-    }
-
-    // ========== 巡检记录 ==========
-    public Map<String, Object> recordCheck(Long taskId, int pointSeq, Long deviceId,
-                                            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) " +
-            "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);
-    }
-
-    // ========== 问题上报（巡检APP） ==========
-    public Map<String, Object> reportIssue(Long taskId, Long deviceId, String issueType,
-                                            String description, List<String> photoUrls,
-                                            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 = ?",
-            issueType + ": " + description.substring(0, Math.min(description.length(), 50)), taskId);
-
-        log.info("Issue reported: type={} desc={}", issueType, description);
-        return Map.of("reported", true, "issueType", issueType, "photos", photoUrls);
-    }
-
-    // ========== 统计分析 ==========
-    public Map<String, Object> getStats(String area, LocalDate start, LocalDate end) {
-        Map<String, Object> stats = new LinkedHashMap<>();
-
-        // 任务执行率
-        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));
-
-        // 人员里程
-        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 " +
-            "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",
-            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",
-            start, end));
-
-        return stats;
-    }
-}

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

@@ -0,0 +1,292 @@
+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.PatrolCheckpoint;
+import com.water.patrol.entity.PatrolRoute;
+import com.water.patrol.mapper.PatrolCheckpointMapper;
+import com.water.patrol.mapper.PatrolRouteMapper;
+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.*;
+
+/**
+ * 巡检路线管理服务 - 路线CRUD + 检查点设置 + 路线优化
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class RouteService {
+
+    private final PatrolRouteMapper routeMapper;
+    private final PatrolCheckpointMapper checkpointMapper;
+
+    // ==================== 路线 CRUD ====================
+
+    /**
+     * 分页查询路线
+     */
+    public Page<PatrolRoute> page(int current, int size, String keyword, String area, Integer status) {
+        LambdaQueryWrapper<PatrolRoute> wrapper = new LambdaQueryWrapper<>();
+        if (keyword != null && !keyword.isEmpty()) {
+            wrapper.and(w -> w.like(PatrolRoute::getRouteName, keyword)
+                    .or().like(PatrolRoute::getRouteCode, keyword)
+                    .or().like(PatrolRoute::getArea, keyword));
+        }
+        if (area != null && !area.isEmpty()) {
+            wrapper.eq(PatrolRoute::getArea, area);
+        }
+        if (status != null) {
+            wrapper.eq(PatrolRoute::getStatus, status);
+        }
+        wrapper.orderByDesc(PatrolRoute::getCreatedTime);
+        return routeMapper.selectPage(new Page<>(current, size), wrapper);
+    }
+
+    /**
+     * 查询路线详情
+     */
+    public PatrolRoute getById(Long id) {
+        return routeMapper.selectById(id);
+    }
+
+    /**
+     * 创建路线
+     */
+    @Transactional
+    public PatrolRoute create(PatrolRoute route) {
+        route.setCreatedTime(LocalDateTime.now());
+        route.setUpdatedTime(LocalDateTime.now());
+        route.setDeleted(0);
+        if (route.getStatus() == null) route.setStatus(1);
+        if (route.getEstimDuration() == null) route.setEstimDuration(60);
+        if (route.getTotalDistance() == null) route.setTotalDistance(0.0);
+        routeMapper.insert(route);
+        return route;
+    }
+
+    /**
+     * 更新路线
+     */
+    @Transactional
+    public boolean update(PatrolRoute route) {
+        route.setUpdatedTime(LocalDateTime.now());
+        return routeMapper.updateById(route) > 0;
+    }
+
+    /**
+     * 删除路线(逻辑删除)
+     */
+    @Transactional
+    public boolean delete(Long id) {
+        return routeMapper.deleteById(id) > 0;
+    }
+
+    /**
+     * 启用/停用路线
+     */
+    @Transactional
+    public boolean toggleStatus(Long id, int status) {
+        PatrolRoute route = new PatrolRoute();
+        route.setId(id);
+        route.setStatus(status);
+        route.setUpdatedTime(LocalDateTime.now());
+        return routeMapper.updateById(route) > 0;
+    }
+
+    /**
+     * 按区域统计路线数
+     */
+    public List<Map<String, Object>> countByArea() {
+        return routeMapper.countByArea();
+    }
+
+    // ==================== 检查点管理 ====================
+
+    /**
+     * 查询路线的所有检查点
+     */
+    public List<PatrolCheckpoint> getCheckpoints(Long routeId) {
+        return checkpointMapper.findByRouteId(routeId);
+    }
+
+    /**
+     * 批量设置路线检查点(替换模式)
+     */
+    @Transactional
+    public List<PatrolCheckpoint> setCheckpoints(Long routeId, List<PatrolCheckpoint> checkpoints) {
+        // 先删除旧检查点(逻辑删除)
+        LambdaQueryWrapper<PatrolCheckpoint> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(PatrolCheckpoint::getRouteId, routeId);
+        checkpointMapper.delete(wrapper);
+
+        // 批量插入新检查点
+        List<PatrolCheckpoint> saved = new ArrayList<>();
+        for (int i = 0; i < checkpoints.size(); i++) {
+            PatrolCheckpoint cp = checkpoints.get(i);
+            cp.setId(null);
+            cp.setRouteId(routeId);
+            cp.setSeq(i + 1);
+            cp.setDeleted(0);
+            cp.setCreatedTime(LocalDateTime.now());
+            cp.setUpdatedTime(LocalDateTime.now());
+            if (cp.getRequired() == null) cp.setRequired(1);
+            checkpointMapper.insert(cp);
+            saved.add(cp);
+        }
+
+        // 更新路线的检查点数量信息
+        updateRouteDistanceAndDuration(routeId);
+
+        return saved;
+    }
+
+    /**
+     * 添加单个检查点
+     */
+    @Transactional
+    public PatrolCheckpoint addCheckpoint(PatrolCheckpoint checkpoint) {
+        checkpoint.setDeleted(0);
+        checkpoint.setCreatedTime(LocalDateTime.now());
+        checkpoint.setUpdatedTime(LocalDateTime.now());
+        if (checkpoint.getRequired() == null) checkpoint.setRequired(1);
+        // 自动设置序号为最后
+        int count = checkpointMapper.countByRouteId(checkpoint.getRouteId());
+        checkpoint.setSeq(count + 1);
+        checkpointMapper.insert(checkpoint);
+        return checkpoint;
+    }
+
+    /**
+     * 删除检查点
+     */
+    @Transactional
+    public boolean deleteCheckpoint(Long id) {
+        return checkpointMapper.deleteById(id) > 0;
+    }
+
+    // ==================== 路线优化 ====================
+
+    /**
+     * 路线优化 - 根据检查点坐标计算最优距离(贪心最近邻)
+     * 返回优化后的距离和顺序建议
+     */
+    public Map<String, Object> optimizeRoute(Long routeId) {
+        List<PatrolCheckpoint> checkpoints = checkpointMapper.findByRouteId(routeId);
+        if (checkpoints.size() < 2) {
+            return Map.of("optimized", false, "reason", "检查点数量不足，无需优化");
+        }
+
+        // 贪心最近邻算法优化顺序
+        List<PatrolCheckpoint> optimized = nearestNeighborOptimize(checkpoints);
+
+        double totalDistance = calculateTotalDistance(optimized);
+
+        // 重新排列序号
+        for (int i = 0; i < optimized.size(); i++) {
+            PatrolCheckpoint cp = optimized.get(i);
+            PatrolCheckpoint update = new PatrolCheckpoint();
+            update.setId(cp.getId());
+            update.setSeq(i + 1);
+            update.setUpdatedTime(LocalDateTime.now());
+            checkpointMapper.updateById(update);
+        }
+
+        // 更新路线距离
+        PatrolRoute routeUpdate = new PatrolRoute();
+        routeUpdate.setId(routeId);
+        routeUpdate.setTotalDistance(Math.round(totalDistance * 100.0) / 100.0);
+        routeUpdate.setEstimDuration((int) (totalDistance / 4.0 * 60)); // 按4km/h步行速度估算
+        routeUpdate.setUpdatedTime(LocalDateTime.now());
+        routeMapper.updateById(routeUpdate);
+
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("optimized", true);
+        result.put("checkpointCount", optimized.size());
+        result.put("totalDistanceKm", Math.round(totalDistance * 100.0) / 100.0);
+        result.put("estimatedMinutes", (int) (totalDistance / 4.0 * 60));
+        result.put("optimizedOrder", optimized.stream().map(PatrolCheckpoint::getName).toList());
+        return result;
+    }
+
+    /**
+     * 最近邻优化
+     */
+    private List<PatrolCheckpoint> nearestNeighborOptimize(List<PatrolCheckpoint> checkpoints) {
+        List<PatrolCheckpoint> remaining = new ArrayList<>(checkpoints);
+        List<PatrolCheckpoint> result = new ArrayList<>();
+
+        // 从第一个检查点开始
+        PatrolCheckpoint current = remaining.remove(0);
+        result.add(current);
+
+        while (!remaining.isEmpty()) {
+            PatrolCheckpoint nearest = null;
+            double minDist = Double.MAX_VALUE;
+            for (PatrolCheckpoint cp : remaining) {
+                double dist = haversine(
+                        current.getLat() != null ? current.getLat() : 0,
+                        current.getLng() != null ? current.getLng() : 0,
+                        cp.getLat() != null ? cp.getLat() : 0,
+                        cp.getLng() != null ? cp.getLng() : 0);
+                if (dist < minDist) {
+                    minDist = dist;
+                    nearest = cp;
+                }
+            }
+            remaining.remove(nearest);
+            result.add(nearest);
+            current = nearest;
+        }
+        return result;
+    }
+
+    /**
+     * 计算总距离
+     */
+    private double calculateTotalDistance(List<PatrolCheckpoint> checkpoints) {
+        double total = 0;
+        for (int i = 1; i < checkpoints.size(); i++) {
+            PatrolCheckpoint prev = checkpoints.get(i - 1);
+            PatrolCheckpoint curr = checkpoints.get(i);
+            total += haversine(
+                    prev.getLat() != null ? prev.getLat() : 0,
+                    prev.getLng() != null ? prev.getLng() : 0,
+                    curr.getLat() != null ? curr.getLat() : 0,
+                    curr.getLng() != null ? curr.getLng() : 0);
+        }
+        return total;
+    }
+
+    /**
+     * Haversine公式计算两点距离(km)
+     */
+    double haversine(double lat1, double lng1, double lat2, double lng2) {
+        final double R = 6371.0;
+        double dLat = Math.toRadians(lat2 - lat1);
+        double dLng = Math.toRadians(lng2 - lng1);
+        double a = Math.sin(dLat / 2) * Math.sin(dLat / 2)
+                + Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2))
+                * Math.sin(dLng / 2) * Math.sin(dLng / 2);
+        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+        return R * c;
+    }
+
+    /**
+     * 更新路线距离和时长估算
+     */
+    private void updateRouteDistanceAndDuration(Long routeId) {
+        List<PatrolCheckpoint> checkpoints = checkpointMapper.findByRouteId(routeId);
+        double distance = calculateTotalDistance(checkpoints);
+        PatrolRoute route = new PatrolRoute();
+        route.setId(routeId);
+        route.setTotalDistance(Math.round(distance * 100.0) / 100.0);
+        route.setEstimDuration((int) (distance / 4.0 * 60));
+        route.setUpdatedTime(LocalDateTime.now());
+        routeMapper.updateById(route);
+    }
+}

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

@@ -0,0 +1,362 @@
+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.PatrolCheckpoint;
+import com.water.patrol.entity.PatrolRoute;
+import com.water.patrol.entity.PatrolTask;
+import com.water.patrol.entity.PatrolWorker;
+import com.water.patrol.mapper.PatrolCheckpointMapper;
+import com.water.patrol.mapper.PatrolRouteMapper;
+import com.water.patrol.mapper.PatrolTaskMapper;
+import com.water.patrol.mapper.PatrolWorkerMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.temporal.TemporalAdjusters;
+import java.util.*;
+
+/**
+ * 巡检任务管理服务 - 任务创建 + 自动/手动分派 + 周期任务
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class TaskService {
+
+    private final PatrolTaskMapper taskMapper;
+    private final PatrolRouteMapper routeMapper;
+    private final PatrolWorkerMapper workerMapper;
+    private final PatrolCheckpointMapper checkpointMapper;
+
+    // ==================== 任务 CRUD ====================
+
+    /**
+     * 分页查询任务
+     */
+    public Page<PatrolTask> page(int current, int size, String keyword, String status,
+                                  LocalDate startDate, LocalDate endDate, Long workerId) {
+        LambdaQueryWrapper<PatrolTask> wrapper = new LambdaQueryWrapper<>();
+        if (keyword != null && !keyword.isEmpty()) {
+            wrapper.like(PatrolTask::getTaskName, keyword);
+        }
+        if (status != null && !status.isEmpty()) {
+            wrapper.eq(PatrolTask::getStatus, status);
+        }
+        if (startDate != null) {
+            wrapper.ge(PatrolTask::getTaskDate, startDate);
+        }
+        if (endDate != null) {
+            wrapper.le(PatrolTask::getTaskDate, endDate);
+        }
+        if (workerId != null) {
+            wrapper.eq(PatrolTask::getWorkerId, workerId);
+        }
+        wrapper.orderByDesc(PatrolTask::getTaskDate).orderByAsc(PatrolTask::getPlanStart);
+        return taskMapper.selectPage(new Page<>(current, size), wrapper);
+    }
+
+    /**
+     * 查询任务详情
+     */
+    public PatrolTask getById(Long id) {
+        return taskMapper.selectById(id);
+    }
+
+    /**
+     * 创建任务
+     */
+    @Transactional
+    public PatrolTask create(PatrolTask task) {
+        task.setCreatedTime(LocalDateTime.now());
+        task.setUpdatedTime(LocalDateTime.now());
+        task.setDeleted(0);
+        if (task.getStatus() == null) task.setStatus("pending");
+        if (task.getPriority() == null) task.setPriority(0);
+        if (task.getDistance() == null) task.setDistance(0.0);
+        if (task.getCheckpointDone() == null) task.setCheckpointDone(0);
+
+        // 如果关联了路线，自动设置检查点总数和计划时间
+        if (task.getRouteId() != null) {
+            int cpCount = checkpointMapper.countByRouteId(task.getRouteId());
+            task.setCheckpointTotal(cpCount);
+
+            PatrolRoute route = routeMapper.selectById(task.getRouteId());
+            if (route != null && task.getTaskName() == null) {
+                task.setTaskName("巡检: " + route.getRouteName());
+            }
+        }
+        if (task.getCheckpointTotal() == null) task.setCheckpointTotal(0);
+
+        if (task.getTaskDate() != null) {
+            LocalDateTime dateStart = task.getTaskDate().atTime(9, 0);
+            if (task.getPlanStart() == null) task.setPlanStart(dateStart);
+            if (task.getPlanEnd() == null) {
+                int duration = 60;
+                if (task.getRouteId() != null) {
+                    PatrolRoute route = routeMapper.selectById(task.getRouteId());
+                    if (route != null && route.getEstimDuration() != null) {
+                        duration = route.getEstimDuration();
+                    }
+                }
+                task.setPlanEnd(dateStart.plusMinutes(duration));
+            }
+        }
+
+        taskMapper.insert(task);
+        return task;
+    }
+
+    /**
+     * 更新任务
+     */
+    @Transactional
+    public boolean update(PatrolTask task) {
+        task.setUpdatedTime(LocalDateTime.now());
+        return taskMapper.updateById(task) > 0;
+    }
+
+    /**
+     * 删除任务
+     */
+    @Transactional
+    public boolean delete(Long id) {
+        return taskMapper.deleteById(id) > 0;
+    }
+
+    // ==================== 任务分派 ====================
+
+    /**
+     * 手动分派任务给巡检员
+     */
+    @Transactional
+    public boolean assign(Long taskId, Long workerId) {
+        PatrolTask task = new PatrolTask();
+        task.setId(taskId);
+        task.setWorkerId(workerId);
+        task.setStatus("assigned");
+        task.setUpdatedTime(LocalDateTime.now());
+        return taskMapper.updateById(task) > 0;
+    }
+
+    /**
+     * 自动分派 - 选择当前负荷最低的可用巡检员
+     */
+    @Transactional
+    public Map<String, Object> autoAssign(Long taskId) {
+        PatrolTask task = taskMapper.selectById(taskId);
+        if (task == null) {
+            return Map.of("success", false, "reason", "任务不存在");
+        }
+
+        // 查找在岗的巡检员
+        List<PatrolWorker> workers = workerMapper.findActive();
+        if (workers.isEmpty()) {
+            return Map.of("success", false, "reason", "无可用巡检员");
+        }
+
+        // 计算每个巡检员当天的任务负荷
+        PatrolWorker bestWorker = null;
+        int minLoad = Integer.MAX_VALUE;
+
+        for (PatrolWorker worker : workers) {
+            List<PatrolTask> workerTasks = taskMapper.findByDateAndWorker(task.getTaskDate(), worker.getId());
+            if (workerTasks.size() < minLoad) {
+                minLoad = workerTasks.size();
+                bestWorker = worker;
+            }
+        }
+
+        if (bestWorker == null) {
+            return Map.of("success", false, "reason", "无法选择巡检员");
+        }
+
+        // 分派任务
+        assign(taskId, bestWorker.getId());
+
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("success", true);
+        result.put("taskId", taskId);
+        result.put("workerId", bestWorker.getId());
+        result.put("workerName", bestWorker.getName());
+        result.put("currentLoad", minLoad);
+        return result;
+    }
+
+    /**
+     * 批量自动分派 - 对指定日期的所有pending任务进行自动分派
+     */
+    @Transactional
+    public Map<String, Object> batchAutoAssign(LocalDate date) {
+        LambdaQueryWrapper<PatrolTask> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(PatrolTask::getStatus, "pending");
+        wrapper.eq(PatrolTask::getTaskDate, date);
+        wrapper.eq(PatrolTask::getDeleted, 0);
+        List<PatrolTask> pendingTasks = taskMapper.selectList(wrapper);
+
+        int assigned = 0;
+        for (PatrolTask task : pendingTasks) {
+            Map<String, Object> result = autoAssign(task.getId());
+            if (Boolean.TRUE.equals(result.get("success"))) {
+                assigned++;
+            }
+        }
+
+        return Map.of("total", pendingTasks.size(), "assigned", assigned, "date", date.toString());
+    }
+
+    /**
+     * 开始任务
+     */
+    @Transactional
+    public boolean startTask(Long taskId) {
+        PatrolTask task = new PatrolTask();
+        task.setId(taskId);
+        task.setStatus("in_progress");
+        task.setActualStart(LocalDateTime.now());
+        task.setUpdatedTime(LocalDateTime.now());
+        return taskMapper.updateById(task) > 0;
+    }
+
+    /**
+     * 完成任务
+     */
+    @Transactional
+    public boolean completeTask(Long taskId, Double distance) {
+        PatrolTask task = new PatrolTask();
+        task.setId(taskId);
+        task.setStatus("completed");
+        task.setActualEnd(LocalDateTime.now());
+        task.setDistance(distance);
+        task.setUpdatedTime(LocalDateTime.now());
+        return taskMapper.updateById(task) > 0;
+    }
+
+    /**
+     * 取消任务
+     */
+    @Transactional
+    public boolean cancelTask(Long taskId, String reason) {
+        PatrolTask task = new PatrolTask();
+        task.setId(taskId);
+        task.setStatus("cancelled");
+        task.setRemark(reason);
+        task.setUpdatedTime(LocalDateTime.now());
+        return taskMapper.updateById(task) > 0;
+    }
+
+    // ==================== 周期任务 ====================
+
+    /**
+     * 创建周期任务(日/周/月)
+     * 从指定开始日期起，生成N个周期的任务
+     */
+    @Transactional
+    public Map<String, Object> createCycleTask(PatrolTask template, String cycleType,
+                                                 LocalDate startDate, int cycles) {
+        List<LocalDate> dates = generateCycleDates(cycleType, startDate, cycles);
+        List<PatrolTask> createdTasks = new ArrayList<>();
+
+        for (LocalDate date : dates) {
+            PatrolTask task = new PatrolTask();
+            task.setTaskName(template.getTaskName());
+            task.setRouteId(template.getRouteId());
+            task.setWorkerId(template.getWorkerId());
+            task.setTaskDate(date);
+            task.setCycleType(cycleType);
+            task.setPriority(template.getPriority());
+            task.setRemark(template.getRemark());
+
+            // 直接创建
+            task.setCreatedTime(LocalDateTime.now());
+            task.setUpdatedTime(LocalDateTime.now());
+            task.setDeleted(0);
+            task.setStatus(template.getWorkerId() != null ? "assigned" : "pending");
+            if (task.getPriority() == null) task.setPriority(0);
+            task.setDistance(0.0);
+            task.setCheckpointDone(0);
+
+            if (task.getRouteId() != null) {
+                int cpCount = checkpointMapper.countByRouteId(task.getRouteId());
+                task.setCheckpointTotal(cpCount);
+            }
+            if (task.getCheckpointTotal() == null) task.setCheckpointTotal(0);
+
+            LocalDateTime dateStart = date.atTime(9, 0);
+            task.setPlanStart(dateStart);
+            int duration = 60;
+            if (task.getRouteId() != null) {
+                PatrolRoute route = routeMapper.selectById(task.getRouteId());
+                if (route != null && route.getEstimDuration() != null) {
+                    duration = route.getEstimDuration();
+                }
+            }
+            task.setPlanEnd(dateStart.plusMinutes(duration));
+
+            taskMapper.insert(task);
+            createdTasks.add(task);
+        }
+
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("cycleType", cycleType);
+        result.put("startDate", startDate.toString());
+        result.put("cycles", cycles);
+        result.put("created", createdTasks.size());
+        result.put("tasks", createdTasks.stream().map(t -> Map.of("id", t.getId(), "date", t.getTaskDate().toString())).toList());
+        return result;
+    }
+
+    /**
+     * 根据周期类型生成日期列表
+     */
+    List<LocalDate> generateCycleDates(String cycleType, LocalDate startDate, int cycles) {
+        List<LocalDate> dates = new ArrayList<>();
+        LocalDate current = startDate;
+
+        for (int i = 0; i < cycles; i++) {
+            dates.add(current);
+            switch (cycleType.toLowerCase()) {
+                case "daily" -> current = current.plusDays(1);
+                case "weekly" -> current = current.plusWeeks(1);
+                case "monthly" -> current = current.plusMonths(1);
+                default -> current = current.plusDays(1);
+            }
+        }
+        return dates;
+    }
+
+    // ==================== 统计 ====================
+
+    /**
+     * 任务统计
+     */
+    public Map<String, Object> getTaskStats(LocalDate startDate, LocalDate endDate) {
+        Map<String, Object> stats = new LinkedHashMap<>();
+
+        // 按状态统计
+        List<Map<String, Object>> statusCounts = taskMapper.countByStatusInRange(startDate, endDate);
+        stats.put("byStatus", statusCounts);
+
+        // 人员工作量
+        List<Map<String, Object>> workload = taskMapper.workloadByWorker(startDate, endDate);
+        stats.put("workload", workload);
+
+        // 总计
+        int total = statusCounts.stream().mapToInt(m -> ((Number) m.get("count")).intValue()).sum();
+        int completed = statusCounts.stream()
+                .filter(m -> "completed".equals(m.get("status")))
+                .mapToInt(m -> ((Number) m.get("count")).intValue())
+                .sum();
+        stats.put("total", total);
+        stats.put("completed", completed);
+        stats.put("completionRate", total > 0 ? Math.round(completed * 100.0 / total) : 0);
+
+        return stats;
+    }
+}

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

@@ -0,0 +1,176 @@
+package com.water.patrol.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.water.patrol.entity.GpsTrackPoint;
+import com.water.patrol.entity.dto.GpsTrackBatchRequest;
+import com.water.patrol.mapper.GpsTrackPointMapper;
+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.*;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class TrackService {
+
+    private final GpsTrackPointMapper trackPointMapper;
+
+    /**
+     * 记录单个GPS轨迹点
+     */
+    public GpsTrackPoint recordTrackPoint(Long executionId, Double lng, Double lat,
+                                           Double altitude, Double speed,
+                                           Double bearing, Double accuracy) {
+        GpsTrackPoint point = new GpsTrackPoint();
+        point.setExecutionId(executionId);
+        point.setLng(lng);
+        point.setLat(lat);
+        point.setAltitude(altitude);
+        point.setSpeed(speed);
+        point.setBearing(bearing);
+        point.setAccuracy(accuracy);
+        point.setRecordTime(LocalDateTime.now());
+        trackPointMapper.insert(point);
+        return point;
+    }
+
+    /**
+     * 批量记录GPS轨迹点
+     */
+    @Transactional
+    public int batchRecordTrackPoints(Long executionId, GpsTrackBatchRequest request) {
+        if (request.getPoints() == null || request.getPoints().isEmpty()) {
+            return 0;
+        }
+
+        DateTimeFormatter formatter = DateTimeFormatter.ISO_DATE_TIME;
+        int count = 0;
+        for (GpsTrackBatchRequest.GpsTrackPointDto dto : request.getPoints()) {
+            GpsTrackPoint point = new GpsTrackPoint();
+            point.setExecutionId(executionId);
+            point.setLng(dto.getLng());
+            point.setLat(dto.getLat());
+            point.setAltitude(dto.getAltitude());
+            point.setSpeed(dto.getSpeed());
+            point.setBearing(dto.getBearing());
+            point.setAccuracy(dto.getAccuracy());
+
+            if (dto.getRecordTime() != null && !dto.getRecordTime().isEmpty()) {
+                point.setRecordTime(LocalDateTime.parse(dto.getRecordTime(), formatter));
+            } else {
+                point.setRecordTime(LocalDateTime.now());
+            }
+
+            trackPointMapper.insert(point);
+            count++;
+        }
+
+        log.info("Batch recorded {} GPS track points for execution {}", count, executionId);
+        return count;
+    }
+
+    /**
+     * 获取完整轨迹（用于回放）
+     */
+    public List<GpsTrackPoint> getTrackPoints(Long executionId) {
+        return trackPointMapper.selectTrackByExecutionId(executionId);
+    }
+
+    /**
+     * 获取轨迹摘要数据（用于地图展示，减少数据量）
+     */
+    public Map<String, Object> getTrackSummary(Long executionId) {
+        List<GpsTrackPoint> points = getTrackPoints(executionId);
+
+        Map<String, Object> summary = new LinkedHashMap<>();
+        summary.put("executionId", executionId);
+        summary.put("totalPoints", points.size());
+
+        if (points.isEmpty()) {
+            summary.put("distance", 0.0);
+            summary.put("duration", 0);
+            summary.put("avgSpeed", 0.0);
+            summary.put("points", List.of());
+            return summary;
+        }
+
+        // Calculate total distance using Haversine formula
+        double totalDistance = 0.0;
+        for (int i = 1; i < points.size(); i++) {
+            totalDistance += haversineDistance(
+                    points.get(i - 1).getLat(), points.get(i - 1).getLng(),
+                    points.get(i).getLat(), points.get(i).getLng());
+        }
+
+        // Duration in minutes
+        LocalDateTime start = points.get(0).getRecordTime();
+        LocalDateTime end = points.get(points.size() - 1).getRecordTime();
+        long durationMinutes = java.time.Duration.between(start, end).toMinutes();
+
+        // Average speed
+        double avgSpeed = points.stream()
+                .filter(p -> p.getSpeed() != null)
+                .mapToDouble(GpsTrackPoint::getSpeed)
+                .average()
+                .orElse(0.0);
+
+        // Simplify points for map display (keep every Nth point)
+        int step = Math.max(1, points.size() / 200);
+        List<Map<String, Object>> simplifiedPoints = new ArrayList<>();
+        for (int i = 0; i < points.size(); i += step) {
+            GpsTrackPoint p = points.get(i);
+            Map<String, Object> sp = new LinkedHashMap<>();
+            sp.put("lng", p.getLng());
+            sp.put("lat", p.getLat());
+            sp.put("t", p.getRecordTime() != null ? p.getRecordTime().toString() : null);
+            simplifiedPoints.add(sp);
+        }
+        // Always include last point
+        if (points.size() % step != 1) {
+            GpsTrackPoint last = points.get(points.size() - 1);
+            Map<String, Object> sp = new LinkedHashMap<>();
+            sp.put("lng", last.getLng());
+            sp.put("lat", last.getLat());
+            sp.put("t", last.getRecordTime() != null ? last.getRecordTime().toString() : null);
+            simplifiedPoints.add(sp);
+        }
+
+        summary.put("distance", Math.round(totalDistance * 1000.0) / 1000.0); // km
+        summary.put("duration", durationMinutes);
+        summary.put("avgSpeed", Math.round(avgSpeed * 100.0) / 100.0);
+        summary.put("points", simplifiedPoints);
+
+        return summary;
+    }
+
+    /**
+     * 获取最新位置
+     */
+    public GpsTrackPoint getLatestPosition(Long executionId) {
+        LambdaQueryWrapper<GpsTrackPoint> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(GpsTrackPoint::getExecutionId, executionId)
+               .orderByDesc(GpsTrackPoint::getRecordTime)
+               .last("LIMIT 1");
+        return trackPointMapper.selectOne(wrapper);
+    }
+
+    /**
+     * Haversine公式计算两点距离(km)
+     */
+    private double haversineDistance(double lat1, double lng1, double lat2, double lng2) {
+        final double R = 6371.0; // Earth radius in km
+        double dLat = Math.toRadians(lat2 - lat1);
+        double dLng = Math.toRadians(lng2 - lng1);
+        double a = Math.sin(dLat / 2) * Math.sin(dLat / 2)
+                + Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2))
+                * Math.sin(dLng / 2) * Math.sin(dLng / 2);
+        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+        return R * c;
+    }
+}

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

@@ -0,0 +1,178 @@
+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.PatrolTask;
+import com.water.patrol.entity.PatrolWorker;
+import com.water.patrol.mapper.PatrolTaskMapper;
+import com.water.patrol.mapper.PatrolWorkerMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 巡检人员管理服务 - 巡检员信息 + 技能标签 + 工作负荷
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class WorkerService {
+
+    private final PatrolWorkerMapper workerMapper;
+    private final PatrolTaskMapper taskMapper;
+
+    // ==================== 人员 CRUD ====================
+
+    /**
+     * 分页查询巡检员
+     */
+    public Page<PatrolWorker> page(int current, int size, String keyword, Integer status) {
+        LambdaQueryWrapper<PatrolWorker> wrapper = new LambdaQueryWrapper<>();
+        if (keyword != null && !keyword.isEmpty()) {
+            wrapper.and(w -> w.like(PatrolWorker::getName, keyword)
+                    .or().like(PatrolWorker::getPhone, keyword)
+                    .or().like(PatrolWorker::getDept, keyword));
+        }
+        if (status != null) {
+            wrapper.eq(PatrolWorker::getStatus, status);
+        }
+        wrapper.orderByAsc(PatrolWorker::getName);
+        return workerMapper.selectPage(new Page<>(current, size), wrapper);
+    }
+
+    /**
+     * 查询巡检员详情
+     */
+    public PatrolWorker getById(Long id) {
+        return workerMapper.selectById(id);
+    }
+
+    /**
+     * 创建巡检员
+     */
+    @Transactional
+    public PatrolWorker create(PatrolWorker worker) {
+        worker.setCreatedTime(LocalDateTime.now());
+        worker.setUpdatedTime(LocalDateTime.now());
+        worker.setDeleted(0);
+        if (worker.getStatus() == null) worker.setStatus(1);
+        workerMapper.insert(worker);
+        return worker;
+    }
+
+    /**
+     * 更新巡检员
+     */
+    @Transactional
+    public boolean update(PatrolWorker worker) {
+        worker.setUpdatedTime(LocalDateTime.now());
+        return workerMapper.updateById(worker) > 0;
+    }
+
+    /**
+     * 删除巡检员(逻辑删除)
+     */
+    @Transactional
+    public boolean delete(Long id) {
+        return workerMapper.deleteById(id) > 0;
+    }
+
+    /**
+     * 查询所有在岗巡检员
+     */
+    public List<PatrolWorker> findActive() {
+        return workerMapper.findActive();
+    }
+
+    // ==================== 技能标签 ====================
+
+    /**
+     * 按技能筛选巡检员
+     */
+    public List<PatrolWorker> findBySkill(String skillTag) {
+        LambdaQueryWrapper<PatrolWorker> wrapper = new LambdaQueryWrapper<>();
+        wrapper.like(PatrolWorker::getSkillTags, skillTag);
+        wrapper.eq(PatrolWorker::getStatus, 1);
+        wrapper.eq(PatrolWorker::getDeleted, 0);
+        return workerMapper.selectList(wrapper);
+    }
+
+    /**
+     * 更新技能标签
+     */
+    @Transactional
+    public boolean updateSkillTags(Long workerId, String skillTags) {
+        PatrolWorker worker = new PatrolWorker();
+        worker.setId(workerId);
+        worker.setSkillTags(skillTags);
+        worker.setUpdatedTime(LocalDateTime.now());
+        return workerMapper.updateById(worker) > 0;
+    }
+
+    // ==================== 工作负荷 ====================
+
+    /**
+     * 查询巡检员工作负荷(指定日期范围)
+     */
+    public Map<String, Object> getWorkload(Long workerId, LocalDate startDate, LocalDate endDate) {
+        LambdaQueryWrapper<PatrolTask> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(PatrolTask::getWorkerId, workerId);
+        wrapper.ge(PatrolTask::getTaskDate, startDate);
+        wrapper.le(PatrolTask::getTaskDate, endDate);
+        wrapper.eq(PatrolTask::getDeleted, 0);
+        List<PatrolTask> tasks = taskMapper.selectList(wrapper);
+
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("workerId", workerId);
+        result.put("startDate", startDate.toString());
+        result.put("endDate", endDate.toString());
+        result.put("totalTasks", tasks.size());
+        result.put("completed", tasks.stream().filter(t -> "completed".equals(t.getStatus())).count());
+        result.put("inProgress", tasks.stream().filter(t -> "in_progress".equals(t.getStatus())).count());
+        result.put("pending", tasks.stream().filter(t -> "pending".equals(t.getStatus()) || "assigned".equals(t.getStatus())).count());
+        result.put("totalDistance", tasks.stream()
+                .filter(t -> t.getDistance() != null)
+                .mapToDouble(PatrolTask::getDistance)
+                .sum());
+        result.put("tasks", tasks);
+        return result;
+    }
+
+    /**
+     * 查询所有巡检员负荷概览
+     */
+    public List<Map<String, Object>> getWorkloadOverview(LocalDate date) {
+        List<PatrolWorker> workers = workerMapper.findActive();
+        List<Map<String, Object>> overview = new ArrayList<>();
+
+        for (PatrolWorker worker : workers) {
+            List<PatrolTask> dayTasks = taskMapper.findByDateAndWorker(date, worker.getId());
+            Map<String, Object> item = new LinkedHashMap<>();
+            item.put("workerId", worker.getId());
+            item.put("workerName", worker.getName());
+            item.put("dept", worker.getDept());
+            item.put("taskCount", dayTasks.size());
+            item.put("completed", dayTasks.stream().filter(t -> "completed".equals(t.getStatus())).count());
+            item.put("totalDistance", dayTasks.stream()
+                    .filter(t -> t.getDistance() != null)
+                    .mapToDouble(PatrolTask::getDistance)
+                    .sum());
+            overview.add(item);
+        }
+
+        return overview;
+    }
+
+    /**
+     * 按部门统计人数
+     */
+    public List<Map<String, Object>> countByDept() {
+        return workerMapper.countByDept();
+    }
+}

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

@@ -0,0 +1,170 @@
+-- ============================================================
+-- 巡检路线管理与任务分派 DDL
+-- ============================================================
+
+-- 巡检人员表
+CREATE TABLE IF NOT EXISTS patrol_worker (
+    id          BIGSERIAL PRIMARY KEY,
+    name        VARCHAR(50)  NOT NULL,
+    phone       VARCHAR(20),
+    dept        VARCHAR(100),
+    skill_tags  VARCHAR(500),           -- JSON数组: ["管道","阀门","水表"]
+    status      INT DEFAULT 1,          -- 1=在岗 0=休假 -1=离职
+    created_time TIMESTAMP DEFAULT NOW(),
+    updated_time TIMESTAMP DEFAULT NOW(),
+    deleted     INT DEFAULT 0
+);
+
+-- 巡检路线表
+CREATE TABLE IF NOT EXISTS patrol_route (
+    id             BIGSERIAL PRIMARY KEY,
+    route_name     VARCHAR(200) NOT NULL,
+    route_code     VARCHAR(50),
+    area           VARCHAR(100),
+    description    TEXT,
+    total_distance DOUBLE PRECISION DEFAULT 0,  -- 公里
+    estim_duration INT DEFAULT 60,              -- 分钟
+    status         INT DEFAULT 1,               -- 1=启用 0=停用
+    created_by     BIGINT,
+    updated_by     BIGINT,
+    created_time   TIMESTAMP DEFAULT NOW(),
+    updated_time   TIMESTAMP DEFAULT NOW(),
+    deleted        INT DEFAULT 0
+);
+
+-- 巡检检查点表
+CREATE TABLE IF NOT EXISTS patrol_checkpoint (
+    id            BIGSERIAL PRIMARY KEY,
+    route_id      BIGINT NOT NULL REFERENCES patrol_route(id),
+    seq           INT NOT NULL,                  -- 检查点顺序
+    name          VARCHAR(200) NOT NULL,
+    check_type    VARCHAR(50),                   -- 检查类型: visual/device/read
+    device_id     BIGINT,                        -- 关联设备ID(可选)
+    lng           DOUBLE PRECISION,
+    lat           DOUBLE PRECISION,
+    check_items   TEXT,                          -- JSON数组: 检查项列表
+    required      INT DEFAULT 1,                 -- 1=必检 0=选检
+    created_time  TIMESTAMP DEFAULT NOW(),
+    updated_time  TIMESTAMP DEFAULT NOW(),
+    deleted       INT DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_checkpoint_route ON patrol_checkpoint(route_id);
+
+-- 巡检任务表
+CREATE TABLE IF NOT EXISTS patrol_task (
+    id              BIGSERIAL PRIMARY KEY,
+    task_name       VARCHAR(200) NOT NULL,
+    route_id        BIGINT REFERENCES patrol_route(id),
+    worker_id       BIGINT REFERENCES patrol_worker(id),
+    task_date       DATE NOT NULL,
+    cycle_type      VARCHAR(20),                -- daily/weekly/monthly/once
+    plan_start      TIMESTAMP,
+    plan_end        TIMESTAMP,
+    actual_start    TIMESTAMP,
+    actual_end      TIMESTAMP,
+    status          VARCHAR(20) DEFAULT 'pending', -- pending/assigned/in_progress/completed/cancelled
+    priority        INT DEFAULT 0,
+    distance        DOUBLE PRECISION DEFAULT 0,
+    checkpoint_done INT DEFAULT 0,              -- 已完成检查点数
+    checkpoint_total INT DEFAULT 0,             -- 总检查点数
+    remark          TEXT,
+    created_by      BIGINT,
+    created_time    TIMESTAMP DEFAULT NOW(),
+    updated_time    TIMESTAMP DEFAULT NOW(),
+    deleted         INT DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_task_date ON patrol_task(task_date);
+CREATE INDEX IF NOT EXISTS idx_task_worker ON patrol_task(worker_id);
+CREATE INDEX IF NOT EXISTS idx_task_route ON patrol_task(route_id);
+CREATE INDEX IF NOT EXISTS idx_task_status ON patrol_task(status);
+
+-- 巡检执行记录表
+CREATE TABLE IF NOT EXISTS patrol_execution (
+    id                  BIGSERIAL PRIMARY KEY,
+    task_id             BIGINT REFERENCES patrol_task(id),
+    inspector_id        BIGINT,
+    inspector_name      VARCHAR(50),
+    status              VARCHAR(20) DEFAULT 'pending',  -- pending/in_progress/completed/aborted
+    start_time          TIMESTAMP,
+    end_time            TIMESTAMP,
+    total_check_items   INT DEFAULT 0,
+    completed_check_items INT DEFAULT 0,
+    issue_count         INT DEFAULT 0,
+    total_distance      NUMERIC(10,3) DEFAULT 0,
+    start_lng           DOUBLE PRECISION,
+    start_lat           DOUBLE PRECISION,
+    end_lng             DOUBLE PRECISION,
+    end_lat             DOUBLE PRECISION,
+    remark              TEXT,
+    created_at          TIMESTAMP DEFAULT NOW(),
+    updated_at          TIMESTAMP DEFAULT NOW(),
+    deleted             INT DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_exec_task ON patrol_execution(task_id);
+CREATE INDEX IF NOT EXISTS idx_exec_inspector ON patrol_execution(inspector_id);
+CREATE INDEX IF NOT EXISTS idx_exec_status ON patrol_execution(status);
+
+-- 检查项记录表
+CREATE TABLE IF NOT EXISTS check_item_record (
+    id              BIGSERIAL PRIMARY KEY,
+    execution_id    BIGINT NOT NULL REFERENCES patrol_execution(id),
+    point_seq       INT,
+    point_name      VARCHAR(200),
+    item_name       VARCHAR(200),
+    check_status    VARCHAR(20),          -- normal/abnormal/skipped
+    record_value    DOUBLE PRECISION,
+    value_unit      VARCHAR(20),
+    description     TEXT,
+    photo_urls      TEXT,                 -- JSON数组
+    remark          TEXT,
+    record_time     TIMESTAMP,
+    lng             DOUBLE PRECISION,
+    lat             DOUBLE PRECISION,
+    created_at      TIMESTAMP DEFAULT NOW(),
+    updated_at      TIMESTAMP DEFAULT NOW(),
+    deleted         INT DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_check_record_exec ON check_item_record(execution_id);
+
+-- GPS轨迹点表
+CREATE TABLE IF NOT EXISTS gps_track_point (
+    id              BIGSERIAL PRIMARY KEY,
+    execution_id    BIGINT NOT NULL REFERENCES patrol_execution(id),
+    lng             DOUBLE PRECISION NOT NULL,
+    lat             DOUBLE PRECISION NOT NULL,
+    altitude        DOUBLE PRECISION,
+    speed           DOUBLE PRECISION,
+    bearing         DOUBLE PRECISION,
+    accuracy        DOUBLE PRECISION,
+    record_time     TIMESTAMP DEFAULT NOW(),
+    created_at      TIMESTAMP DEFAULT NOW(),
+    updated_at      TIMESTAMP DEFAULT NOW(),
+    deleted         INT DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_track_exec ON gps_track_point(execution_id);
+CREATE INDEX IF NOT EXISTS idx_track_time ON gps_track_point(record_time);
+
+-- 巡检问题上报表
+CREATE TABLE IF NOT EXISTS patrol_issue (
+    id              BIGSERIAL PRIMARY KEY,
+    execution_id    BIGINT NOT NULL REFERENCES patrol_execution(id),
+    check_record_id BIGINT,
+    issue_type      VARCHAR(30),          -- leak/damage/pollution/illegal/other
+    severity        VARCHAR(20),          -- low/medium/high/critical
+    description     TEXT,
+    photo_urls      TEXT,                 -- JSON数组
+    lng             DOUBLE PRECISION,
+    lat             DOUBLE PRECISION,
+    address         VARCHAR(500),
+    handle_status   VARCHAR(20) DEFAULT 'pending',  -- pending/processing/resolved/closed
+    work_order_id   BIGINT,
+    reporter_id     BIGINT,
+    reporter_name   VARCHAR(50),
+    report_time     TIMESTAMP DEFAULT NOW(),
+    created_at      TIMESTAMP DEFAULT NOW(),
+    updated_at      TIMESTAMP DEFAULT NOW(),
+    deleted         INT DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS idx_issue_exec ON patrol_issue(execution_id);
+CREATE INDEX IF NOT EXISTS idx_issue_status ON patrol_issue(handle_status);
+CREATE INDEX IF NOT EXISTS idx_issue_type ON patrol_issue(issue_type);

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

@@ -0,0 +1,211 @@
+package com.water.patrol.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.water.patrol.entity.CheckItemRecord;
+import com.water.patrol.entity.PatrolExecution;
+import com.water.patrol.entity.dto.CheckItemRecordRequest;
+import com.water.patrol.entity.dto.CompleteExecutionRequest;
+import com.water.patrol.entity.dto.StartExecutionRequest;
+import com.water.patrol.mapper.CheckItemRecordMapper;
+import com.water.patrol.mapper.PatrolExecutionMapper;
+import org.junit.jupiter.api.BeforeEach;
+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.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.Arrays;
+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 ExecutionServiceTest {
+
+    @Mock
+    private PatrolExecutionMapper executionMapper;
+
+    @Mock
+    private CheckItemRecordMapper checkItemRecordMapper;
+
+    @InjectMocks
+    private ExecutionService executionService;
+
+    private StartExecutionRequest startRequest;
+
+    @BeforeEach
+    void setUp() {
+        startRequest = new StartExecutionRequest();
+        startRequest.setTaskId(1L);
+        startRequest.setInspectorId(100L);
+        startRequest.setInspectorName("张三");
+        startRequest.setStartLng(86.6134);
+        startRequest.setStartLat(44.8256);
+        startRequest.setTotalCheckItems(10);
+    }
+
+    @Test
+    @DisplayName("开始巡检执行 - 正常创建")
+    void startExecution_success() {
+        when(executionMapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(null);
+        when(executionMapper.insert(any(PatrolExecution.class))).thenReturn(1);
+
+        PatrolExecution result = executionService.startExecution(startRequest);
+
+        assertNotNull(result);
+        assertEquals(1L, result.getTaskId());
+        assertEquals("张三", result.getInspectorName());
+        assertEquals("in_progress", result.getStatus());
+        assertEquals(10, result.getTotalCheckItems());
+        assertEquals(0, result.getCompletedCheckItems());
+        assertEquals(0, result.getIssueCount());
+        assertNotNull(result.getStartTime());
+
+        ArgumentCaptor<PatrolExecution> captor = ArgumentCaptor.forClass(PatrolExecution.class);
+        verify(executionMapper).insert(captor.capture());
+        assertEquals("in_progress", captor.getValue().getStatus());
+    }
+
+    @Test
+    @DisplayName("开始巡检执行 - 已有进行中的执行应抛异常")
+    void startExecution_duplicateExecution_throwsException() {
+        PatrolExecution existing = new PatrolExecution();
+        existing.setId(99L);
+        existing.setTaskId(1L);
+        existing.setStatus("in_progress");
+
+        when(executionMapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(existing);
+
+        RuntimeException ex = assertThrows(RuntimeException.class,
+                () -> executionService.startExecution(startRequest));
+        assertTrue(ex.getMessage().contains("已有进行中的巡检执行"));
+    }
+
+    @Test
+    @DisplayName("提交检查项记录 - 正常记录并更新计数")
+    void submitCheckItem_success() {
+        PatrolExecution execution = buildInProgressExecution();
+        when(executionMapper.selectById(1L)).thenReturn(execution);
+        when(checkItemRecordMapper.insert(any(CheckItemRecord.class))).thenReturn(1);
+        when(executionMapper.updateById(any(PatrolExecution.class))).thenReturn(1);
+
+        CheckItemRecordRequest req = new CheckItemRecordRequest();
+        req.setPointSeq(1);
+        req.setPointName("1号阀门");
+        req.setItemName("阀门状态");
+        req.setCheckStatus("normal");
+        req.setDescription("运行正常");
+        req.setLng(86.6135);
+        req.setLat(44.8257);
+        req.setPhotoUrls(Arrays.asList("http://img.example.com/1.jpg", "http://img.example.com/2.jpg"));
+
+        CheckItemRecord result = executionService.submitCheckItem(1L, req);
+
+        assertNotNull(result);
+        assertEquals("normal", result.getCheckStatus());
+        assertEquals(1, result.getPointSeq());
+        assertNotNull(result.getRecordTime());
+        assertEquals(1, execution.getCompletedCheckItems());
+
+        verify(checkItemRecordMapper).insert(any(CheckItemRecord.class));
+        verify(executionMapper).updateById(any(PatrolExecution.class));
+    }
+
+    @Test
+    @DisplayName("提交检查项记录 - 执行非进行中应抛异常")
+    void submitCheckItem_notInProgress_throwsException() {
+        PatrolExecution execution = buildInProgressExecution();
+        execution.setStatus("completed");
+        when(executionMapper.selectById(1L)).thenReturn(execution);
+
+        CheckItemRecordRequest req = new CheckItemRecordRequest();
+        req.setCheckStatus("normal");
+
+        RuntimeException ex = assertThrows(RuntimeException.class,
+                () -> executionService.submitCheckItem(1L, req));
+        assertTrue(ex.getMessage().contains("不在进行中状态"));
+    }
+
+    @Test
+    @DisplayName("完成巡检执行 - 正常完成")
+    void completeExecution_success() {
+        PatrolExecution execution = buildInProgressExecution();
+        when(executionMapper.selectById(1L)).thenReturn(execution);
+        when(executionMapper.updateById(any(PatrolExecution.class))).thenReturn(1);
+
+        CompleteExecutionRequest req = new CompleteExecutionRequest();
+        req.setEndLng(86.6200);
+        req.setEndLat(44.8300);
+        req.setTotalDistance(3.5);
+        req.setRemark("巡检顺利完成");
+
+        PatrolExecution result = executionService.completeExecution(1L, req);
+
+        assertEquals("completed", result.getStatus());
+        assertNotNull(result.getEndTime());
+        assertEquals(86.6200, result.getEndLng());
+        assertEquals(44.8300, result.getEndLat());
+        assertEquals(BigDecimal.valueOf(3.5), result.getTotalDistance());
+    }
+
+    @Test
+    @DisplayName("中止巡检执行 - 正常中止")
+    void abortExecution_success() {
+        PatrolExecution execution = buildInProgressExecution();
+        when(executionMapper.selectById(1L)).thenReturn(execution);
+        when(executionMapper.updateById(any(PatrolExecution.class))).thenReturn(1);
+
+        PatrolExecution result = executionService.abortExecution(1L, "天气原因中止");
+
+        assertEquals("aborted", result.getStatus());
+        assertNotNull(result.getEndTime());
+        assertEquals("天气原因中止", result.getRemark());
+    }
+
+    @Test
+    @DisplayName("批量提交检查项 - 正确更新计数")
+    void batchSubmitCheckItems_success() {
+        PatrolExecution execution = buildInProgressExecution();
+        when(executionMapper.selectById(1L)).thenReturn(execution);
+        when(checkItemRecordMapper.insert(any(CheckItemRecord.class))).thenReturn(1);
+        when(executionMapper.updateById(any(PatrolExecution.class))).thenReturn(1);
+
+        CheckItemRecordRequest item1 = new CheckItemRecordRequest();
+        item1.setPointSeq(1);
+        item1.setItemName("阀门1");
+        item1.setCheckStatus("normal");
+
+        CheckItemRecordRequest item2 = new CheckItemRecordRequest();
+        item2.setPointSeq(2);
+        item2.setItemName("阀门2");
+        item2.setCheckStatus("abnormal");
+
+        int count = executionService.batchSubmitCheckItems(1L, List.of(item1, item2));
+
+        assertEquals(2, count);
+        assertEquals(2, execution.getCompletedCheckItems());
+        verify(checkItemRecordMapper, times(2)).insert(any(CheckItemRecord.class));
+    }
+
+    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;
+    }
+}

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

@@ -0,0 +1,138 @@
+package com.water.patrol.service;
+
+import com.water.patrol.entity.PatrolExecution;
+import com.water.patrol.entity.PatrolIssue;
+import com.water.patrol.entity.dto.PatrolIssueRequest;
+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.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class IssueServiceTest {
+
+    @Mock
+    private PatrolIssueMapper issueMapper;
+
+    @Mock
+    private ExecutionService executionService;
+
+    @InjectMocks
+    private IssueService issueService;
+
+    @Test
+    @DisplayName("上报问题 - 正常上报并关联执行")
+    void reportIssue_success() {
+        PatrolExecution execution = buildInProgressExecution();
+        when(executionService.getExecution(1L)).thenReturn(execution);
+        when(issueMapper.insert(any(PatrolIssue.class))).thenReturn(1);
+
+        PatrolIssueRequest request = new PatrolIssueRequest();
+        request.setIssueType("leak");
+        request.setSeverity("high");
+        request.setDescription("发现管道漏水，水流较大");
+        request.setLng(86.6135);
+        request.setLat(44.8257);
+        request.setAddress("XX路与YY路交叉口");
+        request.setPhotoUrls(Arrays.asList("http://img.example.com/leak1.jpg", "http://img.example.com/leak2.jpg"));
+
+        PatrolIssue result = issueService.reportIssue(1L, request);
+
+        assertNotNull(result);
+        assertEquals("leak", result.getIssueType());
+        assertEquals("high", result.getSeverity());
+        assertEquals("pending", result.getHandleStatus());
+        assertEquals(100L, result.getReporterId());
+        assertEquals("张三", result.getReporterName());
+        assertNotNull(result.getReportTime());
+
+        // Verify issue count was incremented
+        verify(executionService).incrementIssueCount(1L);
+    }
+
+    @Test
+    @DisplayName("上报问题 - 执行非进行中应抛异常")
+    void reportIssue_notInProgress_throwsException() {
+        PatrolExecution execution = buildInProgressExecution();
+        execution.setStatus("completed");
+        when(executionService.getExecution(1L)).thenReturn(execution);
+
+        PatrolIssueRequest request = new PatrolIssueRequest();
+        request.setIssueType("leak");
+        request.setSeverity("high");
+        request.setDescription("test");
+
+        RuntimeException ex = assertThrows(RuntimeException.class,
+                () -> issueService.reportIssue(1L, request));
+        assertTrue(ex.getMessage().contains("不在进行中状态"));
+    }
+
+    @Test
+    @DisplayName("关联工单 - 状态更新为处理中")
+    void linkWorkOrder_success() {
+        PatrolIssue issue = new PatrolIssue();
+        issue.setId(1L);
+        issue.setExecutionId(1L);
+        issue.setHandleStatus("pending");
+
+        when(issueMapper.selectById(1L)).thenReturn(issue);
+        when(issueMapper.updateById(any(PatrolIssue.class))).thenReturn(1);
+
+        PatrolIssue result = issueService.linkWorkOrder(1L, 500L);
+
+        assertEquals(500L, result.getWorkOrderId());
+        assertEquals("processing", result.getHandleStatus());
+    }
+
+    @Test
+    @DisplayName("更新问题处理状态")
+    void updateIssueStatus_success() {
+        PatrolIssue issue = new PatrolIssue();
+        issue.setId(1L);
+        issue.setHandleStatus("processing");
+
+        when(issueMapper.selectById(1L)).thenReturn(issue);
+        when(issueMapper.updateById(any(PatrolIssue.class))).thenReturn(1);
+
+        PatrolIssue result = issueService.updateIssueStatus(1L, "resolved");
+
+        assertEquals("resolved", result.getHandleStatus());
+    }
+
+    @Test
+    @DisplayName("获取问题详情 - 不存在应抛异常")
+    void getIssue_notFound_throwsException() {
+        when(issueMapper.selectById(999L)).thenReturn(null);
+
+        RuntimeException ex = assertThrows(RuntimeException.class,
+                () -> issueService.getIssue(999L));
+        assertTrue(ex.getMessage().contains("问题不存在"));
+    }
+
+    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;
+    }
+}

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

@@ -0,0 +1,201 @@
+package com.water.patrol.service;
+
+import com.water.patrol.entity.PatrolCheckpoint;
+import com.water.patrol.entity.PatrolTask;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * 巡检模块核心逻辑单元测试
+ * 测试路线优化(haversine距离计算)、周期任务日期生成、任务状态流转等纯逻辑
+ */
+class PatrolServiceTest {
+
+    private RouteService routeService;
+    private TaskService taskService;
+
+    @BeforeEach
+    void setUp() {
+        // RouteService需要mapper但haversine是纯方法，传null即可
+        routeService = new RouteService(null, null);
+        taskService = new TaskService(null, null, null, null);
+    }
+
+    // ==================== Haversine 距离计算测试 ====================
+
+    @Test
+    @DisplayName("测试Haversine距离 - 相同坐标应为0")
+    void testHaversine_samePoint() {
+        double dist = routeService.haversine(44.85, 82.07, 44.85, 82.07);
+        assertEquals(0.0, dist, 0.001);
+    }
+
+    @Test
+    @DisplayName("测试Haversine距离 - 已知距离的两个城市(北京-上海约1068km)")
+    void testHaversine_beijingToShanghai() {
+        // 北京(39.9, 116.4) -> 上海(31.2, 121.5)
+        double dist = routeService.haversine(39.9, 116.4, 31.2, 121.5);
+        assertTrue(dist > 1000 && dist < 1150,
+                "北京到上海应在1000-1150km范围，实际: " + dist);
+    }
+
+    @Test
+    @DisplayName("测试Haversine距离 - 短距离(巡检场景，几百米)")
+    void testHaversine_shortDistance() {
+        // 两个相距约500m的坐标点
+        double dist = routeService.haversine(44.850, 82.070, 44.854, 82.073);
+        assertTrue(dist > 0.3 && dist < 0.6,
+                "短距离应在300m-600m范围，实际: " + dist + "km");
+    }
+
+    @Test
+    @DisplayName("测试Haversine对称性 - A到B等于B到A")
+    void testHaversine_symmetric() {
+        double d1 = routeService.haversine(44.85, 82.07, 44.86, 82.08);
+        double d2 = routeService.haversine(44.86, 82.08, 44.85, 82.07);
+        assertEquals(d1, d2, 0.0001);
+    }
+
+    // ==================== 周期任务日期生成测试 ====================
+
+    @Test
+    @DisplayName("测试日周期 - 生成7天日期")
+    void testGenerateCycleDates_daily() {
+        LocalDate start = LocalDate.of(2026, 6, 1);
+        List<LocalDate> dates = taskService.generateCycleDates("daily", start, 7);
+        assertEquals(7, dates.size());
+        assertEquals(start, dates.get(0));
+        assertEquals(start.plusDays(6), dates.get(6));
+        // 验证连续日期
+        for (int i = 1; i < dates.size(); i++) {
+            assertEquals(dates.get(i - 1).plusDays(1), dates.get(i));
+        }
+    }
+
+    @Test
+    @DisplayName("测试周周期 - 生成4周日期")
+    void testGenerateCycleDates_weekly() {
+        LocalDate start = LocalDate.of(2026, 6, 1);
+        List<LocalDate> dates = taskService.generateCycleDates("weekly", start, 4);
+        assertEquals(4, dates.size());
+        assertEquals(start, dates.get(0));
+        assertEquals(start.plusWeeks(3), dates.get(3));
+        // 验证每周间隔7天
+        for (int i = 1; i < dates.size(); i++) {
+            assertEquals(7, dates.get(i).toEpochDay() - dates.get(i - 1).toEpochDay());
+        }
+    }
+
+    @Test
+    @DisplayName("测试月周期 - 生成3个月日期")
+    void testGenerateCycleDates_monthly() {
+        LocalDate start = LocalDate.of(2026, 1, 15);
+        List<LocalDate> dates = taskService.generateCycleDates("monthly", start, 3);
+        assertEquals(3, dates.size());
+        assertEquals(start, dates.get(0));
+        assertEquals(LocalDate.of(2026, 2, 15), dates.get(1));
+        assertEquals(LocalDate.of(2026, 3, 15), dates.get(2));
+    }
+
+    @Test
+    @DisplayName("测试月周期 - 跨年末")
+    void testGenerateCycleDates_monthlyCrossYear() {
+        LocalDate start = LocalDate.of(2026, 11, 1);
+        List<LocalDate> dates = taskService.generateCycleDates("monthly", start, 4);
+        assertEquals(4, dates.size());
+        assertEquals(LocalDate.of(2026, 11, 1), dates.get(0));
+        assertEquals(LocalDate.of(2026, 12, 1), dates.get(1));
+        assertEquals(LocalDate.of(2027, 1, 1), dates.get(2));
+        assertEquals(LocalDate.of(2027, 2, 1), dates.get(3));
+    }
+
+    @Test
+    @DisplayName("测试单周期 - 只生成1个日期")
+    void testGenerateCycleDates_single() {
+        LocalDate start = LocalDate.of(2026, 6, 14);
+        List<LocalDate> dates = taskService.generateCycleDates("daily", start, 1);
+        assertEquals(1, dates.size());
+        assertEquals(start, dates.get(0));
+    }
+
+    // ==================== 巡检任务实体逻辑测试 ====================
+
+    @Test
+    @DisplayName("测试PatrolTask实体 - 默认值设置")
+    void testPatrolTask_defaults() {
+        PatrolTask task = new PatrolTask();
+        task.setTaskName("测试任务");
+        task.setTaskDate(LocalDate.of(2026, 6, 14));
+        task.setRouteId(1L);
+        task.setStatus("pending");
+
+        assertNotNull(task.getTaskName());
+        assertEquals("pending", task.getStatus());
+        assertEquals(LocalDate.of(2026, 6, 14), task.getTaskDate());
+    }
+
+    @Test
+    @DisplayName("测试PatrolTask状态流转 - pending -> assigned -> in_progress -> completed")
+    void testPatrolTask_statusFlow() {
+        PatrolTask task = new PatrolTask();
+        task.setStatus("pending");
+        assertEquals("pending", task.getStatus());
+
+        task.setStatus("assigned");
+        assertEquals("assigned", task.getStatus());
+
+        task.setStatus("in_progress");
+        assertEquals("in_progress", task.getStatus());
+
+        task.setStatus("completed");
+        assertEquals("completed", task.getStatus());
+    }
+
+    // ==================== 检查点实体测试 ====================
+
+    @Test
+    @DisplayName("测试PatrolCheckpoint - 检查点顺序排列")
+    void testCheckpoint_ordering() {
+        List<PatrolCheckpoint> checkpoints = List.of(
+                createCheckpoint(3, "C"),
+                createCheckpoint(1, "A"),
+                createCheckpoint(2, "B")
+        );
+
+        List<PatrolCheckpoint> sorted = checkpoints.stream()
+                .sorted((a, b) -> Integer.compare(a.getSeq(), b.getSeq()))
+                .toList();
+
+        assertEquals("A", sorted.get(0).getName());
+        assertEquals("B", sorted.get(1).getName());
+        assertEquals("C", sorted.get(2).getName());
+    }
+
+    @Test
+    @DisplayName("测试检查点坐标有效性")
+    void testCheckpoint_coordinates() {
+        PatrolCheckpoint cp = new PatrolCheckpoint();
+        cp.setLng(82.07);
+        cp.setLat(44.85);
+        cp.setName("检查点A");
+        cp.setCheckType("visual");
+
+        assertNotNull(cp.getLng());
+        assertNotNull(cp.getLat());
+        assertTrue(cp.getLng() > 0 && cp.getLng() < 180);
+        assertTrue(cp.getLat() > 0 && cp.getLat() < 90);
+    }
+
+    private PatrolCheckpoint createCheckpoint(int seq, String name) {
+        PatrolCheckpoint cp = new PatrolCheckpoint();
+        cp.setSeq(seq);
+        cp.setName(name);
+        return cp;
+    }
+}

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

@@ -0,0 +1,152 @@
+package com.water.patrol.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.water.patrol.entity.GpsTrackPoint;
+import com.water.patrol.entity.dto.GpsTrackBatchRequest;
+import com.water.patrol.mapper.GpsTrackPointMapper;
+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.ArrayList;
+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.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class TrackServiceTest {
+
+    @Mock
+    private GpsTrackPointMapper trackPointMapper;
+
+    @InjectMocks
+    private TrackService trackService;
+
+    @Test
+    @DisplayName("记录单个GPS轨迹点")
+    void recordTrackPoint_success() {
+        when(trackPointMapper.insert(any(GpsTrackPoint.class))).thenReturn(1);
+
+        GpsTrackPoint result = trackService.recordTrackPoint(
+                1L, 86.6134, 44.8256, 500.0, 1.5, 180.0, 10.0);
+
+        assertNotNull(result);
+        assertEquals(1L, result.getExecutionId());
+        assertEquals(86.6134, result.getLng());
+        assertEquals(44.8256, result.getLat());
+        assertEquals(1.5, result.getSpeed());
+        assertNotNull(result.getRecordTime());
+
+        verify(trackPointMapper).insert(any(GpsTrackPoint.class));
+    }
+
+    @Test
+    @DisplayName("批量记录GPS轨迹点")
+    void batchRecordTrackPoints_success() {
+        when(trackPointMapper.insert(any(GpsTrackPoint.class))).thenReturn(1);
+
+        GpsTrackBatchRequest request = new GpsTrackBatchRequest();
+        List<GpsTrackBatchRequest.GpsTrackPointDto> points = new ArrayList<>();
+
+        GpsTrackBatchRequest.GpsTrackPointDto p1 = new GpsTrackBatchRequest.GpsTrackPointDto();
+        p1.setLng(86.6134);
+        p1.setLat(44.8256);
+        p1.setSpeed(1.2);
+        p1.setRecordTime("2025-06-14T10:00:00");
+        points.add(p1);
+
+        GpsTrackBatchRequest.GpsTrackPointDto p2 = new GpsTrackBatchRequest.GpsTrackPointDto();
+        p2.setLng(86.6135);
+        p2.setLat(44.8257);
+        p2.setSpeed(1.3);
+        p2.setRecordTime("2025-06-14T10:00:10");
+        points.add(p2);
+
+        request.setPoints(points);
+
+        int count = trackService.batchRecordTrackPoints(1L, request);
+
+        assertEquals(2, count);
+        verify(trackPointMapper, times(2)).insert(any(GpsTrackPoint.class));
+    }
+
+    @Test
+    @DisplayName("批量记录空列表返回0")
+    void batchRecordTrackPoints_emptyList() {
+        GpsTrackBatchRequest request = new GpsTrackBatchRequest();
+        request.setPoints(List.of());
+
+        int count = trackService.batchRecordTrackPoints(1L, request);
+
+        assertEquals(0, count);
+        verify(trackPointMapper, never()).insert(any());
+    }
+
+    @Test
+    @DisplayName("获取轨迹摘要 - 空轨迹")
+    void getTrackSummary_emptyTrack() {
+        when(trackPointMapper.selectTrackByExecutionId(1L)).thenReturn(List.of());
+
+        Map<String, Object> summary = trackService.getTrackSummary(1L);
+
+        assertEquals(1L, summary.get("executionId"));
+        assertEquals(0, summary.get("totalPoints"));
+        assertEquals(0.0, summary.get("distance"));
+        assertEquals(0, summary.get("duration"));
+    }
+
+    @Test
+    @DisplayName("获取轨迹摘要 - 包含距离计算")
+    void getTrackSummary_withDistance() {
+        List<GpsTrackPoint> points = new ArrayList<>();
+
+        GpsTrackPoint p1 = new GpsTrackPoint();
+        p1.setLng(86.6134);
+        p1.setLat(44.8256);
+        p1.setSpeed(1.2);
+        p1.setRecordTime(LocalDateTime.of(2025, 6, 14, 10, 0, 0));
+        points.add(p1);
+
+        GpsTrackPoint p2 = new GpsTrackPoint();
+        p2.setLng(86.6144);
+        p2.setLat(44.8266);
+        p2.setSpeed(1.5);
+        p2.setRecordTime(LocalDateTime.of(2025, 6, 14, 10, 30, 0));
+        points.add(p2);
+
+        when(trackPointMapper.selectTrackByExecutionId(1L)).thenReturn(points);
+
+        Map<String, Object> summary = trackService.getTrackSummary(1L);
+
+        assertEquals(2, summary.get("totalPoints"));
+        assertTrue((double) summary.get("distance") > 0);
+        assertEquals(30L, summary.get("duration"));
+        assertTrue((double) summary.get("avgSpeed") > 0);
+    }
+
+    @Test
+    @DisplayName("获取最新位置")
+    void getLatestPosition_success() {
+        GpsTrackPoint latest = new GpsTrackPoint();
+        latest.setExecutionId(1L);
+        latest.setLng(86.6200);
+        latest.setLat(44.8300);
+        latest.setRecordTime(LocalDateTime.now());
+
+        when(trackPointMapper.selectOne(any(LambdaQueryWrapper.class))).thenReturn(latest);
+
+        GpsTrackPoint result = trackService.getLatestPosition(1L);
+
+        assertNotNull(result);
+        assertEquals(86.6200, result.getLng());
+        assertEquals(44.8300, result.getLat());
+    }
+}