feat(data-engine): #71 历史数据回溯 + 报表生成（水量/水质/报警）

- 新增历史数据查询功能，支持按类型、时间、区域过滤
- 新增水量汇总报表，包含总量、分区域统计、每日趋势
- 新增水质合格率报表，包含总检测数、合格数、分区域合格率
- 新增报警统计报表，包含总量、级别统计、区域分布、每日趋势
- 新增综合数据报表，整合水量、水质、报警数据并提供评估建议
- 新增HistoryDataController，提供完整的RESTful API接口
- 扩展ReportService支持各种类型报表生成和保存
- 支持报表发布和状态管理功能

API端点：
- GET /api/data/historical - 历史数据查询
- GET /api/data/report/water-volume - 水量汇总报表
- GET /api/data/report/water-quality - 水质合格率报表
- GET /api/data/report/alarm-statistics - 报警统计报表
- POST /api/data/report/*/generate - 生成各类报表并保存
- GET /api/data/reports - 报表列表
- GET /api/data/reports/{id} - 报表详情
- POST /api/data/reports/{id}/publish - 发布报表

提交ID: f6a7b11c
Issue: #71
分支: feature/issue-71

wm-data-engine/src/main/java/com/water/data_engine/controller/HistoryDataController.java

@@ -0,0 +1,316 @@
+package com.water.data_engine.controller;
+
+import com.water.common.core.result.R;
+import com.water.data_engine.service.DataStatisticsService;
+import com.water.data_engine.service.ReportService;
+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 lombok.extern.slf4j.Slf4j;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.web.bind.annotation.*;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 历史数据查询和报表生成控制器
+ * 对应 Issue #71：历史数据回溯 + 报表生成（水量/水质/报警）
+ */
+@Tag(name = "历史数据查询与报表")
+@RestController
+@RequestMapping("/api/data")
+@Slf4j
+@RequiredArgsConstructor
+public class HistoryDataController {
+
+    private final DataStatisticsService dataStatisticsService;
+    private final ReportService reportService;
+
+    @Operation(summary = "历史数据回溯查询")
+    @GetMapping("/historical")
+    public R<Map<String, Object>> queryHistoricalData(
+            @Parameter(description = "数据类型：water_volume/pressure/water_quality/alarm") 
+            @RequestParam(required = false) String dataType,
+            @Parameter(description = "区域名称") 
+            @RequestParam(required = false) String area,
+            @Parameter(description = "开始时间，格式：yyyy-MM-dd HH:mm:ss") 
+            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") String startTime,
+            @Parameter(description = "结束时间，格式：yyyy-MM-dd HH:mm:ss") 
+            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") String endTime) {
+        
+        log.info("开始查询历史数据: dataType={}, area={}, startTime={}, endTime={}", dataType, area, startTime, endTime);
+        
+        try {
+            Map<String, Object> result = dataStatisticsService.queryHistoricalData(dataType, area, startTime, endTime);
+            log.info("历史数据查询成功，返回 {} 条记录", result.get("totalRecords"));
+            return R.ok(result);
+        } catch (Exception e) {
+            log.error("历史数据查询失败: {}", e.getMessage());
+            return R.error("历史数据查询失败: " + e.getMessage());
+        }
+    }
+
+    @Operation(summary = "水量汇总报表")
+    @GetMapping("/report/water-volume")
+    public R<Map<String, Object>> getWaterVolumeSummary(
+            @Parameter(description = "查询开始时间，格式：yyyy-MM-dd HH:mm:ss") 
+            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") String startTime,
+            @Parameter(description = "查询结束时间，格式：yyyy-MM-dd HH:mm:ss") 
+            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") String endTime) {
+        
+        log.info("开始生成水量汇总报表: startTime={}, endTime={}", startTime, endTime);
+        
+        try {
+            Map<String, Object> summary = dataStatisticsService.getWaterVolumeSummary(startTime, endTime);
+            log.info("水量汇总生成成功");
+            return R.ok(summary);
+        } catch (Exception e) {
+            log.error("水量汇总生成失败: {}", e.getMessage());
+            return R.error("水量汇总生成失败: " + e.getMessage());
+        }
+    }
+
+    @Operation(summary = "水质合格率报表")
+    @GetMapping("/report/water-quality")
+    public R<Map<String, Object>> getWaterQualityRate(
+            @Parameter(description = "查询开始时间，格式：yyyy-MM-dd HH:mm:ss") 
+            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") String startTime,
+            @Parameter(description = "查询结束时间，格式：yyyy-MM-dd HH:mm:ss") 
+            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") String endTime) {
+        
+        log.info("开始生成水质合格率报表: startTime={}, endTime={}", startTime, endTime);
+        
+        try {
+            Map<String, Object> qualityStats = dataStatisticsService.getWaterQualityRate(startTime, endTime);
+            log.info("水质合格率统计成功");
+            return R.ok(qualityStats);
+        } catch (Exception e) {
+            log.error("水质合格率统计失败: {}", e.getMessage());
+            return R.error("水质合格率统计失败: " + e.getMessage());
+        }
+    }
+
+    @Operation(summary = "报警统计报表")
+    @GetMapping("/report/alarm-statistics")
+    public R<Map<String, Object>> getAlarmStatistics(
+            @Parameter(description = "查询开始时间，格式：yyyy-MM-dd HH:mm:ss") 
+            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") String startTime,
+            @Parameter(description = "查询结束时间，格式：yyyy-MM-dd HH:mm:ss") 
+            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") String endTime) {
+        
+        log.info("开始生成报警统计报表: startTime={}, endTime={}", startTime, endTime);
+        
+        try {
+            Map<String, Object> alarmStats = dataStatisticsService.getAlarmStatistics(startTime, endTime);
+            log.info("报警统计生成成功");
+            return R.ok(alarmStats);
+        } catch (Exception e) {
+            log.error("报警统计生成失败: {}", e.getMessage());
+            return R.error("报警统计生成失败: " + e.getMessage());
+        }
+    }
+
+    @Operation(summary = "生成水量汇总报表并保存")
+    @PostMapping("/report/water-volume/generate")
+    public R<Map<String, Object>> generateWaterVolumeReport(
+            @Parameter(description = "报表周期描述") 
+            @RequestParam String period,
+            @Parameter(description = "查询开始时间，格式：yyyy-MM-dd HH:mm:ss") 
+            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") String startTime,
+            @Parameter(description = "查询结束时间，格式：yyyy-MM-dd HH:mm:ss") 
+            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") String endTime) {
+        
+        log.info("开始生成并保存水量汇总报表: period={}, startTime={}, endTime={}", period, startTime, endTime);
+        
+        try {
+            var report = reportService.generateWaterVolumeReport(period, startTime, endTime);
+            
+            Map<String, Object> result = Map.of(
+                "reportNo", report.getReportNo(),
+                "reportType", report.getReportType(),
+                "period", report.getPeriod(),
+                "title", report.getTitle(),
+                "status", report.getStatus(),
+                "createdTime", report.getCreatedTime()
+            );
+            
+            log.info("水量汇总报表生成并保存成功: reportNo={}", report.getReportNo());
+            return R.ok(result);
+        } catch (Exception e) {
+            log.error("水量汇总报表生成失败: {}", e.getMessage());
+            return R.error("水量汇总报表生成失败: " + e.getMessage());
+        }
+    }
+
+    @Operation(summary = "生成水质合格率报表并保存")
+    @PostMapping("/report/water-quality/generate")
+    public R<Map<String, Object>> generateWaterQualityReport(
+            @Parameter(description = "报表周期描述") 
+            @RequestParam String period,
+            @Parameter(description = "查询开始时间，格式：yyyy-MM-dd HH:mm:ss") 
+            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") String startTime,
+            @Parameter(description = "查询结束时间，格式：yyyy-MM-dd HH:mm:ss") 
+            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") String endTime) {
+        
+        log.info("开始生成并保存水质合格率报表: period={}, startTime={}, endTime={}", period, startTime, endTime);
+        
+        try {
+            var report = reportService.generateWaterQualityReport(period, startTime, endTime);
+            
+            Map<String, Object> result = Map.of(
+                "reportNo", report.getReportNo(),
+                "reportType", report.getReportType(),
+                "period", report.getPeriod(),
+                "title", report.getTitle(),
+                "status", report.getStatus(),
+                "createdTime", report.getCreatedTime()
+            );
+            
+            log.info("水质合格率报表生成并保存成功: reportNo={}", report.getReportNo());
+            return R.ok(result);
+        } catch (Exception e) {
+            log.error("水质合格率报表生成失败: {}", e.getMessage());
+            return R.error("水质合格率报表生成失败: " + e.getMessage());
+        }
+    }
+
+    @Operation(summary = "生成报警统计报表并保存")
+    @PostMapping("/report/alarm-statistics/generate")
+    public R<Map<String, Object>> generateAlarmStatisticsReport(
+            @Parameter(description = "报表周期描述") 
+            @RequestParam String period,
+            @Parameter(description = "查询开始时间，格式：yyyy-MM-dd HH:mm:ss") 
+            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") String startTime,
+            @Parameter(description = "查询结束时间，格式：yyyy-MM-dd HH:mm:ss") 
+            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") String endTime) {
+        
+        log.info("开始生成并保存报警统计报表: period={}, startTime={}, endTime={}", period, startTime, endTime);
+        
+        try {
+            var report = reportService.generateAlarmStatisticsReport(period, startTime, endTime);
+            
+            Map<String, Object> result = Map.of(
+                "reportNo", report.getReportNo(),
+                "reportType", report.getReportType(),
+                "period", report.getPeriod(),
+                "title", report.getTitle(),
+                "status", report.getStatus(),
+                "createdTime", report.getCreatedTime()
+            );
+            
+            log.info("报警统计报表生成并保存成功: reportNo={}", report.getReportNo());
+            return R.ok(result);
+        } catch (Exception e) {
+            log.error("报警统计报表生成失败: {}", e.getMessage());
+            return R.error("报警统计报表生成失败: " + e.getMessage());
+        }
+    }
+
+    @Operation(summary = "生成综合数据报表")
+    @PostMapping("/report/comprehensive/generate")
+    public R<Map<String, Object>> generateComprehensiveReport(
+            @Parameter(description = "报表周期描述") 
+            @RequestParam String period,
+            @Parameter(description = "查询开始时间，格式：yyyy-MM-dd HH:mm:ss") 
+            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") String startTime,
+            @Parameter(description = "查询结束时间，格式：yyyy-MM-dd HH:mm:ss") 
+            @RequestParam(required = false) @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") String endTime) {
+        
+        log.info("开始生成综合数据报表: period={}, startTime={}, endTime={}", period, startTime, endTime);
+        
+        try {
+            var report = reportService.generateComprehensiveReport(period, startTime, endTime);
+            
+            Map<String, Object> result = Map.of(
+                "reportNo", report.getReportNo(),
+                "reportType", report.getReportType(),
+                "period", report.getPeriod(),
+                "title", report.getTitle(),
+                "status", report.getStatus(),
+                "createdTime", report.getCreatedTime()
+            );
+            
+            log.info("综合数据报表生成并保存成功: reportNo={}", report.getReportNo());
+            return R.ok(result);
+        } catch (Exception e) {
+            log.error("综合数据报表生成失败: {}", e.getMessage());
+            return R.error("综合数据报表生成失败: " + e.getMessage());
+        }
+    }
+
+    @Operation(summary = "获取报表列表")
+    @GetMapping("/reports")
+    public R<List<Map<String, Object>>> getReports(
+            @Parameter(description = "报表类型：water_volume/water_quality/alarm_statistics/comprehensive") 
+            @RequestParam(required = false) String reportType,
+            @Parameter(description = "报表状态：GENERATED/PUBLISHED") 
+            @RequestParam(required = false) String status) {
+        
+        try {
+            var reports = reportService.listReports(reportType, status);
+            List<Map<String, Object>> result = reports.stream()
+                .map(report -> Map.of(
+                    "id", report.getId(),
+                    "reportNo", report.getReportNo(),
+                    "reportType", report.getReportType(),
+                    "period", report.getPeriod(),
+                    "title", report.getTitle(),
+                    "status", report.getStatus(),
+                    "createdTime", report.getCreatedTime(),
+                    "publishedTime", report.getPublishedTime()
+                ))
+                .toList();
+            
+            return R.ok(result);
+        } catch (Exception e) {
+            log.error("获取报表列表失败: {}", e.getMessage());
+            return R.error("获取报表列表失败: " + e.getMessage());
+        }
+    }
+
+    @Operation(summary = "获取报表详情")
+    @GetMapping("/reports/{id}")
+    public R<Map<String, Object>> getReportDetail(@PathVariable Long id) {
+        
+        try {
+            var report = reportService.getReport(id);
+            if (report == null) {
+                return R.error("报表不存在");
+            }
+            
+            Map<String, Object> result = Map.of(
+                "id", report.getId(),
+                "reportNo", report.getReportNo(),
+                "reportType", report.getReportType(),
+                "period", report.getPeriod(),
+                "title", report.getTitle(),
+                "status", report.getStatus(),
+                "content", report.getContent(),
+                "createdTime", report.getCreatedTime(),
+                "publishedTime", report.getPublishedTime()
+            );
+            
+            return R.ok(result);
+        } catch (Exception e) {
+            log.error("获取报表详情失败: {}", e.getMessage());
+            return R.error("获取报表详情失败: " + e.getMessage());
+        }
+    }
+
+    @Operation(summary = "发布报表")
+    @PostMapping("/reports/{id}/publish")
+    public R<String> publishReport(@PathVariable Long id) {
+        
+        try {
+            reportService.publishReport(id);
+            log.info("报表发布成功: id={}", id);
+            return R.ok("报表发布成功");
+        } catch (Exception e) {
+            log.error("报表发布失败: {}", e.getMessage());
+            return R.error("报表发布失败: " + e.getMessage());
+        }
+    }
+}

wm-data-engine/src/main/java/com/water/data_engine/service/DataStatisticsService.java

@@ -7,13 +7,12 @@ import org.springframework.stereotype.Service;
 
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * 数据统计服务
- * 提供数据采集统计、质量分析等功能
+ * 提供数据采集统计、质量分析、历史数据查询等功能
  */
 @Slf4j
 @Service
@@ -83,6 +82,243 @@ public class DataStatisticsService {
         return stats;
     }
 
+    /**
+     * 历史数据回溯查询
+     * 支持按数据类型、时间范围、区域查询历史数据
+     */
+    public Map<String, Object> queryHistoricalData(String dataType, String area, String startTime, String endTime) {
+        Map<String, Object> result = new HashMap<>();
+        
+        // 默认查询最近7天
+        if (startTime == null) {
+            startTime = LocalDateTime.now().minusDays(7).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+        }
+        if (endTime == null) {
+            endTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+        }
+        
+        try {
+            List<Map<String, Object>> dataRecords = new ArrayList<>();
+            String baseSql = "SELECT * FROM collect_record WHERE collect_time BETWEEN ? AND ?";
+            List<Object> params = new ArrayList<>();
+            params.add(startTime);
+            params.add(endTime);
+            
+            // 按数据类型过滤
+            if (dataType != null && !dataType.trim().isEmpty()) {
+                baseSql += " AND data_type = ?";
+                params.add(dataType);
+            }
+            
+            // 按区域过滤
+            if (area != null && !area.trim().isEmpty()) {
+                baseSql += " AND area = ?";
+                params.add(area);
+            }
+            
+            baseSql += " ORDER BY collect_time DESC";
+            
+            // 执行查询
+            dataRecords = jdbcTemplate.queryForList(baseSql, params.toArray());
+            
+            // 数据预处理
+            List<Map<String, Object>> processedData = dataRecords.stream()
+                .map(record -> {
+                    Map<String, Object> processed = new HashMap<>();
+                    processed.put("id", record.get("id"));
+                    processed.put("sourceKey", record.get("source_key"));
+                    processed.put("dataType", record.get("data_type"));
+                    processed.put("area", record.get("area"));
+                    processed.put("collectTime", record.get("collect_time"));
+                    processed.put("value", record.get("data_value"));
+                    processed.put("status", record.get("status"));
+                    processed.put("errorMsg", record.get("error_msg"));
+                    return processed;
+                })
+                .collect(Collectors.toList());
+            
+            result.put("dataRecords", processedData);
+            result.put("totalRecords", processedData.size());
+            result.put("queryPeriod", startTime + " - " + endTime);
+            
+            if (dataType != null && !dataType.trim().isEmpty()) {
+                result.put("filterByType", dataType);
+            }
+            
+            if (area != null && !area.trim().isEmpty()) {
+                result.put("filterByArea", area);
+            }
+            
+            log.info("查询历史数据成功: {}条记录, 类型={}, 区域={}", processedData.size(), dataType, area);
+            
+        } catch (Exception e) {
+            log.error("查询历史数据失败: {}", e.getMessage());
+            throw new RuntimeException("历史数据查询失败: " + e.getMessage());
+        }
+        
+        return result;
+    }
+
+    /**
+     * 获取水量汇总报表数据
+     */
+    public Map<String, Object> getWaterVolumeSummary(String startTime, String endTime) {
+        Map<String, Object> summary = new HashMap<>();
+        
+        if (startTime == null) {
+            startTime = LocalDateTime.now().minusDays(7).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+        }
+        if (endTime == null) {
+            endTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+        }
+        
+        try {
+            // 总供水量
+            String totalSupplySql = "SELECT SUM(data_value) as totalSupply FROM collect_record " +
+                                 "WHERE data_type = 'water_volume' AND collect_time BETWEEN ? AND ?";
+            Double totalSupply = jdbcTemplate.queryForObject(totalSupplySql, Double.class, startTime, endTime);
+            
+            // 分区域供水量统计
+            String areaSupplySql = "SELECT area, SUM(data_value) as supply FROM collect_record " +
+                                "WHERE data_type = 'water_volume' AND collect_time BETWEEN ? AND ? " +
+                                "GROUP BY area ORDER BY supply DESC";
+            List<Map<String, Object>> areaSupply = jdbcTemplate.queryForList(areaSupplySql, startTime, endTime);
+            
+            // 每日供水量趋势
+            String dailyTrendSql = "SELECT DATE(collect_time) as date, SUM(data_value) as dailySupply " +
+                                "FROM collect_record WHERE data_type = 'water_volume' AND collect_time BETWEEN ? AND ? " +
+                                "GROUP BY DATE(collect_time) ORDER BY date";
+            List<Map<String, Object>> dailyTrend = jdbcTemplate.queryForList(dailyTrendSql, startTime, endTime);
+            
+            summary.put("totalSupply", totalSupply != null ? totalSupply : 0.0);
+            summary.put("areaSupplyStats", areaSupply);
+            summary.put("dailyTrend", dailyTrend);
+            
+            log.info("获取水量汇总成功: 总供水量={}, 分区域数={}", totalSupply, areaSupply.size());
+            
+        } catch (Exception e) {
+            log.error("获取水量汇总失败: {}", e.getMessage());
+            throw new RuntimeException("水量汇总查询失败: " + e.getMessage());
+        }
+        
+        return summary;
+    }
+
+    /**
+     * 获取水质合格率统计
+     */
+    public Map<String, Object> getWaterQualityRate(String startTime, String endTime) {
+        Map<String, Object> qualityStats = new HashMap<>();
+        
+        if (startTime == null) {
+            startTime = LocalDateTime.now().minusDays(7).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+        }
+        if (endTime == null) {
+            endTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+        }
+        
+        try {
+            // 水质检测总量
+            String totalTestsSql = "SELECT COUNT(*) as totalTests FROM collect_record " +
+                                "WHERE data_type = 'water_quality' AND collect_time BETWEEN ? AND ?";
+            Integer totalTests = jdbcTemplate.queryForObject(totalTestsSql, Integer.class, startTime, endTime);
+            
+            // 合格检测数量（假设数据值 > 80 为合格）
+            String passedTestsSql = "SELECT COUNT(*) as passedTests FROM collect_record " +
+                                 "WHERE data_type = 'water_quality' AND data_value >= 80 AND collect_time BETWEEN ? AND ?";
+            Integer passedTests = jdbcTemplate.queryForObject(passedTestsSql, Integer.class, startTime, endTime);
+            
+            // 合格率计算
+            double passRate = totalTests > 0 ? (double) passedTests / totalTests * 100 : 0;
+            
+            // 分区域合格率
+            String areaQualitySql = "SELECT area, COUNT(*) as total, SUM(CASE WHEN data_value >= 80 THEN 1 ELSE 0 END) as passed " +
+                                  "FROM collect_record WHERE data_type = 'water_quality' AND collect_time BETWEEN ? AND ? " +
+                                  "GROUP BY area";
+            List<Map<String, Object>> areaQuality = jdbcTemplate.queryForList(areaQualitySql, startTime, endTime);
+            
+            // 处理分区域合格率数据
+            List<Map<String, Object>> processedAreaQuality = areaQuality.stream()
+                .map(area -> {
+                    Map<String, Object> processed = new HashMap<>();
+                    processed.put("area", area.get("area"));
+                    processed.put("totalTests", area.get("total"));
+                    processed.put("passedTests", area.get("passed"));
+                    double areaPassRate = (int)area.get("total") > 0 ? 
+                        (double)(int)area.get("passed") / (int)area.get("total") * 100 : 0;
+                    processed.put("passRate", String.format("%.2f%%", areaPassRate));
+                    return processed;
+                })
+                .collect(Collectors.toList());
+            
+            qualityStats.put("totalTests", totalTests != null ? totalTests : 0);
+            qualityStats.put("passedTests", passedTests != null ? passedTests : 0);
+            qualityStats.put("passRate", String.format("%.2f%%", passRate));
+            qualityStats.put("areaQualityStats", processedAreaQuality);
+            
+            log.info("获取水质合格率成功: 总检测={}, 合格={}, 合格率={}", totalTests, passedTests, String.format("%.2f%%", passRate));
+            
+        } catch (Exception e) {
+            log.error("获取水质合格率失败: {}", e.getMessage());
+            throw new RuntimeException("水质合格率查询失败: " + e.getMessage());
+        }
+        
+        return qualityStats;
+    }
+
+    /**
+     * 获取报警统计
+     */
+    public Map<String, Object> getAlarmStatistics(String startTime, String endTime) {
+        Map<String, Object> alarmStats = new HashMap<>();
+        
+        if (startTime == null) {
+            startTime = LocalDateTime.now().minusDays(7).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+        }
+        if (endTime == null) {
+            endTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+        }
+        
+        try {
+            // 报警总量
+            String totalAlarmsSql = "SELECT COUNT(*) as totalAlarms FROM collect_record " +
+                                 "WHERE data_type = 'alarm' AND collect_time BETWEEN ? AND ?";
+            Integer totalAlarms = jdbcTemplate.queryForObject(totalAlarmsSql, Integer.class, startTime, endTime);
+            
+            // 按报警级别统计
+            String levelStatsSql = "SELECT source_key as alarmLevel, COUNT(*) as count FROM collect_record " +
+                                  "WHERE data_type = 'alarm' AND collect_time BETWEEN ? AND ? " +
+                                  "GROUP BY source_key ORDER BY count DESC";
+            List<Map<String, Object>> levelStats = jdbcTemplate.queryForList(levelStatsSql, startTime, endTime);
+            
+            // 按区域报警统计
+            String areaAlarmSql = "SELECT area, COUNT(*) as alarmCount FROM collect_record " +
+                                "WHERE data_type = 'alarm' AND collect_time BETWEEN ? AND ? " +
+                                "GROUP BY area ORDER BY alarmCount DESC";
+            List<Map<String, Object>> areaAlarmStats = jdbcTemplate.queryForList(areaAlarmSql, startTime, endTime);
+            
+            // 每日报警趋势
+            String dailyAlarmSql = "SELECT DATE(collect_time) as date, COUNT(*) as alarmCount " +
+                                "FROM collect_record WHERE data_type = 'alarm' AND collect_time BETWEEN ? AND ? " +
+                                "GROUP BY DATE(collect_time) ORDER BY date";
+            List<Map<String, Object>> dailyAlarmTrend = jdbcTemplate.queryForList(dailyAlarmSql, startTime, endTime);
+            
+            alarmStats.put("totalAlarms", totalAlarms != null ? totalAlarms : 0);
+            alarmStats.put("levelStatistics", levelStats);
+            alarmStats.put("areaAlarmStats", areaAlarmStats);
+            alarmStats.put("dailyAlarmTrend", dailyAlarmTrend);
+            
+            log.info("获取报警统计成功: 总报警={}, 级别统计={}, 区域统计={}", 
+                totalAlarms, levelStats.size(), areaAlarmStats.size());
+            
+        } catch (Exception e) {
+            log.error("获取报警统计失败: {}", e.getMessage());
+            throw new RuntimeException("报警统计查询失败: " + e.getMessage());
+        }
+        
+        return alarmStats;
+    }
+
     /**
      * 获取设备数据统计
      */

wm-data-engine/src/main/java/com/water/data_engine/service/ReportService.java

@@ -10,6 +10,7 @@ import org.springframework.stereotype.Service;
 
 import java.time.LocalDate;
 import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
 import java.util.*;
 
 @Service
@@ -18,9 +19,293 @@ public class ReportService {
 
     private final DataReportMapper reportMapper;
     private final ReportTemplateMapper templateMapper;
+    private final DataStatisticsService dataStatisticsService;
 
     /**
-     * 自动生成报表
+     * 生成水量汇总报表
+     */
+    public DataReport generateWaterVolumeReport(String period, String startTime, String endTime) {
+        DataReport report = new DataReport();
+        report.setReportName("水量汇总报表");
+        report.setReportCode("WATER-VOL-" + System.currentTimeMillis());
+        report.setReportType("water_volume");
+        report.setDataType("water_supply");
+        report.setArea("ALL");
+        
+        try {
+            // 设置时间范围
+            LocalDate start = startTime != null ? LocalDate.parse(startTime.substring(0, 10)) : LocalDate.now().minusDays(7);
+            LocalDate end = endTime != null ? LocalDate.parse(endTime.substring(0, 10)) : LocalDate.now();
+            report.setPeriodStart(start);
+            report.setPeriodEnd(end);
+            
+            // 获取水量汇总数据
+            Map<String, Object> waterVolumeData = dataStatisticsService.getWaterVolumeSummary(startTime, endTime);
+            
+            Map<String, Object> content = new LinkedHashMap<>();
+            content.put("generatedAt", LocalDateTime.now());
+            content.put("period", period);
+            content.put("startTime", startTime);
+            content.put("endTime", endTime);
+            
+            // 基础统计
+            content.put("totalWaterSupply", waterVolumeData.get("totalSupply"));
+            content.put("totalAreaCount", ((List<?>) waterVolumeData.get("areaSupplyStats")).size());
+            
+            // 分区域供水量统计
+            content.put("areaWaterSupply", waterVolumeData.get("areaSupplyStats"));
+            
+            // 每日趋势数据
+            content.put("dailyTrend", waterVolumeData.get("dailyTrend"));
+            
+            // 计算平均日供水量
+            List<Map<String, Object>> dailyTrend = (List<Map<String, Object>>) waterVolumeData.get("dailyTrend");
+            if (dailyTrend != null && !dailyTrend.isEmpty()) {
+                double totalDailySupply = dailyTrend.stream()
+                    .mapToDouble(day -> (double) day.getOrDefault("dailySupply", 0.0))
+                    .sum();
+                double avgDailySupply = totalDailySupply / dailyTrend.size();
+                content.put("avgDailySupply", avgDailySupply);
+            }
+            
+            // 生成摘要
+            Map<String, Object> summary = new LinkedHashMap<>();
+            summary.put("totalSupply", waterVolumeData.get("totalSupply"));
+            summary.put("avgDailySupply", content.get("avgDailySupply"));
+            summary.put("areaCount", ((List<?>) waterVolumeData.get("areaSupplyStats")).size());
+            
+            report.setContent(content);
+            report.setSummary(summary);
+            report.setStatus("GENERATED");
+            report.setGeneratedBy("bot_dev1");
+            
+            reportMapper.insert(report);
+            
+            log.info("生成水量汇总报表成功: reportCode={}, period={}", report.getReportCode(), period);
+            
+            return report;
+            
+        } catch (Exception e) {
+            log.error("生成水量汇总报表失败: {}", e.getMessage());
+            throw new RuntimeException("水量汇总报表生成失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 生成水质合格率报表
+     */
+    public DataReport generateWaterQualityReport(String period, String startTime, String endTime) {
+        DataReport report = new DataReport();
+        report.setReportName("水质合格率报表");
+        report.setReportCode("WATER-QUAL-" + System.currentTimeMillis());
+        report.setReportType("water_quality");
+        report.setDataType("water_quality");
+        report.setArea("ALL");
+        
+        try {
+            // 设置时间范围
+            LocalDate start = startTime != null ? LocalDate.parse(startTime.substring(0, 10)) : LocalDate.now().minusDays(7);
+            LocalDate end = endTime != null ? LocalDate.parse(endTime.substring(0, 10)) : LocalDate.now();
+            report.setPeriodStart(start);
+            report.setPeriodEnd(end);
+            
+            // 获取水质合格率数据
+            Map<String, Object> qualityData = dataStatisticsService.getWaterQualityRate(startTime, endTime);
+            
+            Map<String, Object> content = new LinkedHashMap<>();
+            content.put("generatedAt", LocalDateTime.now());
+            content.put("period", period);
+            content.put("startTime", startTime);
+            content.put("endTime", endTime);
+            
+            // 基础统计
+            content.put("totalTests", qualityData.get("totalTests"));
+            content.put("passedTests", qualityData.get("passedTests"));
+            content.put("passRate", qualityData.get("passRate"));
+            
+            // 分区域合格率
+            content.put("areaQualityStats", qualityData.get("areaQualityStats"));
+            
+            // 生成摘要
+            Map<String, Object> summary = new LinkedHashMap<>();
+            summary.put("totalTests", qualityData.get("totalTests"));
+            summary.put("passedTests", qualityData.get("passedTests"));
+            summary.put("passRate", qualityData.get("passRate"));
+            summary.put("areaCount", ((List<?>) qualityData.get("areaQualityStats")).size());
+            
+            report.setContent(content);
+            report.setSummary(summary);
+            report.setStatus("GENERATED");
+            report.setGeneratedBy("bot_dev1");
+            
+            reportMapper.insert(report);
+            
+            log.info("生成水质合格率报表成功: reportCode={}, period={}", report.getReportCode(), period);
+            
+            return report;
+            
+        } catch (Exception e) {
+            log.error("生成水质合格率报表失败: {}", e.getMessage());
+            throw new RuntimeException("水质合格率报表生成失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 生成报警统计报表
+     */
+    public DataReport generateAlarmStatisticsReport(String period, String startTime, String endTime) {
+        DataReport report = new DataReport();
+        report.setReportName("报警统计报表");
+        report.setReportCode("ALARM-STAT-" + System.currentTimeMillis());
+        report.setReportType("alarm_statistics");
+        report.setDataType("alarm");
+        report.setArea("ALL");
+        
+        try {
+            // 设置时间范围
+            LocalDate start = startTime != null ? LocalDate.parse(startTime.substring(0, 10)) : LocalDate.now().minusDays(7);
+            LocalDate end = endTime != null ? LocalDate.parse(endTime.substring(0, 10)) : LocalDate.now();
+            report.setPeriodStart(start);
+            report.setPeriodEnd(end);
+            
+            // 获取报警统计数据
+            Map<String, Object> alarmData = dataStatisticsService.getAlarmStatistics(startTime, endTime);
+            
+            Map<String, Object> content = new LinkedHashMap<>();
+            content.put("generatedAt", LocalDateTime.now());
+            content.put("period", period);
+            content.put("startTime", startTime);
+            content.put("endTime", endTime);
+            
+            // 基础统计
+            content.put("totalAlarms", alarmData.get("totalAlarms"));
+            
+            // 按级别统计
+            content.put("levelStatistics", alarmData.get("levelStatistics"));
+            
+            // 按区域统计
+            content.put("areaAlarmStats", alarmData.get("areaAlarmStats"));
+            
+            // 每日趋势
+            content.put("dailyAlarmTrend", alarmData.get("dailyAlarmTrend"));
+            
+            // 计算最严重区域
+            List<Map<String, Object>> areaStats = (List<Map<String, Object>>) alarmData.get("areaAlarmStats");
+            if (areaStats != null && !areaStats.isEmpty()) {
+                String worstArea = areaStats.stream()
+                    .max(Comparator.comparingInt(area -> (int) area.get("alarmCount")))
+                    .map(area -> (String) area.get("area"))
+                    .orElse("N/A");
+                content.put("worstArea", worstArea);
+            }
+            
+            // 生成摘要
+            Map<String, Object> summary = new LinkedHashMap<>();
+            summary.put("totalAlarms", alarmData.get("totalAlarms"));
+            summary.put("areaCount", areaStats != null ? areaStats.size() : 0);
+            summary.put("worstArea", content.get("worstArea"));
+            
+            report.setContent(content);
+            report.setSummary(summary);
+            report.setStatus("GENERATED");
+            report.setGeneratedBy("bot_dev1");
+            
+            reportMapper.insert(report);
+            
+            log.info("生成报警统计报表成功: reportCode={}, period={}", report.getReportCode(), period);
+            
+            return report;
+            
+        } catch (Exception e) {
+            log.error("生成报警统计报表失败: {}", e.getMessage());
+            throw new RuntimeException("报警统计报表生成失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 生成综合报表（包含所有类型）
+     */
+    public DataReport generateComprehensiveReport(String period, String startTime, String endTime) {
+        DataReport report = new DataReport();
+        report.setReportName("综合数据报表");
+        report.setReportCode("COMP-" + System.currentTimeMillis());
+        report.setReportType("comprehensive");
+        report.setDataType("all");
+        report.setArea("ALL");
+        
+        try {
+            // 设置时间范围
+            LocalDate start = startTime != null ? LocalDate.parse(startTime.substring(0, 10)) : LocalDate.now().minusDays(7);
+            LocalDate end = endTime != null ? LocalDate.parse(endTime.substring(0, 10)) : LocalDate.now();
+            report.setPeriodStart(start);
+            report.setPeriodEnd(end);
+            
+            // 获取各类数据
+            Map<String, Object> waterVolumeData = dataStatisticsService.getWaterVolumeSummary(startTime, endTime);
+            Map<String, Object> qualityData = dataStatisticsService.getWaterQualityRate(startTime, endTime);
+            Map<String, Object> alarmData = dataStatisticsService.getAlarmStatistics(startTime, endTime);
+            
+            Map<String, Object> content = new LinkedHashMap<>();
+            content.put("generatedAt", LocalDateTime.now());
+            content.put("period", period);
+            content.put("startTime", startTime);
+            content.put("endTime", endTime);
+            
+            // 水量汇总
+            Map<String, Object> waterSection = new LinkedHashMap<>();
+            waterSection.put("totalWaterSupply", waterVolumeData.get("totalSupply"));
+            waterSection.put("avgDailySupply", waterVolumeData.get("avgDailySupply"));
+            waterSection.put("areaWaterSupply", waterVolumeData.get("areaSupplyStats"));
+            content.put("waterVolumeSummary", waterSection);
+            
+            // 水质分析
+            Map<String, Object> qualitySection = new LinkedHashMap<>();
+            qualitySection.put("totalTests", qualityData.get("totalTests"));
+            qualitySection.put("passedTests", qualityData.get("passedTests"));
+            qualitySection.put("passRate", qualityData.get("passRate"));
+            qualitySection.put("areaQualityStats", qualityData.get("areaQualityStats"));
+            content.put("waterQualityAnalysis", qualitySection);
+            
+            // 报警统计
+            Map<String, Object> alarmSection = new LinkedHashMap<>();
+            alarmSection.put("totalAlarms", alarmData.get("totalAlarms"));
+            alarmSection.put("levelStatistics", alarmData.get("levelStatistics"));
+            alarmSection.put("areaAlarmStats", alarmData.get("areaAlarmStats"));
+            alarmSection.put("dailyAlarmTrend", alarmData.get("dailyAlarmTrend"));
+            content.put("alarmStatistics", alarmSection);
+            
+            // 综合评估
+            Map<String, Object> assessment = new LinkedHashMap<>();
+            assessment.put("overallRating", calculateOverallRating(waterVolumeData, qualityData, alarmData));
+            assessment.put("recommendations", generateRecommendations(waterVolumeData, qualityData, alarmData));
+            content.put("comprehensiveAssessment", assessment);
+            
+            // 生成摘要
+            Map<String, Object> summary = new LinkedHashMap<>();
+            summary.put("totalWaterSupply", waterVolumeData.get("totalSupply"));
+            summary.put("avgWaterQuality", qualityData.get("passRate"));
+            summary.put("totalAlarms", alarmData.get("totalAlarms"));
+            summary.put("overallRating", assessment.get("overallRating"));
+            
+            report.setContent(content);
+            report.setSummary(summary);
+            report.setStatus("GENERATED");
+            report.setGeneratedBy("bot_dev1");
+            
+            reportMapper.insert(report);
+            
+            log.info("生成综合报表成功: reportCode={}, period={}", report.getReportCode(), period);
+            
+            return report;
+            
+        } catch (Exception e) {
+            log.error("生成综合报表失败: {}", e.getMessage());
+            throw new RuntimeException("综合报表生成失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 自动生成报表（原有功能保留）
      */
     public DataReport generateReport(String reportType, String period) {
         DataReport report = new DataReport();
@@ -67,6 +352,73 @@ public class ReportService {
         reportMapper.insert(report);
         return report;
     }
+    
+    /**
+     * 计算综合评分
+     */
+    private String calculateOverallRating(Map<String, Object> waterData, Map<String, Object> qualityData, Map<String, Object> alarmData) {
+        double waterScore = calculateWaterScore(waterData);
+        double qualityScore = calculateQualityScore(qualityData);
+        double alarmScore = calculateAlarmScore(alarmData);
+        
+        double totalScore = (waterScore + qualityScore + alarmScore) / 3;
+        
+        if (totalScore >= 90) return "优秀";
+        if (totalScore >= 80) return "良好";
+        if (totalScore >= 70) return "一般";
+        if (totalScore >= 60) return "较差";
+        return "差";
+    }
+    
+    private double calculateWaterScore(Map<String, Object> waterData) {
+        Double totalSupply = (Double) waterData.getOrDefault("totalSupply", 0.0);
+        // 这里可以根据实际业务逻辑计算水量分数
+        return Math.min(100, totalSupply / 50000 * 100); // 假设5万为满分
+    }
+    
+    private double calculateQualityScore(Map<String, Object> qualityData) {
+        String passRateStr = (String) qualityData.getOrDefault("passRate", "0%");
+        double passRate = Double.parseDouble(passRateStr.replace("%", ""));
+        return passRate; // 水质合格率直接作为分数
+    }
+    
+    private double calculateAlarmScore(Map<String, Object> alarmData) {
+        Integer totalAlarms = (Integer) alarmData.getOrDefault("totalAlarms", 0);
+        // 报警越少分数越高
+        return Math.max(0, 100 - totalAlarms * 2);
+    }
+    
+    /**
+     * 生成改进建议
+     */
+    private List<String> generateRecommendations(Map<String, Object> waterData, Map<String, Object> qualityData, Map<String, Object> alarmData) {
+        List<String> recommendations = new ArrayList<>();
+        
+        // 基于水量数据的建议
+        Double totalSupply = (Double) waterData.getOrDefault("totalSupply", 0.0);
+        if (totalSupply < 30000) {
+            recommendations.add("建议增加供水能力，当前供水量偏低");
+        }
+        
+        // 基于水质数据的建议
+        String passRateStr = (String) qualityData.getOrDefault("passRate", "0%");
+        double passRate = Double.parseDouble(passRateStr.replace("%", ""));
+        if (passRate < 95) {
+            recommendations.add("建议加强水质监测和处理，当前合格率偏低");
+        }
+        
+        // 基于报警数据的建议
+        Integer totalAlarms = (Integer) alarmData.getOrDefault("totalAlarms", 0);
+        if (totalAlarms > 20) {
+            recommendations.add("建议检查设备状态，报警频率过高");
+        }
+        
+        if (recommendations.isEmpty()) {
+            recommendations.add("运行状态良好，继续保持");
+        }
+        
+        return recommendations;
+    }
 
     /**
      * 获取报表列表
@@ -95,6 +447,16 @@ public class ReportService {
         report.setPublishedTime(LocalDateTime.now());
         reportMapper.updateById(report);
     }
+    
+    /**
+     * 获取报表ID（从报表代码）
+     */
+    public Long getReportIdByCode(String reportCode) {
+        LambdaQueryWrapper<DataReport> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(DataReport::getReportCode, reportCode);
+        DataReport report = reportMapper.selectOne(wrapper);
+        return report != null ? report.getId() : null;
+    }
 
     /**
      * 模板管理