feat(wm-patrol): #78 巡检统计分析（执行率/里程/问题分类/排名）

基于 master 真实表结构(pat_task/pat_work_order/pat_issue_report/pat_route_setup)重新实现，替代操作废弃旧表的旧实现。

- StatsController: GET /api/patrol/stats/{summary,completion-rate,mileage,issues,rank}

- PatrolStatsService: 执行率(按巡检员/路线/时间段) + 里程(概览/巡检员/趋势) + 问题分类(类型/严重度/解决率) + 综合看板

- PatrolRankService: 巡检员/路线排名

- V89__patrol_stats.sql: patrol_stats_daily 每日汇总表 + 聚合SQL

- 单元测试: PatrolStatsServiceTest / PatrolRankServiceTest (JUnit5 + Mock JdbcTemplate)

API路径符合设计文档7.3。分支重建为干净单提交，覆盖此前被#74/#76污染的版本。

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

@@ -0,0 +1,119 @@
+package com.water.patrol.controller;
+
+import com.water.common.core.result.R;
+import com.water.patrol.entity.dto.RankResult;
+import com.water.patrol.entity.dto.StatsQueryRequest;
+import com.water.patrol.entity.dto.StatsSummary;
+import com.water.patrol.service.PatrolRankService;
+import com.water.patrol.service.PatrolStatsService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 巡检统计分析 REST API（对应设计文档 7.3）
+ */
+@Tag(name = "巡检统计分析")
+@RestController
+@RequestMapping("/api/patrol/stats")
+@RequiredArgsConstructor
+public class StatsController {
+
+    private final PatrolStatsService statsService;
+    private final PatrolRankService rankService;
+
+    // ==================== 综合看板 ====================
+
+    @Operation(summary = "综合看板概览")
+    @GetMapping("/summary")
+    public R<StatsSummary> summary(
+            @Parameter(description = "起始日期") @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
+            @Parameter(description = "结束日期") @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate) {
+        return R.ok(statsService.dashboardSummary(req(startDate, endDate)));
+    }
+
+    // ==================== 执行率统计 ====================
+
+    @Operation(summary = "执行率统计（dim: inspector=按巡检员, route=按路线, period=按时间段）")
+    @GetMapping("/completion-rate")
+    public R<List<Map<String, Object>>> completionRate(
+            @RequestParam(defaultValue = "inspector") String dim,
+            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
+            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate) {
+        StatsQueryRequest r = req(startDate, endDate);
+        List<Map<String, Object>> result;
+        switch (dim) {
+            case "route" -> result = statsService.completionRateByRoute(r);
+            case "period" -> result = statsService.completionRateByPeriod(r);
+            default -> result = statsService.completionRateByInspector(r);
+        }
+        return R.ok(result);
+    }
+
+    // ==================== 里程统计 ====================
+
+    @Operation(summary = "里程统计（dim: summary=概览, inspector=按巡检员, trend=按天趋势）")
+    @GetMapping("/mileage")
+    public R<?> mileage(
+            @RequestParam(defaultValue = "summary") String dim,
+            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
+            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate) {
+        StatsQueryRequest r = req(startDate, endDate);
+        Object result;
+        switch (dim) {
+            case "inspector" -> result = statsService.mileageByInspector(r);
+            case "trend" -> result = statsService.mileageTrend(r);
+            default -> result = statsService.mileageSummary(r);
+        }
+        return R.ok(result);
+    }
+
+    // ==================== 问题分类统计 ====================
+
+    @Operation(summary = "问题分类统计（dim: type=类型分布, severity=严重度分布, resolution=解决率）")
+    @GetMapping("/issues")
+    public R<?> issues(
+            @RequestParam(defaultValue = "type") String dim,
+            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
+            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate) {
+        StatsQueryRequest r = req(startDate, endDate);
+        Object result;
+        switch (dim) {
+            case "severity" -> result = statsService.issueSeverityDistribution(r);
+            case "resolution" -> result = statsService.issueResolutionStats(r);
+            default -> result = statsService.issueTypeDistribution(r);
+        }
+        return R.ok(result);
+    }
+
+    // ==================== 排名 ====================
+
+    @Operation(summary = "排名（type: inspector=巡检员, route=路线）")
+    @GetMapping("/rank")
+    public R<List<RankResult>> rank(
+            @RequestParam(defaultValue = "inspector") String type,
+            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
+            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate,
+            @RequestParam(required = false, defaultValue = "10") Integer topN) {
+        StatsQueryRequest r = req(startDate, endDate);
+        r.setTopN(topN);
+        return R.ok("route".equals(type) ? rankService.routeRank(r) : rankService.inspectorRank(r));
+    }
+
+    private StatsQueryRequest req(LocalDate startDate, LocalDate endDate) {
+        StatsQueryRequest r = new StatsQueryRequest();
+        r.setStartDate(startDate);
+        r.setEndDate(endDate);
+        return r;
+    }
+}

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

@@ -0,0 +1,30 @@
+package com.water.patrol.entity.dto;
+
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/**
+ * 巡检排名结果项
+ */
+@Data
+public class RankResult {
+
+    /** 名次 */
+    private int rank;
+
+    /** 对象主键（巡检员ID/路线ID） */
+    private Long id;
+
+    /** 对象名称（巡检员姓名/路线名称） */
+    private String name;
+
+    /** 排序指标值（里程=公里，完成率=百分比） */
+    private BigDecimal score;
+
+    /** 任务总数 */
+    private int totalTasks;
+
+    /** 已完成任务数 */
+    private int completedTasks;
+}

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

@@ -0,0 +1,28 @@
+package com.water.patrol.entity.dto;
+
+import lombok.Data;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.time.LocalDate;
+
+/**
+ * 巡检统计查询参数
+ */
+@Data
+public class StatsQueryRequest {
+
+    @DateTimeFormat(iso = DateTimeFormat.ISO.DATE)
+    private LocalDate startDate;
+
+    @DateTimeFormat(iso = DateTimeFormat.ISO.DATE)
+    private LocalDate endDate;
+
+    /** 排名返回数量，默认 10 */
+    private Integer topN = 10;
+
+    /** 指定巡检员过滤（可空） */
+    private Long assigneeId;
+
+    /** 指定路线过滤（可空） */
+    private Long routeId;
+}

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

@@ -0,0 +1,45 @@
+package com.water.patrol.entity.dto;
+
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/**
+ * 巡检综合看板概览
+ */
+@Data
+public class StatsSummary {
+
+    /** 统计区间天数 */
+    private long days;
+
+    /** 任务总数 */
+    private int totalTasks;
+
+    /** 已完成任务数 */
+    private int completedTasks;
+
+    /** 任务执行率（完成率），百分比 */
+    private BigDecimal executionRate;
+
+    /** 里程合计（公里） */
+    private BigDecimal totalDistance;
+
+    /** 日均里程 */
+    private BigDecimal avgDailyDistance;
+
+    /** 问题总数 */
+    private int totalIssues;
+
+    /** 已解决问题数 */
+    private int resolvedIssues;
+
+    /** 问题解决率，百分比 */
+    private BigDecimal resolutionRate;
+
+    /** 参与巡检员数 */
+    private int inspectorCount;
+
+    /** 活跃路线数 */
+    private int activeRoutes;
+}

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

@@ -0,0 +1,102 @@
+package com.water.patrol.service;
+
+import com.water.patrol.entity.dto.RankResult;
+import com.water.patrol.entity.dto.StatsQueryRequest;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 巡检排名服务（对应设计文档 7.3 GET /api/patrol/rank）
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class PatrolRankService {
+
+    private final JdbcTemplate jdbc;
+
+    private static final int DEFAULT_DAYS = 30;
+
+    /**
+     * 巡检员排名（默认按里程，对应 GET /api/patrol/rank?type=inspector）
+     */
+    public List<RankResult> inspectorRank(StatsQueryRequest req) {
+        LocalDate[] range = resolve(req);
+        int limit = topN(req);
+        log.info("巡检员排名: {} ~ {}, topN={}", range[0], range[1], limit);
+        List<RankResult> raw = jdbc.query(
+                "SELECT worker_id AS id, worker_name AS name, " +
+                        "COALESCE(SUM(distance), 0) AS score, " +
+                        "COUNT(*) AS total_tasks, " +
+                        "COUNT(*) FILTER (WHERE status = 'completed') AS completed_tasks " +
+                        "FROM pat_task WHERE worker_id IS NOT NULL " +
+                        "AND created_at >= ?::date AND created_at < (?::date + interval '1 day') " +
+                        "GROUP BY worker_id, worker_name ORDER BY score DESC NULLS LAST LIMIT ?",
+                (rs, i) -> mapRow(rs), range[0], range[1], limit);
+        return assignRanks(raw);
+    }
+
+    /**
+     * 路线排名（对应 GET /api/patrol/rank?type=route）
+     */
+    public List<RankResult> routeRank(StatsQueryRequest req) {
+        LocalDate[] range = resolve(req);
+        int limit = topN(req);
+        log.info("路线排名: {} ~ {}, topN={}", range[0], range[1], limit);
+        List<RankResult> raw = jdbc.query(
+                "SELECT t.route_id AS id, COALESCE(r.route_name, ('路线#' || t.route_id)) AS name, " +
+                        "COALESCE(SUM(t.distance), 0) AS score, " +
+                        "COUNT(*) AS total_tasks, " +
+                        "COUNT(*) FILTER (WHERE t.status = 'completed') AS completed_tasks " +
+                        "FROM pat_task t LEFT JOIN pat_route_setup r ON t.route_id = r.id " +
+                        "WHERE t.route_id IS NOT NULL " +
+                        "AND t.created_at >= ?::date AND t.created_at < (?::date + interval '1 day') " +
+                        "GROUP BY t.route_id, r.route_name ORDER BY score DESC NULLS LAST LIMIT ?",
+                (rs, i) -> mapRow(rs), range[0], range[1], limit);
+        return assignRanks(raw);
+    }
+
+    // ==================== 内部工具 ====================
+
+    private RankResult mapRow(ResultSet rs) throws SQLException {
+        RankResult r = new RankResult();
+        long id = rs.getLong("id");
+        r.setId(rs.wasNull() ? null : id);
+        r.setName(rs.getString("name"));
+        r.setScore(BigDecimal.valueOf(rs.getDouble("score")));
+        r.setTotalTasks(rs.getInt("total_tasks"));
+        r.setCompletedTasks(rs.getInt("completed_tasks"));
+        return r;
+    }
+
+    private List<RankResult> assignRanks(List<RankResult> raw) {
+        List<RankResult> result = new ArrayList<>(raw.size());
+        for (int i = 0; i < raw.size(); i++) {
+            RankResult r = raw.get(i);
+            r.setRank(i + 1);
+            result.add(r);
+        }
+        return result;
+    }
+
+    private int topN(StatsQueryRequest req) {
+        Integer n = req == null ? null : req.getTopN();
+        return (n == null || n <= 0) ? 10 : n;
+    }
+
+    private LocalDate[] resolve(StatsQueryRequest req) {
+        LocalDate end = (req == null || req.getEndDate() == null) ? LocalDate.now() : req.getEndDate();
+        LocalDate start = (req == null || req.getStartDate() == null)
+                ? end.minusDays(DEFAULT_DAYS - 1L) : req.getStartDate();
+        return new LocalDate[]{start, end};
+    }
+}

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

@@ -0,0 +1,265 @@
+package com.water.patrol.service;
+
+import com.water.patrol.entity.dto.StatsQueryRequest;
+import com.water.patrol.entity.dto.StatsSummary;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.LocalDate;
+import java.time.temporal.ChronoUnit;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 巡检统计分析服务
+ * <p>
+ * 基于 master 真实表结构（pat_task / pat_work_order / pat_issue_report / pat_route_setup）。
+ * 对应设计文档 7.3 统计分析章节。
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class PatrolStatsService {
+
+    private final JdbcTemplate jdbc;
+
+    /** 默认统计区间天数 */
+    private static final int DEFAULT_DAYS = 30;
+
+    // ==================== 区间解析 ====================
+
+    /**
+     * 解析请求日期区间，缺省取最近 30 天。返回 [start, end, days]。
+     */
+    private LocalDate[] resolveRange(StatsQueryRequest req) {
+        LocalDate end = (req == null || req.getEndDate() == null) ? LocalDate.now() : req.getEndDate();
+        LocalDate start = (req == null || req.getStartDate() == null)
+                ? end.minusDays(DEFAULT_DAYS - 1L) : req.getStartDate();
+        return new LocalDate[]{start, end};
+    }
+
+    // ==================== 综合看板 ====================
+
+    /**
+     * 综合看板概览（对应 GET /api/patrol/stats/summary）
+     */
+    public StatsSummary dashboardSummary(StatsQueryRequest req) {
+        LocalDate[] range = resolveRange(req);
+        LocalDate start = range[0], end = range[1];
+        long days = Math.max(ChronoUnit.DAYS.between(start, end) + 1, 1);
+        log.info("巡检综合看板: {} ~ {} ({}天)", start, end, days);
+
+        StatsSummary s = new StatsSummary();
+        s.setDays(days);
+
+        Integer totalTasks = jdbc.queryForObject(
+                "SELECT COUNT(*) FROM pat_task WHERE created_at >= ?::date AND created_at < (?::date + interval '1 day')",
+                Integer.class, start, end);
+        Integer completedTasks = jdbc.queryForObject(
+                "SELECT COUNT(*) FROM pat_task WHERE status = 'completed' AND created_at >= ?::date AND created_at < (?::date + interval '1 day')",
+                Integer.class, start, end);
+        int total = totalTasks == null ? 0 : totalTasks;
+        int completed = completedTasks == null ? 0 : completedTasks;
+        s.setTotalTasks(total);
+        s.setCompletedTasks(completed);
+        s.setExecutionRate(rate(completed, total));
+
+        Double totalDistance = jdbc.queryForObject(
+                "SELECT COALESCE(SUM(distance), 0) FROM pat_task WHERE created_at >= ?::date AND created_at < (?::date + interval '1 day')",
+                Double.class, start, end);
+        BigDecimal dist = totalDistance == null ? BigDecimal.ZERO : BigDecimal.valueOf(totalDistance);
+        s.setTotalDistance(dist);
+        s.setAvgDailyDistance(dist.divide(BigDecimal.valueOf(days), 2, RoundingMode.HALF_UP));
+
+        Integer totalIssues = jdbc.queryForObject(
+                "SELECT COUNT(*) FROM pat_issue_report WHERE created_at >= ?::date AND created_at < (?::date + interval '1 day')",
+                Integer.class, start, end);
+        Integer resolvedIssues = jdbc.queryForObject(
+                "SELECT COUNT(*) FROM pat_issue_report WHERE status IN ('resolved','closed') AND created_at >= ?::date AND created_at < (?::date + interval '1 day')",
+                Integer.class, start, end);
+        int issues = totalIssues == null ? 0 : totalIssues;
+        int resolved = resolvedIssues == null ? 0 : resolvedIssues;
+        s.setTotalIssues(issues);
+        s.setResolvedIssues(resolved);
+        s.setResolutionRate(rate(resolved, issues));
+
+        Integer inspectorCount = jdbc.queryForObject(
+                "SELECT COUNT(DISTINCT worker_id) FROM pat_task WHERE worker_id IS NOT NULL AND created_at >= ?::date AND created_at < (?::date + interval '1 day')",
+                Integer.class, start, end);
+        Integer activeRoutes = jdbc.queryForObject(
+                "SELECT COUNT(DISTINCT route_id) FROM pat_task WHERE route_id IS NOT NULL AND created_at >= ?::date AND created_at < (?::date + interval '1 day')",
+                Integer.class, start, end);
+        s.setInspectorCount(inspectorCount == null ? 0 : inspectorCount);
+        s.setActiveRoutes(activeRoutes == null ? 0 : activeRoutes);
+        return s;
+    }
+
+    // ==================== 执行率统计 ====================
+
+    /**
+     * 按巡检员统计执行率（对应 GET /api/patrol/stats/completion-rate?dim=inspector）
+     */
+    public List<Map<String, Object>> completionRateByInspector(StatsQueryRequest req) {
+        LocalDate[] range = resolveRange(req);
+        log.info("执行率(按巡检员): {} ~ {}", range[0], range[1]);
+        return jdbc.queryForList(
+                "SELECT worker_id AS inspectorId, worker_name AS inspectorName, " +
+                        "COUNT(*) AS total, " +
+                        "COUNT(*) FILTER (WHERE status = 'completed') AS completed, " +
+                        "ROUND(COUNT(*) FILTER (WHERE status = 'completed') * 100.0 / NULLIF(COUNT(*), 0), 2) AS completionRate " +
+                        "FROM pat_task WHERE worker_id IS NOT NULL " +
+                        "AND created_at >= ?::date AND created_at < (?::date + interval '1 day') " +
+                        "GROUP BY worker_id, worker_name ORDER BY completionRate DESC NULLS LAST",
+                range[0], range[1]);
+    }
+
+    /**
+     * 按路线统计执行率（对应 GET /api/patrol/stats/completion-rate?dim=route）
+     */
+    public List<Map<String, Object>> completionRateByRoute(StatsQueryRequest req) {
+        LocalDate[] range = resolveRange(req);
+        log.info("执行率(按路线): {} ~ {}", range[0], range[1]);
+        return jdbc.queryForList(
+                "SELECT t.route_id AS routeId, COALESCE(r.route_name, ('路线#' || t.route_id)) AS routeName, " +
+                        "COUNT(*) AS total, " +
+                        "COUNT(*) FILTER (WHERE t.status = 'completed') AS completed, " +
+                        "ROUND(COUNT(*) FILTER (WHERE t.status = 'completed') * 100.0 / NULLIF(COUNT(*), 0), 2) AS completionRate " +
+                        "FROM pat_task t LEFT JOIN pat_route_setup r ON t.route_id = r.id " +
+                        "WHERE t.route_id IS NOT NULL " +
+                        "AND t.created_at >= ?::date AND t.created_at < (?::date + interval '1 day') " +
+                        "GROUP BY t.route_id, r.route_name ORDER BY completionRate DESC NULLS LAST",
+                range[0], range[1]);
+    }
+
+    /**
+     * 按时间段统计执行率（按天，对应 GET /api/patrol/stats/completion-rate?dim=period）
+     */
+    public List<Map<String, Object>> completionRateByPeriod(StatsQueryRequest req) {
+        LocalDate[] range = resolveRange(req);
+        log.info("执行率(按时间段): {} ~ {}", range[0], range[1]);
+        return jdbc.queryForList(
+                "SELECT DATE(created_at) AS period, COUNT(*) AS total, " +
+                        "COUNT(*) FILTER (WHERE status = 'completed') AS completed, " +
+                        "ROUND(COUNT(*) FILTER (WHERE status = 'completed') * 100.0 / NULLIF(COUNT(*), 0), 2) AS completionRate " +
+                        "FROM pat_task " +
+                        "WHERE created_at >= ?::date AND created_at < (?::date + interval '1 day') " +
+                        "GROUP BY DATE(created_at) ORDER BY period",
+                range[0], range[1]);
+    }
+
+    // ==================== 里程统计 ====================
+
+    /**
+     * 里程概览（对应 GET /api/patrol/stats/mileage）
+     */
+    public Map<String, Object> mileageSummary(StatsQueryRequest req) {
+        LocalDate[] range = resolveRange(req);
+        long days = Math.max(ChronoUnit.DAYS.between(range[0], range[1]) + 1, 1);
+        log.info("里程概览: {} ~ {}", range[0], range[1]);
+        Map<String, Object> r = new HashMap<>();
+        Double total = jdbc.queryForObject(
+                "SELECT COALESCE(SUM(distance), 0) FROM pat_task WHERE created_at >= ?::date AND created_at < (?::date + interval '1 day')",
+                Double.class, range[0], range[1]);
+        BigDecimal t = total == null ? BigDecimal.ZERO : BigDecimal.valueOf(total);
+        r.put("totalDistance", t);
+        r.put("avgDailyDistance", t.divide(BigDecimal.valueOf(days), 2, RoundingMode.HALF_UP));
+        r.put("days", days);
+        return r;
+    }
+
+    /**
+     * 按巡检员统计里程
+     */
+    public List<Map<String, Object>> mileageByInspector(StatsQueryRequest req) {
+        LocalDate[] range = resolveRange(req);
+        log.info("里程(按巡检员): {} ~ {}", range[0], range[1]);
+        return jdbc.queryForList(
+                "SELECT worker_id AS inspectorId, worker_name AS inspectorName, " +
+                        "COALESCE(SUM(distance), 0) AS totalDistance, COUNT(*) AS taskCount " +
+                        "FROM pat_task WHERE worker_id IS NOT NULL " +
+                        "AND created_at >= ?::date AND created_at < (?::date + interval '1 day') " +
+                        "GROUP BY worker_id, worker_name ORDER BY totalDistance DESC",
+                range[0], range[1]);
+    }
+
+    /**
+     * 里程趋势（按天）
+     */
+    public List<Map<String, Object>> mileageTrend(StatsQueryRequest req) {
+        LocalDate[] range = resolveRange(req);
+        log.info("里程趋势: {} ~ {}", range[0], range[1]);
+        return jdbc.queryForList(
+                "SELECT DATE(created_at) AS date, COALESCE(SUM(distance), 0) AS distance, COUNT(*) AS taskCount " +
+                        "FROM pat_task " +
+                        "WHERE created_at >= ?::date AND created_at < (?::date + interval '1 day') " +
+                        "GROUP BY DATE(created_at) ORDER BY date",
+                range[0], range[1]);
+    }
+
+    // ==================== 问题分类统计 ====================
+
+    /**
+     * 问题类型分布（对应 GET /api/patrol/stats/issues?dim=type）
+     */
+    public List<Map<String, Object>> issueTypeDistribution(StatsQueryRequest req) {
+        LocalDate[] range = resolveRange(req);
+        log.info("问题类型分布: {} ~ {}", range[0], range[1]);
+        return jdbc.queryForList(
+                "SELECT COALESCE(NULLIF(issue_type, ''), '未分类') AS issueType, COUNT(*) AS count " +
+                        "FROM pat_issue_report " +
+                        "WHERE created_at >= ?::date AND created_at < (?::date + interval '1 day') " +
+                        "GROUP BY COALESCE(NULLIF(issue_type, ''), '未分类') ORDER BY count DESC",
+                range[0], range[1]);
+    }
+
+    /**
+     * 问题严重度分布
+     */
+    public List<Map<String, Object>> issueSeverityDistribution(StatsQueryRequest req) {
+        LocalDate[] range = resolveRange(req);
+        log.info("问题严重度分布: {} ~ {}", range[0], range[1]);
+        return jdbc.queryForList(
+                "SELECT COALESCE(NULLIF(severity, ''), 'unknown') AS severity, COUNT(*) AS count " +
+                        "FROM pat_issue_report " +
+                        "WHERE created_at >= ?::date AND created_at < (?::date + interval '1 day') " +
+                        "GROUP BY COALESCE(NULLIF(severity, ''), 'unknown') ORDER BY count DESC",
+                range[0], range[1]);
+    }
+
+    /**
+     * 问题解决率（对应 GET /api/patrol/stats/issues?dim=resolution）
+     */
+    public Map<String, Object> issueResolutionStats(StatsQueryRequest req) {
+        LocalDate[] range = resolveRange(req);
+        log.info("问题解决率: {} ~ {}", range[0], range[1]);
+        Integer total = jdbc.queryForObject(
+                "SELECT COUNT(*) FROM pat_issue_report WHERE created_at >= ?::date AND created_at < (?::date + interval '1 day')",
+                Integer.class, range[0], range[1]);
+        Integer resolved = jdbc.queryForObject(
+                "SELECT COUNT(*) FROM pat_issue_report WHERE status IN ('resolved','closed') " +
+                        "AND created_at >= ?::date AND created_at < (?::date + interval '1 day')",
+                Integer.class, range[0], range[1]);
+        int t = total == null ? 0 : total;
+        int r = resolved == null ? 0 : resolved;
+        Map<String, Object> m = new HashMap<>();
+        m.put("total", t);
+        m.put("resolved", r);
+        m.put("resolutionRate", rate(r, t));
+        return m;
+    }
+
+    // ==================== 工具方法 ====================
+
+    /** 计算百分比，分母为 0 返回 0 */
+    private BigDecimal rate(int part, int whole) {
+        if (whole <= 0) {
+            return BigDecimal.ZERO;
+        }
+        return BigDecimal.valueOf(part * 100.0 / whole).setScale(2, RoundingMode.HALF_UP);
+    }
+}

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

@@ -0,0 +1,43 @@
+-- =============================================================
+-- V89__patrol_stats.sql
+-- 巡检统计分析 - 每日汇总表（对应设计文档 7.3 统计分析）
+-- =============================================================
+
+-- 巡检每日汇总表（由定时任务凌晨执行聚合，本脚本仅建表 + 提供聚合 SQL 示例）
+CREATE TABLE IF NOT EXISTS patrol_stats_daily (
+    stat_date        DATE          NOT NULL,
+    worker_id        BIGINT,
+    worker_name      VARCHAR(50),
+    route_id         BIGINT,
+    area_id          BIGINT,
+    total_tasks      INT           DEFAULT 0,
+    completed_tasks  INT           DEFAULT 0,
+    total_distance   DOUBLE PRECISION DEFAULT 0,
+    total_minutes    INT           DEFAULT 0,
+    issue_count      INT           DEFAULT 0,
+    created_at       TIMESTAMPTZ   DEFAULT NOW(),
+    PRIMARY KEY (stat_date, worker_id, route_id)
+);
+CREATE INDEX IF NOT EXISTS idx_patrol_stats_date   ON patrol_stats_daily(stat_date);
+CREATE INDEX IF NOT EXISTS idx_patrol_stats_worker ON patrol_stats_daily(worker_id);
+
+-- =============================================================
+-- 每日聚合刷新 SQL（由 cron 凌晨执行，例如刷新昨天的数据）
+-- 用法: 将 :stat_date 替换为目标日期，如 CURRENT_DATE - 1
+-- =============================================================
+-- DELETE FROM patrol_stats_daily WHERE stat_date = :stat_date;
+-- INSERT INTO patrol_stats_daily (stat_date, worker_id, worker_name, route_id, area_id,
+--                                 total_tasks, completed_tasks, total_distance, total_minutes, issue_count)
+-- SELECT
+--     DATE(t.created_at)                                          AS stat_date,
+--     t.worker_id, t.worker_name, t.route_id, r.area_id,
+--     COUNT(*)                                                    AS total_tasks,
+--     COUNT(*) FILTER (WHERE t.status = 'completed')              AS completed_tasks,
+--     COALESCE(SUM(t.distance), 0)                                AS total_distance,
+--     COALESCE(SUM(EXTRACT(EPOCH FROM (t.end_time - t.start_time)) / 60), 0)::INT AS total_minutes,
+--     (SELECT COUNT(*) FROM pat_issue_report ir
+--        WHERE ir.task_id = t.id)                                 AS issue_count
+-- FROM pat_task t
+-- LEFT JOIN pat_route_setup r ON t.route_id = r.id
+-- WHERE DATE(t.created_at) = :stat_date
+-- GROUP BY DATE(t.created_at), t.worker_id, t.worker_name, t.route_id, r.area_id;

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

@@ -0,0 +1,86 @@
+package com.water.patrol.service;
+
+import com.water.patrol.entity.dto.RankResult;
+import com.water.patrol.entity.dto.StatsQueryRequest;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+/**
+ * PatrolRankService 单元测试
+ */
+@ExtendWith(MockitoExtension.class)
+class PatrolRankServiceTest {
+
+    @Mock JdbcTemplate jdbc;
+    @InjectMocks PatrolRankService svc;
+
+    @Test
+    void inspectorRank_assignsSequentialRanksAndRespectsTopN() {
+        // 模拟 mapper 返回两行（按 score 降序）
+        when(jdbc.query(anyString(), any(org.springframework.jdbc.core.RowMapper.class), any(), any(), any()))
+                .thenAnswer(inv -> {
+                    List<RankResult> rows = List.of(build(1L, "张三", 50.0, 10, 9),
+                                                    build(2L, "李四", 30.0, 8, 5));
+                    return rows;
+                });
+
+        StatsQueryRequest req = new StatsQueryRequest();
+        req.setTopN(5);
+        List<RankResult> r = svc.inspectorRank(req);
+        assertEquals(2, r.size());
+        assertEquals(1, r.get(0).getRank());
+        assertEquals("张三", r.get(0).getName());
+        assertEquals(2, r.get(1).getRank());
+        assertEquals("李四", r.get(1).getName());
+        // score 保留
+        assertEquals(0, java.math.BigDecimal.valueOf(50.0).compareTo(r.get(0).getScore()));
+    }
+
+    @Test
+    void inspectorRank_emptyResultWhenNoData() {
+        when(jdbc.query(anyString(), any(org.springframework.jdbc.core.RowMapper.class), any(), any(), any()))
+                .thenReturn(List.of());
+        List<RankResult> r = svc.inspectorRank(null);
+        assertNotNull(r);
+        assertTrue(r.isEmpty());
+    }
+
+    @Test
+    void routeRank_returnsRows() {
+        when(jdbc.query(anyString(), any(org.springframework.jdbc.core.RowMapper.class), any(), any(), any()))
+                .thenReturn(List.of(build(10L, "北线", 100.0, 5, 5)));
+        List<RankResult> r = svc.routeRank(null);
+        assertEquals(1, r.size());
+        assertEquals(1, r.get(0).getRank());
+        assertEquals("北线", r.get(0).getName());
+    }
+
+    @Test
+    void topN_defaultsTo10WhenNullOrNonPositive() {
+        // 仅验证默认值逻辑：传 null 请求不应抛异常
+        when(jdbc.query(anyString(), any(org.springframework.jdbc.core.RowMapper.class), any(), any(), eq(10)))
+                .thenReturn(List.of());
+        StatsQueryRequest req = new StatsQueryRequest(); // topN 默认 10
+        assertDoesNotThrow(() -> svc.inspectorRank(req));
+    }
+
+    private RankResult build(Long id, String name, double score, int total, int completed) {
+        RankResult r = new RankResult();
+        r.setId(id);
+        r.setName(name);
+        r.setScore(java.math.BigDecimal.valueOf(score));
+        r.setTotalTasks(total);
+        r.setCompletedTasks(completed);
+        return r;
+    }
+}

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

@@ -0,0 +1,161 @@
+package com.water.patrol.service;
+
+import com.water.patrol.entity.dto.StatsQueryRequest;
+import com.water.patrol.entity.dto.StatsSummary;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+/**
+ * PatrolStatsService 单元测试
+ */
+@ExtendWith(MockitoExtension.class)
+class PatrolStatsServiceTest {
+
+    @Mock JdbcTemplate jdbc;
+    @InjectMocks PatrolStatsService svc;
+
+    // ---------- 区间默认值 ----------
+    @Test
+    void resolveRange_defaultsToLast30Days() {
+        // 不传日期时应取最近 30 天，不会抛异常（即便底层 jdbc 未打桩，dashboard 也容忍 null）
+        // 这里用 mileage（单查询）验证默认区间被解析且执行
+        when(jdbc.queryForObject(anyString(), eq(Double.class), any(), any())).thenReturn(0.0);
+        StatsQueryRequest req = new StatsQueryRequest(); // 全空
+        Map<String, Object> m = svc.mileageSummary(req);
+        assertNotNull(m);
+        assertEquals(30, ((Number) m.get("days")).intValue());
+    }
+
+    // ---------- 综合看板：执行率/解决率计算 ----------
+    @Test
+    void dashboardSummary_computesExecutionAndResolutionRate() {
+        // totalTasks=10, completedTasks=8 -> 执行率 80
+        when(jdbc.queryForObject(contains("FROM pat_task WHERE created_at"), eq(Integer.class), any(), any()))
+                .thenReturn(10);
+        when(jdbc.queryForObject(contains("status = 'completed'"), eq(Integer.class), any(), any()))
+                .thenReturn(8);
+        // totalDistance
+        when(jdbc.queryForObject(contains("SUM(distance)"), eq(Double.class), any(), any()))
+                .thenReturn(300.0);
+        // issues total=5, resolved=3 -> 解决率 60
+        when(jdbc.queryForObject(contains("FROM pat_issue_report WHERE created_at"), eq(Integer.class), any(), any()))
+                .thenReturn(5);
+        when(jdbc.queryForObject(contains("status IN ('resolved','closed')"), eq(Integer.class), any(), any()))
+                .thenReturn(3);
+        when(jdbc.queryForObject(contains("COUNT(DISTINCT worker_id)"), eq(Integer.class), any(), any()))
+                .thenReturn(4);
+        when(jdbc.queryForObject(contains("COUNT(DISTINCT route_id)"), eq(Integer.class), any(), any()))
+                .thenReturn(2);
+
+        StatsSummary s = svc.dashboardSummary(null);
+        assertEquals(10, s.getTotalTasks());
+        assertEquals(8, s.getCompletedTasks());
+        assertEquals(0, new BigDecimal("80.00").compareTo(s.getExecutionRate()));
+        assertEquals(5, s.getTotalIssues());
+        assertEquals(3, s.getResolvedIssues());
+        assertEquals(0, new BigDecimal("60.00").compareTo(s.getResolutionRate()));
+        assertEquals(4, s.getInspectorCount());
+        assertEquals(2, s.getActiveRoutes());
+        assertEquals(0, new BigDecimal("300.0").compareTo(s.getTotalDistance()));
+    }
+
+    @Test
+    void dashboardSummary_zeroTotalYieldsZeroRate() {
+        when(jdbc.queryForObject(anyString(), eq(Integer.class), any(), any())).thenReturn(0);
+        when(jdbc.queryForObject(anyString(), eq(Double.class), any(), any())).thenReturn(0.0);
+        StatsSummary s = svc.dashboardSummary(null);
+        assertEquals(0, s.getTotalTasks());
+        assertEquals(0, new BigDecimal("0").compareTo(s.getExecutionRate()));
+        assertEquals(0, new BigDecimal("0").compareTo(s.getResolutionRate()));
+    }
+
+    // ---------- 执行率分组 ----------
+    @Test
+    void completionRateByInspector_returnsRows() {
+        List<Map<String, Object>> rows = List.of(
+                Map.of("inspectorId", 1L, "inspectorName", "张三", "total", 10, "completed", 9, "completionrate", 90.0));
+        when(jdbc.queryForList(anyString(), any(), any())).thenReturn(rows);
+        List<Map<String, Object>> result = svc.completionRateByInspector(null);
+        assertEquals(1, result.size());
+        assertEquals("张三", result.get(0).get("inspectorName"));
+    }
+
+    @Test
+    void completionRateByRoute_returnsRows() {
+        when(jdbc.queryForList(anyString(), any(), any())).thenReturn(List.of());
+        assertNotNull(svc.completionRateByRoute(null));
+    }
+
+    @Test
+    void completionRateByPeriod_returnsRows() {
+        when(jdbc.queryForList(anyString(), any(), any())).thenReturn(List.of());
+        assertNotNull(svc.completionRateByPeriod(null));
+    }
+
+    // ---------- 里程 ----------
+    @Test
+    void mileageSummary_computesAvgDaily() {
+        when(jdbc.queryForObject(anyString(), eq(Double.class), any(), any())).thenReturn(600.0);
+        StatsQueryRequest req = new StatsQueryRequest();
+        req.setStartDate(LocalDate.of(2026, 6, 1));
+        req.setEndDate(LocalDate.of(2026, 6, 5)); // 5 天
+        Map<String, Object> m = svc.mileageSummary(req);
+        assertEquals(0, new BigDecimal("600.0").compareTo((BigDecimal) m.get("totalDistance")));
+        assertEquals(5, ((Number) m.get("days")).intValue());
+        // 日均 = 600 / 5 = 120.00
+        assertEquals(0, new BigDecimal("120.00").compareTo((BigDecimal) m.get("avgDailyDistance")));
+    }
+
+    @Test
+    void mileageByInspector_returnsRows() {
+        when(jdbc.queryForList(anyString(), any(), any())).thenReturn(List.of());
+        assertNotNull(svc.mileageByInspector(null));
+    }
+
+    @Test
+    void mileageTrend_returnsRows() {
+        when(jdbc.queryForList(anyString(), any(), any())).thenReturn(List.of());
+        assertNotNull(svc.mileageTrend(null));
+    }
+
+    // ---------- 问题分类 ----------
+    @Test
+    void issueTypeDistribution_returnsRows() {
+        when(jdbc.queryForList(anyString(), any(), any())).thenReturn(
+                List.of(Map.of("issuetype", "leak", "count", 3)));
+        List<Map<String, Object>> r = svc.issueTypeDistribution(null);
+        assertEquals(1, r.size());
+    }
+
+    @Test
+    void issueSeverityDistribution_returnsRows() {
+        when(jdbc.queryForList(anyString(), any(), any())).thenReturn(List.of());
+        assertNotNull(svc.issueSeverityDistribution(null));
+    }
+
+    @Test
+    void issueResolutionStats_computesRate() {
+        when(jdbc.queryForObject(contains("FROM pat_issue_report WHERE created_at"), eq(Integer.class), any(), any()))
+                .thenReturn(4);
+        when(jdbc.queryForObject(contains("'resolved','closed'"), eq(Integer.class), any(), any()))
+                .thenReturn(1);
+        Map<String, Object> m = svc.issueResolutionStats(null);
+        assertEquals(4, m.get("total"));
+        assertEquals(1, m.get("resolved"));
+        // 1/4 * 100 = 25.00
+        assertEquals(0, new BigDecimal("25.00").compareTo((BigDecimal) m.get("resolutionRate")));
+    }
+}