feat: 实现 Issue 13 - 数据中心与配置中心功能

- DATA-01 数据查看：自动监测数据+人工填报数据统一查看，只读不可修改；图表/报表形式展示，支持历史回溯
- DATA-02 设备管理：供水工程设备列表，按设备名称/类型/运行时间/位置查询
- DATA-03 阈值管理：水压、流量等各类实时监测数据触发报警阈值设定与编辑
- DATA-04 信息发布：预报发布、预警发布，支持上级单位/上游水库信息发布，发布后在调度平台同步展示
- DATA-05 报表统计：水量报表、水压报表、流量报表、水质报表、液位报表
- CFG-01 指令配置：配置供水工程调度下发指令，定义常用调度指令内容，用于快速下发
- CFG-02 限值配置：配置管网压力、清水池液位等监测超限数值
- CFG-03 报警方案：新增报警方案（报警名称/通知方案/报警规则/报警级别），关联监测点
- CFG-04 值班安排：值班方案制定/值班班组配置/值班班次配置，按部门管理

技术实现：
- 新增 DataCenterController 统一管理数据中心与配置中心功能
- 新增 DataCenterService 实现核心业务逻辑
- 新增 AlarmSchemeService 实现报警方案管理
- 新增 DutyScheduleService 实现值班安排管理
- 新增相关 DTO、VO、Entity、Mapper 等支持类

#13 #数据中心 #配置中心

wm-production/src/main/java/com/water/production/controller/DataCenterController.java

+package com.water.production.controller;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.water.common.core.result.R;
+import com.water.production.dto.DataCenterQueryRequest;
+import com.water.production.dto.DataExportRequest;
+import com.water.production.entity.AlarmScheme;
+import com.water.production.entity.DispatchCommand;
+import com.water.production.entity.Threshold;
+import com.water.production.service.*;
+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.time.LocalDate;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 数据中心与配置中心 Controller
+ * 对应 Issue 13: 供水生产管理平台 — 数据中心与配置中心
+ */
+@Tag(name = "数据中心与配置中心")
+@RestController
+@RequestMapping("/api/production/data-center")
+@RequiredArgsConstructor
+public class DataCenterController {
+
+    private final MonitorListService monitorListService;
+    private final DataCenterService dataCenterService;
+    private final ThresholdService thresholdService;
+    private final AlarmSchemeService alarmSchemeService;
+    private final DispatchCommandService dispatchCommandService;
+    private final DutyScheduleService dutyScheduleService;
+
+    // ========== DATA-01 数据查看 ==========
+    @Operation(summary = "自动+人工数据统一查看（只读）")
+    @GetMapping("/data-view")
+    public R<Map<String, Object>> dataView(DataCenterQueryRequest request) {
+        Map<String, Object> dataView = dataCenterService.getDataView(request);
+        return R.ok(dataView);
+    }
+
+    @Operation(summary = "获取历史数据（支持回溯）")
+    @GetMapping("/history")
+    public R<List<Map<String, Object>>> getHistoryData(
+            @RequestParam String dataType,
+            @RequestParam(required = false) String area,
+            @RequestParam String startTime,
+            @RequestParam String endTime) {
+        List<Map<String, Object>> historyData = dataCenterService.getHistoryData(dataType, area, startTime, endTime);
+        return R.ok(historyData);
+    }
+
+    @Operation(summary = "数据图表展示")
+    @GetMapping("/charts")
+    public R<Map<String, Object>> getChartData(
+            @RequestParam String chartType,
+            @RequestParam String period,
+            @RequestParam(required = false) String area,
+            @RequestParam(required = false) String deviceType) {
+        Map<String, Object> chartData = dataCenterService.getChartData(chartType, period, area, deviceType);
+        return R.ok(chartData);
+    }
+
+    // ========== DATA-02 设备管理 ==========
+    @Operation(summary = "设备列表（按名称/类型/时间/位置查询）")
+    @GetMapping("/devices")
+    public R<Page<Map<String, Object>>> listDevices(
+            @RequestParam(defaultValue = "1") int page,
+            @RequestParam(defaultValue = "10") int size,
+            @RequestParam(required = false) String deviceName,
+            @RequestParam(required = false) String deviceType,
+            @RequestParam(required = false) String area,
+            @RequestParam(required = false) String location,
+            @RequestParam(required = false) String status) {
+        Map<String, Object> deviceList = monitorListService.queryDeviceList(
+                deviceName, deviceType, area, location, status, page, size);
+        return R.ok((Page<Map<String, Object>>) deviceList.get("records"));
+    }
+
+    @Operation(summary = "设备详情")
+    @GetMapping("/devices/{deviceId}")
+    public R<Map<String, Object>> deviceDetail(@PathVariable Long deviceId) {
+        Map<String, Object> detail = monitorListService.getDeviceDetail(deviceId);
+        return R.ok(detail);
+    }
+
+    @Operation(summary = "获取设备类型列表")
+    @GetMapping("/device-types")
+    public R<List<String>> getDeviceTypes() {
+        return R.ok(monitorListService.getDeviceTypeList());
+    }
+
+    @Operation(summary = "获取区域列表")
+    @GetMapping("/areas")
+    public R<List<String>> getAreas() {
+        return R.ok(monitorListService.getAreaList());
+    }
+
+    // ========== DATA-03 阈值管理 ==========
+    @Operation(summary = "阈值配置列表")
+    @GetMapping("/thresholds")
+    public R<Page<Threshold>> getThresholds(
+            @RequestParam(defaultValue = "1") int page,
+            @RequestParam(defaultValue = "10") int size,
+            @RequestParam(required = false) String metricKey,
+            @RequestParam(required = false) String area) {
+        return R.ok(thresholdService.pageThresholds(page, size, metricKey, area));
+    }
+
+    @Operation(summary = "获取阈值详情")
+    @GetMapping("/thresholds/{id}")
+    public R<Threshold> getThresholdDetail(@PathVariable Long id) {
+        return R.ok(thresholdService.getThresholdById(id));
+    }
+
+    @Operation(summary = "创建阈值配置")
+    @PostMapping("/thresholds")
+    public R<Threshold> createThreshold(@RequestBody Threshold threshold) {
+        return R.ok(thresholdService.createThreshold(threshold));
+    }
+
+    @Operation(summary = "更新阈值配置")
+    @PutMapping("/thresholds/{id}")
+    public R<String> updateThreshold(@PathVariable Long id, @RequestBody Threshold threshold) {
+        thresholdService.updateThreshold(threshold);
+        return R.ok("更新成功");
+    }
+
+    @Operation(summary = "删除阈值配置")
+    @DeleteMapping("/thresholds/{id}")
+    public R<String> deleteThreshold(@PathVariable Long id) {
+        thresholdService.deleteThreshold(id);
+        return R.ok("删除成功");
+    }
+
+    // ========== DATA-04 信息发布 ==========
+    @Operation(summary = "发布预报信息")
+    @PostMapping("/forecast/publish")
+    public R<String> publishForecast(@RequestParam String title,
+                                    @RequestParam String content,
+                                    @RequestParam(required = false) String area,
+                                    @RequestParam Long publisherId) {
+        dataCenterService.publishForecast(title, content, area, publisherId);
+        return R.ok("预报已发布");
+    }
+
+    @Operation(summary = "发布预警信息")
+    @PostMapping("/warning/publish")
+    public R<String> publishWarning(@RequestParam String title,
+                                   @RequestParam String content,
+                                   @RequestParam(required = false) String area,
+                                   @RequestParam Long publisherId) {
+        dataCenterService.publishWarning(title, content, area, publisherId);
+        return R.ok("预警已发布");
+    }
+
+    @Operation(summary = "获取信息发布列表")
+    @GetMapping("/info-releases")
+    public R<List<Map<String, Object>>> getInfoReleases(
+            @RequestParam(required = false) String type,
+            @RequestParam(required = false) String area) {
+        List<Map<String, Object>> releases = dataCenterService.getInfoReleases(type, area);
+        return R.ok(releases);
+    }
+
+    // ========== DATA-05 报表统计 ==========
+    @Operation(summary = "水量报表")
+    @GetMapping("/reports/water-volume")
+    public R<Map<String, Object>> getWaterVolumeReport(
+            @RequestParam String period,
+            @RequestParam(required = false) String area) {
+        Map<String, Object> report = dataCenterService.generateReport("water_volume", period, area);
+        return R.ok(report);
+    }
+
+    @Operation(summary = "水压报表")
+    @GetMapping("/reports/water-pressure")
+    public R<Map<String, Object>> getWaterPressureReport(
+            @RequestParam String period,
+            @RequestParam(required = false) String area) {
+        Map<String, Object> report = dataCenterService.generateReport("water_pressure", period, area);
+        return R.ok(report);
+    }
+
+    @Operation(summary = "流量报表")
+    @GetMapping("/reports/flow-rate")
+    public R<Map<String, Object>> getFlowRateReport(
+            @RequestParam String period,
+            @RequestParam(required = false) String area) {
+        Map<String, Object> report = dataCenterService.generateReport("flow_rate", period, area);
+        return R.ok(report);
+    }
+
+    @Operation(summary = "水质报表")
+    @GetMapping("/reports/water-quality")
+    public R<Map<String, Object>> getWaterQualityReport(
+            @RequestParam String period,
+            @RequestParam(required = false) String area) {
+        Map<String, Object> report = dataCenterService.generateReport("water_quality", period, area);
+        return R.ok(report);
+    }
+
+    @Operation(summary = "液位报表")
+    @GetMapping("/reports/water-level")
+    public R<Map<String, Object>> getWaterLevelReport(
+            @RequestParam String period,
+            @RequestParam(required = false) String area) {
+        Map<String, Object> report = dataCenterService.generateReport("water_level", period, area);
+        return R.ok(report);
+    }
+
+    // ========== CFG-01 指令配置 ==========
+    @Operation(summary = "调度指令配置列表")
+    @GetMapping("/command-templates")
+    public R<List<DispatchCommand>> getCommandTemplates() {
+        return R.ok(dispatchCommandService.getTemplates());
+    }
+
+    @Operation(summary = "创建指令模板")
+    @PostMapping("/command-templates")
+    public R<DispatchCommand> createCommandTemplate(@RequestBody DispatchCommand command) {
+        command.setTemplate(true);
+        return R.ok(dispatchCommandService.createCommand(command));
+    }
+
+    @Operation(summary = "更新指令模板")
+    @PutMapping("/command-templates/{id}")
+    public R<String> updateCommandTemplate(@PathVariable Long id, @RequestBody DispatchCommand command) {
+        command.setId(id);
+        command.setTemplate(true);
+        dispatchCommandService.updateCommand(command);
+        return R.ok("更新成功");
+    }
+
+    @Operation(summary = "使用模板快速创建指令")
+    @PostMapping("/command-templates/{id}/use")
+    public R<DispatchCommand> useTemplate(@PathVariable Long id,
+                                          @RequestParam Long issuedBy,
+                                          @RequestParam(required = false) String remark) {
+        DispatchCommand template = dispatchCommandService.getCommandById(id);
+        DispatchCommand command = dispatchCommandService.createFromTemplate(template, issuedBy, remark);
+        return R.ok(command);
+    }
+
+    // ========== CFG-02 限值配置 ==========
+    @Operation(summary = "获取所有限值配置")
+    @GetMapping("/limit-configs")
+    public R<Map<String, Object>> getLimitConfigs() {
+        Map<String, Object> configs = dataCenterService.getAllLimitConfigs();
+        return R.ok(configs);
+    }
+
+    @Operation(summary = "更新管网压力限值")
+    @PutMapping("/limit-configs/pressure")
+    public R<String> updatePressureLimits(@RequestParam String area,
+                                         @RequestParam Double minPressure,
+                                         @RequestParam Double maxPressure) {
+        dataCenterService.updatePressureLimits(area, minPressure, maxPressure);
+        return R.ok("压力限值已更新");
+    }
+
+    @Operation(summary = "更新清水池液位限值")
+    @PutMapping("/limit-configs/level")
+    public R<String> updateLevelLimits(@RequestParam String area,
+                                       @RequestParam Double minLevel,
+                                       @RequestParam Double maxLevel) {
+        dataCenterService.updateLevelLimits(area, minLevel, maxLevel);
+        return R.ok("液位限值已更新");
+    }
+
+    // ========== CFG-03 报警方案 ==========
+    @Operation(summary = "报警方案列表")
+    @GetMapping("/alarm-schemes")
+    public R<Page<AlarmScheme>> getAlarmSchemes(
+            @RequestParam(defaultValue = "1") int page,
+            @RequestParam(defaultValue = "10") int size,
+            @RequestParam(required = false) String alarmName,
+            @RequestParam(required = false) String alarmLevel) {
+        return R.ok(alarmSchemeService.pageSchemes(page, size, alarmName, alarmLevel));
+    }
+
+    @Operation(summary = "创建报警方案")
+    @PostMapping("/alarm-schemes")
+    public R<AlarmScheme> createAlarmScheme(@RequestBody AlarmScheme scheme) {
+        return R.ok(alarmSchemeService.createScheme(scheme));
+    }
+
+    @Operation(summary = "更新报警方案")
+    @PutMapping("/alarm-schemes/{id}")
+    public R<String> updateAlarmScheme(@PathVariable Long id, @RequestBody AlarmScheme scheme) {
+        alarmSchemeService.updateScheme(id, scheme);
+        return R.ok("更新成功");
+    }
+
+    @Operation(summary = "删除报警方案")
+    @DeleteMapping("/alarm-schemes/{id}")
+    public R<String> deleteAlarmScheme(@PathVariable Long id) {
+        alarmSchemeService.deleteScheme(id);
+        return R.ok("删除成功");
+    }
+
+    // ========== CFG-04 值班安排 ==========
+    @Operation(summary = "值班方案列表")
+    @GetMapping("/duty-schemes")
+    public R<List<Map<String, Object>>> getDutySchemes() {
+        List<Map<String, Object>> schemes = dutyScheduleService.getDutySchemes();
+        return R.ok(schemes);
+    }
+
+    @Operation(summary = "创建值班方案")
+    @PostMapping("/duty-schemes")
+    public R<Map<String, Object>> createDutyScheme(@RequestBody Map<String, Object> scheme) {
+        Map<String, Object> result = dutyScheduleService.createDutyScheme(scheme);
+        return R.ok(result);
+    }
+
+    @Operation(summary = "值班班次配置")
+    @GetMapping("/duty-shifts")
+    public R<List<Map<String, Object>>> getDutyShifts() {
+        List<Map<String, Object>> shifts = dutyScheduleService.getDutyShifts();
+        return R.ok(shifts);
+    }
+
+    @Operation(summary = "创建值班班次")
+    @PostMapping("/duty-shifts")
+    public R<Map<String, Object>> createDutyShift(@RequestBody Map<String, Object> shift) {
+        Map<String, Object> result = dutyScheduleService.createDutyShift(shift);
+        return R.ok(result);
+    }
+
+    @Operation(summary = "获取今日值班安排")
+    @GetMapping("/duty/today")
+    public R<List<Map<String, Object>>> getTodayDuty() {
+        List<Map<String, Object>> todayDuty = dutyScheduleService.getTodayDuty();
+        return R.ok(todayDuty);
+    }
+
+    @Operation(summary = "值班安排（按日期）")
+    @GetMapping("/duty/schedule")
+    public R<List<Map<String, Object>>> getDutySchedule(
+            @RequestParam LocalDate date,
+            @RequestParam(required = false) String shiftType) {
+        List<Map<String, Object>> schedule = dutyScheduleService.getDutyScheduleByDate(date, shiftType);
+        return R.ok(schedule);
+    }
+
+    // ========== 数据导出 ==========
+    @Operation(summary = "导出数据报表")
+    @PostMapping("/export")
+    public R<byte[]> exportData(@RequestBody DataExportRequest request) {
+        byte[] data = dataCenterService.exportData(request);
+        return R.ok(data);
+    }
+
+    // ========== 统计概览 ==========
+    @Operation(summary = "数据中心概览统计")
+    @GetMapping("/overview")
+    public R<Map<String, Object>> getDataCenterOverview() {
+        Map<String, Object> overview = dataCenterService.getOverview();
+        return R.ok(overview);
+    }
+}

wm-production/src/main/java/com/water/production/dto/DataCenterQueryRequest.java

+package com.water.production.dto;
+
+import lombok.Data;
+import java.time.LocalDateTime;
+
+/**
+ * 数据中心查询请求
+ * 对应 Issue 13: 供水生产管理平台 — 数据中心与配置中心
+ */
+@Data
+public class DataCenterQueryRequest {
+    
+    /** 查询区域 */
+    private String area;
+    
+    /** 设备类型 */
+    private String deviceType;
+    
+    /** 数据类型 */
+    private String dataType;
+    
+    /** 开始时间 */
+    private LocalDateTime startTime;
+    
+    /** 结束时间 */
+    private LocalDateTime endTime;
+    
+    /** 关键字搜索 */
+    private String keyword;
+    
+    /** 设备状态 */
+    private String status;
+    
+    /** 报警级别 */
+    private String alertLevel;
+    
+    /** 页码 */
+    private Integer page = 1;
+    
+    /** 页大小 */
+    private Integer size = 10;
+    
+    /** 排序字段 */
+    private String sortBy = "created_at";
+    
+    /** 排序方向 */
+    private String sortOrder = "desc";
+}

wm-production/src/main/java/com/water/production/dto/DataExportRequest.java

+package com.water.production.dto;
+
+import lombok.Data;
+import java.time.LocalDateTime;
+
+/**
+ * 数据导出请求
+ * 对应 Issue 13: 供水生产管理平台 — 数据中心与配置中心
+ */
+@Data
+public class DataExportRequest {
+    
+    /** 导出类型 */
+    private String exportType = "excel";
+    
+    /** 区域 */
+    private String area;
+    
+    /** 设备类型 */
+    private String deviceType;
+    
+    /** 数据类型 */
+    private String dataType;
+    
+    /** 开始时间 */
+    private LocalDateTime startTime;
+    
+    /** 结束时间 */
+    private LocalDateTime endTime;
+    
+    /** 报表类型 */
+    private String reportType;
+    
+    /** 时间周期 */
+    private String period;
+    
+    /** 包含图表 */
+    private Boolean includeCharts = false;
+    
+    /** 文件名 */
+    private String fileName;
+    
+    /** 模板ID */
+    private Long templateId;
+}

wm-production/src/main/java/com/water/production/entity/AlarmScheme.java

+package com.water.production.entity;
+
+import com.baomidou.mybatisplus.annotation.*;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 报警方案
+ * 对应 Issue 13: CFG-03 报警方案
+ */
+@Data
+@TableName("prod_alarm_scheme")
+public class AlarmScheme {
+    
+    @TableId(type = IdType.AUTO)
+    private Long id;
+    
+    /** 报警方案名称 */
+    private String schemeName;
+    
+    /** 报警级别 */
+    private String alertLevel;
+    
+    /** 方案描述 */
+    private String description;
+    
+    /** 通知方案ID */
+    private Long notificationSchemeId;
+    
+    /** 报警规则JSON */
+    private String ruleJson;
+    
+    /** 关联监测点（逗号分隔的设备ID） */
+    private String deviceIds;
+    
+    /** 关联区域 */
+    private String area;
+    
+    /** 是否启用 */
+    private Boolean enabled = true;
+    
+    /** 创建人ID */
+    private Long createdBy;
+    
+    /** 创建人姓名 */
+    private String createdByName;
+    
+    /** 创建时间 */
+    private LocalDateTime createdAt;
+    
+    /** 更新人ID */
+    private Long updatedBy;
+    
+    /** 更新人姓名 */
+    private String updatedByName;
+    
+    /** 更新时间 */
+    private LocalDateTime updatedAt;
+    
+    /** 备注 */
+    private String remark;
+}

wm-production/src/main/java/com/water/production/mapper/AlarmSchemeMapper.java

+package com.water.production.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.production.entity.AlarmScheme;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 报警方案 Mapper
+ * 对应 Issue 13: CFG-03 报警方案
+ */
+@Mapper
+public interface AlarmSchemeMapper extends BaseMapper<AlarmScheme> {
+    
+}

wm-production/src/main/java/com/water/production/service/AlarmSchemeService.java

+package com.water.production.service;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.water.production.entity.AlarmScheme;
+import com.water.production.vo.AlarmSchemeQueryVO;
+import java.util.List;
+
+/**
+ * 报警方案服务接口
+ * 对应 Issue 13: CFG-03 报警方案
+ */
+public interface AlarmSchemeService {
+    
+    /**
+     * 创建报警方案
+     */
+    AlarmScheme createScheme(AlarmScheme scheme);
+    
+    /**
+     * 更新报警方案
+     */
+    void updateScheme(Long id, AlarmScheme scheme);
+    
+    /**
+     * 删除报警方案
+     */
+    void deleteScheme(Long id);
+    
+    /**
+     * 获取报警方案详情
+     */
+    AlarmScheme getSchemeById(Long id);
+    
+    /**
+     * 分页查询报警方案
+     */
+    Page<AlarmScheme> pageSchemes(int page, int size, String alarmName, String alertLevel);
+    
+    /**
+     * 根据查询条件获取报警方案列表
+     */
+    List<AlarmScheme> getSchemesByQuery(AlarmSchemeQueryVO queryVO);
+    
+    /**
+     * 启用/禁用报警方案
+     */
+    void toggleSchemeStatus(Long id, Boolean enabled);
+    
+    /**
+     * 根据区域获取报警方案
+     */
+    List<AlarmScheme> getSchemesByArea(String area);
+    
+    /**
+     * 根据设备ID获取关联的报警方案
+     */
+    List<AlarmScheme> getSchemesByDeviceId(Long deviceId);
+    
+    /**
+     * 复制报警方案
+     */
+    AlarmScheme copyScheme(Long id);
+}

wm-production/src/main/java/com/water/production/service/DutyScheduleService.java

+package com.water.production.service;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.water.production.entity.DutySchedule;
+import com.water.production.vo.DutyScheduleQueryVO;
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 值班安排服务接口
+ * 对应 Issue 13: CFG-04 值班安排
+ */
+public interface DutyScheduleService {
+    
+    /**
+     * 创建值班安排
+     */
+    DutySchedule createDutySchedule(DutySchedule schedule);
+    
+    /**
+     * 更新值班安排
+     */
+    void updateDutySchedule(DutySchedule schedule);
+    
+    /**
+     * 删除值班安排
+     */
+    void deleteDutySchedule(Long id);
+    
+    /**
+     * 获取值班安排详情
+     */
+    DutySchedule getDutyScheduleById(Long id);
+    
+    /**
+     * 分页查询值班安排
+     */
+    Page<DutySchedule> pageDutySchedules(DutyScheduleQueryVO queryVO);
+    
+    /**
+     * 获取今日值班安排
+     */
+    List<DutySchedule> getTodayDutySchedules();
+    
+    /**
+     * 根据日期获取值班安排
+     */
+    List<DutySchedule> getDutySchedulesByDate(LocalDate date);
+    
+    /**
+     * 根据日期和班次类型获取值班安排
+     */
+    List<DutySchedule> getDutySchedulesByDateAndShift(LocalDate date, String shiftType);
+    
+    /**
+     * 获取值班人员列表
+     */
+    List<Map<String, Object>> getDutyPersonnel();
+    
+    /**
+     * 获取值班方案列表
+     */
+    List<Map<String, Object>> getDutySchemes();
+    
+    /**
+     * 创建值班方案
+     */
+    Map<String, Object> createDutyScheme(Map<String, Object> scheme);
+    
+    /**
+     * 获取值班班次配置
+     */
+    List<Map<String, Object>> getDutyShifts();
+    
+    /**
+     * 创建值班班次
+     */
+    Map<String, Object> createDutyShift(Map<String, Object> shift);
+    
+    /**
+     * 启用/禁用值班安排
+     */
+    void toggleDutyScheduleStatus(Long id, Integer status);
+    
+    /**
+     * 检查时间冲突
+     */
+    boolean hasTimeConflict(Long userId, LocalDate date, String shiftType, Long excludeId);
+    
+    /**
+     * 获取值班统计
+     */
+    Map<String, Object> getDutyStatistics(LocalDate startDate, LocalDate endDate);
+}

wm-production/src/main/java/com/water/production/service/impl/AlarmSchemeServiceImpl.java

+package com.water.production.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.water.production.entity.AlarmScheme;
+import com.water.production.mapper.AlarmSchemeMapper;
+import com.water.production.service.AlarmSchemeService;
+import com.water.production.vo.AlarmSchemeQueryVO;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * 报警方案服务实现
+ * 对应 Issue 13: CFG-03 报警方案
+ */
+@Service
+@RequiredArgsConstructor
+public class AlarmSchemeServiceImpl implements AlarmSchemeService {
+
+    private final AlarmSchemeMapper alarmSchemeMapper;
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public AlarmScheme createScheme(AlarmScheme scheme) {
+        scheme.setCreatedAt(LocalDateTime.now());
+        scheme.setUpdatedAt(LocalDateTime.now());
+        alarmSchemeMapper.insert(scheme);
+        return scheme;
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void updateScheme(Long id, AlarmScheme scheme) {
+        AlarmScheme existingScheme = alarmSchemeMapper.selectById(id);
+        if (existingScheme == null) {
+            throw new RuntimeException("报警方案不存在");
+        }
+        
+        scheme.setId(id);
+        scheme.setUpdatedAt(LocalDateTime.now());
+        alarmSchemeMapper.updateById(scheme);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void deleteScheme(Long id) {
+        AlarmScheme scheme = alarmSchemeMapper.selectById(id);
+        if (scheme == null) {
+            throw new RuntimeException("报警方案不存在");
+        }
+        
+        // 检查是否有关联的报警规则在使用
+        int关联规则数 = alarmSchemeMapper.selectCount(
+            new QueryWrapper<AlarmScheme>()
+                .eq("related_scheme_id", id)
+        );
+        
+        if (关联规则数 > 0) {
+            throw new RuntimeException("该报警方案已被引用，无法删除");
+        }
+        
+        alarmSchemeMapper.deleteById(id);
+    }
+
+    @Override
+    public AlarmScheme getSchemeById(Long id) {
+        return alarmSchemeMapper.selectById(id);
+    }
+
+    @Override
+    public Page<AlarmScheme> pageSchemes(int page, int size, String alarmName, String alertLevel) {
+        Page<AlarmScheme> pageParam = new Page<>(page, size);
+        QueryWrapper<AlarmScheme> queryWrapper = new QueryWrapper<>();
+        
+        if (alarmName != null && !alarmName.trim().isEmpty()) {
+            queryWrapper.like("scheme_name", alarmName);
+        }
+        
+        if (alertLevel != null && !alertLevel.trim().isEmpty()) {
+            queryWrapper.eq("alert_level", alertLevel);
+        }
+        
+        queryWrapper.orderByDesc("updated_at");
+        return alarmSchemeMapper.selectPage(pageParam, queryWrapper);
+    }
+
+    @Override
+    public List<AlarmScheme> getSchemesByQuery(AlarmSchemeQueryVO queryVO) {
+        QueryWrapper<AlarmScheme> queryWrapper = new QueryWrapper<>();
+        
+        if (queryVO.getSchemeName() != null && !queryVO.getSchemeName().trim().isEmpty()) {
+            queryWrapper.like("scheme_name", queryVO.getSchemeName());
+        }
+        
+        if (queryVO.getAlertLevel() != null && !queryVO.getAlertLevel().trim().isEmpty()) {
+            queryWrapper.eq("alert_level", queryVO.getAlertLevel());
+        }
+        
+        if (queryVO.getArea() != null && !queryVO.getArea().trim().isEmpty()) {
+            queryWrapper.eq("area", queryVO.getArea());
+        }
+        
+        if (queryVO.getEnabled() != null) {
+            queryWrapper.eq("enabled", queryVO.getEnabled());
+        }
+        
+        queryWrapper.orderByDesc("updated_at");
+        return alarmSchemeMapper.selectList(queryWrapper);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void toggleSchemeStatus(Long id, Boolean enabled) {
+        AlarmScheme scheme = alarmSchemeMapper.selectById(id);
+        if (scheme == null) {
+            throw new RuntimeException("报警方案不存在");
+        }
+        
+        scheme.setEnabled(enabled);
+        scheme.setUpdatedAt(LocalDateTime.now());
+        alarmSchemeMapper.updateById(scheme);
+    }
+
+    @Override
+    public List<AlarmScheme> getSchemesByArea(String area) {
+        QueryWrapper<AlarmScheme> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("area", area);
+        queryWrapper.eq("enabled", true);
+        queryWrapper.orderByDesc("updated_at");
+        return alarmSchemeMapper.selectList(queryWrapper);
+    }
+
+    @Override
+    public List<AlarmScheme> getSchemesByDeviceId(Long deviceId) {
+        QueryWrapper<AlarmScheme> queryWrapper = new QueryWrapper<>();
+        queryWrapper.apply("device_ids LIKE CONCAT('%',{0},'%')", deviceId.toString());
+        queryWrapper.eq("enabled", true);
+        queryWrapper.orderByDesc("updated_at");
+        return alarmSchemeMapper.selectList(queryWrapper);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public AlarmScheme copyScheme(Long id) {
+        AlarmScheme originalScheme = alarmSchemeMapper.selectById(id);
+        if (originalScheme == null) {
+            throw new RuntimeException("原始报警方案不存在");
+        }
+        
+        AlarmScheme newScheme = new AlarmScheme();
+        newScheme.setSchemeName(originalScheme.getSchemeName() + "_copy_" + System.currentTimeMillis());
+        newScheme.setAlertLevel(originalScheme.getAlertLevel());
+        newScheme.setDescription(originalScheme.getDescription());
+        newScheme.setNotificationSchemeId(originalScheme.getNotificationSchemeId());
+        newScheme.setRuleJson(originalScheme.getRuleJson());
+        newScheme.setDeviceIds(originalScheme.getDeviceIds());
+        newScheme.setArea(originalScheme.getArea());
+        newScheme.setEnabled(true);
+        newScheme.setCreatedBy(0L); // 系统复制
+        newScheme.setCreatedByName("系统");
+        newScheme.setRemark("从方案ID:" + id + " 复制");
+        
+        createScheme(newScheme);
+        return newScheme;
+    }
+}

wm-production/src/main/java/com/water/production/service/impl/DataCenterServiceImpl.java

+package com.water.production.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.water.common.core.page.PageResult;
+import com.water.production.dto.DataCenterQueryRequest;
+import com.water.production.dto.DataExportRequest;
+import com.water.production.entity.*;
+import com.water.production.mapper.*;
+import com.water.production.service.DataCenterService;
+import com.water.production.service.MonitorListService;
+import lombok.RequiredArgsConstructor;
+import org.apache.poi.ss.usermodel.*;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.servlet.ServletOutputStream;
+import java.io.ByteArrayOutputStream;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 数据中心服务实现
+ * 对应 Issue 13: 供水生产管理平台 — 数据中心与配置中心
+ */
+@Service
+@RequiredArgsConstructor
+public class DataCenterServiceImpl implements DataCenterService {
+
+    private final JdbcTemplate jdbc;
+    private final MonitorListMapper monitorListMapper;
+    private final ThresholdMapper thresholdMapper;
+    private final AlarmSchemeMapper alarmSchemeMapper;
+    private final DispatchCommandMapper dispatchCommandMapper;
+    private final DutyScheduleMapper dutyScheduleMapper;
+    private final AlarmEventMapper alarmEventMapper;
+    private final WaterQualityRecordMapper waterQualityRecordMapper;
+    private final ReadingMapper readingMapper;
+    private final DeviceMapper deviceMapper;
+
+    @Override
+    public Map<String, Object> getDataView(DataCenterQueryRequest request) {
+        Map<String, Object> result = new LinkedHashMap<>();
+        
+        // 实时数据概览
+        Map<String, Object> realtimeOverview = getRealtimeOverview(request.getArea());
+        result.put("realtimeData", realtimeOverview);
+        
+        // 关键指标
+        Map<String, Object> keyMetrics = getKeyMetrics(request.getArea());
+        result.put("keyMetrics", keyMetrics);
+        
+        // 设备状态统计
+        Map<String, Object> deviceStats = getDeviceStatistics(request.getArea());
+        result.put("deviceStats", deviceStats);
+        
+        // 报警状态
+        Map<String, Object> alertStats = getAlertStatistics(request.getArea());
+        result.put("alertStats", alertStats);
+        
+        result.put("queryTime", LocalDateTime.now());
+        
+        return result;
+    }
+
+    @Override
+    public List<Map<String, Object>> getHistoryData(String dataType, String area, String startTime, String endTime) {
+        String sql = buildHistoryDataSql(dataType, area);
+        return jdbc.queryForList(sql, area, startTime, endTime);
+    }
+
+    @Override
+    public Map<String, Object> getChartData(String chartType, String period, String area, String deviceType) {
+        String sql = buildChartDataSql(chartType, period, area, deviceType);
+        List<Map<String, Object>> data = jdbc.queryForList(sql);
+        
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("chartType", chartType);
+        result.put("period", period);
+        result.put("data", data);
+        result.put("area", area);
+        result.put("deviceType", deviceType);
+        
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> generateReport(String reportType, String period, String area) {
+        Map<String, Object> report = new LinkedHashMap<>();
+        report.put("reportType", reportType);
+        report.put("period", period);
+        report.put("area", area);
+        report.put("generatedAt", LocalDateTime.now());
+        
+        switch (reportType) {
+            case "water_volume":
+                report.put("data", generateWaterVolumeReport(period, area));
+                break;
+            case "water_pressure":
+                report.put("data", generateWaterPressureReport(period, area));
+                break;
+            case "flow_rate":
+                report.put("data", generateFlowRateReport(period, area));
+                break;
+            case "water_quality":
+                report.put("data", generateWaterQualityReport(period, area));
+                break;
+            case "water_level":
+                report.put("data", generateWaterLevelReport(period, area));
+                break;
+            default:
+                report.put("data", new ArrayList<>());
+        }
+        
+        return report;
+    }
+
+    @Override
+    public List<Threshold> getThresholdsByQuery(String area, String metricKey) {
+        QueryWrapper<Threshold> query = new QueryWrapper<>();
+        if (area != null && !area.isEmpty()) {
+            query.eq("area", area);
+        }
+        if (metricKey != null && !metricKey.isEmpty()) {
+            query.eq("metric_key", metricKey);
+        }
+        query.orderByDesc("updated_at");
+        return thresholdMapper.selectList(query);
+    }
+
+    @Override
+    public void updateThreshold(Long id, Double minValue, Double maxValue, String unit) {
+        Threshold threshold = thresholdMapper.selectById(id);
+        if (threshold != null) {
+            threshold.setMinValue(minValue);
+            threshold.setMaxValue(maxValue);
+            threshold.setUnit(unit);
+            threshold.setUpdatedAt(LocalDateTime.now());
+            thresholdMapper.updateById(threshold);
+        }
+    }
+
+    @Override
+    public void publishForecast(String title, String content, String area, Long publisherId) {
+        String sql = "INSERT INTO sys_info_release (type, title, content, area, publisher_id, publish_time, status) " +
+                     "VALUES ('forecast', ?, ?, ?, ?, NOW(), 'published')";
+        jdbc.update(sql, title, content, area, publisherId);
+    }
+
+    @Override
+    public void publishWarning(String title, String content, String area, Long publisherId) {
+        String sql = "INSERT INTO sys_info_release (type, title, content, area, publisher_id, publish_time, status) " +
+                     "VALUES ('warning', ?, ?, ?, ?, NOW(), 'published')";
+        jdbc.update(sql, title, content, area, publisherId);
+    }
+
+    @Override
+    public List<Map<String, Object>> getInfoReleases(String type, String area) {
+        QueryWrapper<InfoRelease> query = new QueryWrapper<>();
+        if (type != null) {
+            query.eq("type", type);
+        }
+        if (area != null && !area.isEmpty()) {
+            query.eq("area", area);
+        }
+        query.orderByDesc("publish_time");
+        
+        return infoReleasesToMap(alarmReleaseMapper.selectList(query));
+    }
+
+    @Override
+    public Map<String, Object> getAllLimitConfigs() {
+        Map<String, Object> configs = new LinkedHashMap<>();
+        
+        // 管网压力限值
+        List<Map<String, Object>> pressureLimits = jdbc.queryForList(
+            "SELECT area, min_pressure, max_pressure, unit FROM sys_pressure_limit WHERE enabled = true"
+        );
+        configs.put("pressureLimits", pressureLimits);
+        
+        // 清水池液位限值
+        List<Map<String, Object>> levelLimits = jdbc.queryForList(
+            "SELECT area, min_level, max_level, unit FROM sys_level_limit WHERE enabled = true"
+        );
+        configs.put("levelLimits", levelLimits);
+        
+        return configs;
+    }
+
+    @Override
+    public void updatePressureLimits(String area, Double minPressure, Double maxPressure) {
+        String sql = "INSERT INTO sys_pressure_limit (area, min_pressure, max_pressure, unit, enabled, updated_at) " +
+                     "VALUES (?, ?, ?, 'MPa', true, NOW()) " +
+                     "ON CONFLICT (area) DO UPDATE SET min_pressure = ?, max_pressure = ?, updated_at = NOW()";
+        jdbc.update(sql, area, minPressure, maxPressure, minPressure, maxPressure);
+    }
+
+    @Override
+    public void updateLevelLimits(String area, Double minLevel, Double maxLevel) {
+        String sql = "INSERT INTO sys_level_limit (area, min_level, max_level, unit, enabled, updated_at) " +
+                     "VALUES (?, ?, ?, 'm', true, NOW()) " +
+                     "ON CONFLICT (area) DO UPDATE SET min_level = ?, max_level = ?, updated_at = NOW()";
+        jdbc.update(sql, area, minLevel, maxLevel, minLevel, maxLevel);
+    }
+
+    @Override
+    public byte[] exportData(DataExportRequest request) {
+        try (Workbook workbook = new XSSFWorkbook()) {
+            Sheet sheet = workbook.createSheet("数据中心数据");
+            
+            // 创建标题行
+            Row headerRow = sheet.createRow(0);
+            String[] headers = {"时间", "区域", "设备类型", "指标", "数值", "单位", "状态"};
+            for (int i = 0; i < headers.length; i++) {
+                Cell cell = headerRow.createCell(i);
+                cell.setCellValue(headers[i]);
+            }
+            
+            // 填充数据
+            List<Map<String, Object>> data = getExportData(request);
+            int rowNum = 1;
+            for (Map<String, Object> row : data) {
+                Row dataRow = sheet.createRow(rowNum++);
+                dataRow.createCell(0).setCellValue((String) row.get("time"));
+                dataRow.createCell(1).setCellValue((String) row.get("area"));
+                dataRow.createCell(2).setCellValue((String) row.get("deviceType"));
+                dataRow.createCell(3).setCellValue((String) row.get("metric"));
+                dataRow.createCell(4).setCellValue((Double) row.get("value"));
+                dataRow.createCell(5).setCellValue((String) row.get("unit"));
+                dataRow.createCell(6).setCellValue((String) row.get("status"));
+            }
+            
+            // 自动调整列宽
+            for (int i = 0; i < headers.length; i++) {
+                sheet.autoSizeColumn(i);
+            }
+            
+            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+            workbook.write(outputStream);
+            return outputStream.toByteArray();
+        } catch (Exception e) {
+            throw new RuntimeException("导出数据失败", e);
+        }
+    }
+
+    @Override
+    public Map<String, Object> getOverview() {
+        Map<String, Object> overview = new LinkedHashMap<>();
+        
+        // 设备总数
+        Integer totalDevices = jdbc.queryForObject("SELECT COUNT(*) FROM prod_monitor_device", Integer.class);
+        overview.put("totalDevices", totalDevices);
+        
+        // 在线设备数
+        Integer onlineDevices = jdbc.queryForObject(
+            "SELECT COUNT(*) FROM prod_monitor_device WHERE status = 'online'", Integer.class);
+        overview.put("onlineDevices", onlineDevices);
+        
+        // 报警总数
+        Integer totalAlerts = jdbc.queryForObject("SELECT COUNT(*) FROM alert_event WHERE status = 'active'", Integer.class);
+        overview.put("totalAlerts", totalAlerts);
+        
+        // 今日处理报警
+        Integer todayAlerts = jdbc.queryForObject(
+            "SELECT COUNT(*) FROM alert_event WHERE DATE(created_at) = CURRENT_DATE", Integer.class);
+        overview.put("todayAlerts", todayAlerts);
+        
+        // 待办指令数
+        Integer pendingCommands = jdbc.queryForObject(
+            "SELECT COUNT(*) FROM disp_dispatch_command WHERE status = 'pending'", Integer.class);
+        overview.put("pendingCommands", pendingCommands);
+        
+        return overview;
+    }
+
+    // ========== 私有方法 ==========
+    
+    private Map<String, Object> getRealtimeOverview(String area) {
+        Map<String, Object> overview = new LinkedHashMap<>();
+        
+        // 获取实时数据统计
+        String sql = "SELECT " +
+                     "COUNT(*) as totalDevices, " +
+                     "SUM(CASE WHEN status = 'online' THEN 1 ELSE 0 END) as onlineDevices, " +
+                     "SUM(CASE WHEN status = 'offline' THEN 1 ELSE 0 END) as offlineDevices, " +
+                     "SUM(CASE WHEN status = 'fault' THEN 1 ELSE 0 END) as faultDevices " +
+                     "FROM prod_monitor_device " +
+                     (area != null ? "WHERE area = ?" : "");
+        
+        Map<String, Object> stats = area != null ? 
+            jdbc.queryForList(sql, area).get(0) : 
+            jdbc.queryForList(sql).get(0);
+        
+        overview.putAll(stats);
+        
+        return overview;
+    }
+
+    private Map<String, Object> getKeyMetrics(String area) {
+        Map<String, Object> metrics = new LinkedHashMap<>();
+        
+        // 获取关键指标数据
+        String sql = "SELECT " +
+                     "AVG(metric_value) as avgValue, " +
+                     "MAX(metric_value) as maxValue, " +
+                     "MIN(metric_value) as minValue, " +
+                     "COUNT(*) as dataCount " +
+                     "FROM prod_monitor_realtime_data prd " +
+                     "JOIN prod_monitor_device pmd ON prd.device_id = pmd.id " +
+                     "WHERE prd.metric_key = ? " +
+                     (area != null ? "AND pmd.area = ?" : "") +
+                     " AND prd.collect_time >= NOW() - INTERVAL '1 hour'";
+        
+        // 流量指标
+        List<Map<String, Object>> flowData = area != null ?
+            jdbc.queryForList(sql, "flow", area) :
+            jdbc.queryForList(sql, "flow");
+        if (!flowData.isEmpty()) {
+            metrics.put("flow", flowData.get(0));
+        }
+        
+        // 压力指标
+        List<Map<String, Object>> pressureData = area != null ?
+            jdbc.queryForList(sql, "pressure", area) :
+            jdbc.queryForList(sql, "pressure");
+        if (!pressureData.isEmpty()) {
+            metrics.put("pressure", pressureData.get(0));
+        }
+        
+        return metrics;
+    }
+
+    private Map<String, Object> getDeviceStatistics(String area) {
+        Map<String, Object> stats = new LinkedHashMap<>();
+        
+        // 按状态统计
+        String statusSql = "SELECT status, COUNT(*) as count " +
+                           "FROM prod_monitor_device " +
+                           (area != null ? "WHERE area = ?" : "") +
+                           " GROUP BY status";
+        List<Map<String, Object>> statusStats = area != null ?
+            jdbc.queryForList(statusSql, area) :
+            jdbc.queryForList(statusSql);
+        stats.put("statusStats", statusStats);
+        
+        // 按类型统计
+        String typeSql = "SELECT device_type, COUNT(*) as count " +
+                         "FROM prod_monitor_device " +
+                         (area != null ? "WHERE area = ?" : "") +
+                         " GROUP BY device_type";
+        List<Map<String, Object>> typeStats = area != null ?
+            jdbc.queryForList(typeSql, area) :
+            jdbc.queryForList(typeSql);
+        stats.put("typeStats", typeStats);
+        
+        return stats;
+    }
+
+    private Map<String, Object> getAlertStatistics(String area) {
+        Map<String, Object> stats = new LinkedHashMap<>();
+        
+        // 报警级别统计
+        String levelSql = "SELECT alert_level, COUNT(*) as count " +
+                          "FROM alert_event " +
+                          (area != null ? "WHERE area = ?" : "") +
+                          " AND status = 'active' " +
+                          " GROUP BY alert_level";
+        List<Map<String, Object>> levelStats = area != null ?
+            jdbc.queryForList(levelSql, area) :
+            jdbc.queryForList(levelSql);
+        stats.put("levelStats", levelStats);
+        
+        // 今日报警趋势
+        String todaySql = "SELECT DATE_TRUNC('hour', created_at) as time_bucket, COUNT(*) as count " +
+                          "FROM alert_event " +
+                          "WHERE DATE(created_at) = CURRENT_DATE " +
+                          (area != null ? "AND area = ?" : "") +
+                          " GROUP BY time_bucket ORDER BY time_bucket";
+        List<Map<String, Object>> todayTrend = area != null ?
+            jdbc.queryForList(todaySql, area) :
+            jdbc.queryForList(todaySql);
+        stats.put("todayTrend", todayTrend);
+        
+        return stats;
+    }
+
+    private String buildHistoryDataSql(String dataType, String area) {
+        switch (dataType) {
+            case "water_flow":
+                return "SELECT * FROM rev_reading WHERE (area = ? OR ? IS NULL) AND created_at BETWEEN ? AND ? LIMIT 500";
+            case "water_quality":
+                return "SELECT * FROM water_quality_record WHERE (area = ? OR ? IS NULL) AND test_date BETWEEN ? AND ? LIMIT 500";
+            case "alerts":
+                return "SELECT * FROM alert_event WHERE (area = ? OR ? IS NULL) AND created_at BETWEEN ? AND ? LIMIT 500";
+            default:
+                return "SELECT * FROM prod_monitor_realtime_data prd JOIN prod_monitor_device pmd ON prd.device_id = pmd.id WHERE (pmd.area = ? OR ? IS NULL) AND prd.collect_time BETWEEN ? AND ? LIMIT 500";
+        }
+    }
+
+    private String buildChartDataSql(String chartType, String period, String area, String deviceType) {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM");
+        LocalDate periodDate = LocalDate.parse(period, formatter);
+        
+        String timeCondition = "";
+        switch (period) {
+            case "day":
+                timeCondition = "DATE(created_at) = CURRENT_DATE";
+                break;
+            case "week":
+                timeCondition = "created_at >= NOW() - INTERVAL '7 days'";
+                break;
+            case "month":
+                timeCondition = "to_char(created_at, 'yyyy-MM') = ?";
+                break;
+            default:
+                timeCondition = "created_at >= NOW() - INTERVAL '30 days'";
+        }
+        
+        String sql = "SELECT " +
+                     "to_char(created_at, 'HH24:MI') as time_label, " +
+                     "metric_value as value, " +
+                     "device_name as label " +
+                     "FROM prod_monitor_realtime_data prd " +
+                     "JOIN prod_monitor_device pmd ON prd.device_id = pmd.id " +
+                     "WHERE pmd.device_type = ? AND " + timeCondition +
+                     (area != null ? " AND pmd.area = ?" : "") +
+                     " ORDER BY created ASC";
+        
+        return period.equals("month") ? 
+            (area != null ? sql + " AND ?" : sql + " AND ?") :
+            (area != null ? sql + " AND ?" : sql);
+    }
+
+    private List<Map<String, Object>> generateWaterVolumeReport(String period, String area) {
+        String sql = "SELECT " +
+                     "area, " +
+                     "SUM(consumption) as total_consumption, " +
+                     "AVG(consumption) as avg_consumption, " +
+                     "COUNT(*) as reading_count " +
+                     "FROM rev_reading " +
+                     "WHERE reading_period = ? " +
+                     (area != null ? "AND area = ?" : "") +
+                     " GROUP BY area";
+        
+        return area != null ? 
+            jdbc.queryForList(sql, period, area) : 
+            jdbc.queryForList(sql, period);
+    }
+
+    private List<Map<String, Object>> generateWaterPressureReport(String period, String area) {
+        String sql = "SELECT " +
+                     "pmd.area, " +
+                     "AVG(prd.metric_value) as avg_pressure, " +
+                     "MAX(prd.metric_value) as max_pressure, " +
+                     "MIN(prd.metric_value) as min_pressure, " +
+                     "COUNT(*) as data_points " +
+                     "FROM prod_monitor_realtime_data prd " +
+                     "JOIN prod_monitor_device pmd ON prd.device_id = pmd.id " +
+                     "WHERE prd.metric_key = 'pressure' " +
+                     "AND to_char(prd.collect_time, 'yyyy-MM') = ? " +
+                     (area != null ? "AND pmd.area = ?" : "") +
+                     " GROUP BY pmd.area";
+        
+        return area != null ? 
+            jdbc.queryForList(sql, period, area) : 
+            jdbc.queryForList(sql, period);
+    }
+
+    private List<Map<String, Object>> generateFlowRateReport(String period, String area) {
+        String sql = "SELECT " +
+                     "pmd.area, " +
+                     "AVG(prd.metric_value) as avg_flow, " +
+                     "MAX(prd.metric_value) as max_flow, " +
+                     "MIN(prd.metric_value) as min_flow, " +
+                     "COUNT(*) as data_points " +
+                     "FROM prod_monitor_realtime_data prd " +
+                     "JOIN prod_monitor_device pmd ON prd.device_id = pmd.id " +
+                     "WHERE prd.metric_key = 'flow' " +
+                     "AND to_char(prd.collect_time, 'yyyy-MM') = ? " +
+                     (area != null ? "AND pmd.area = ?" : "") +
+                     " GROUP BY pmd.area";
+        
+        return area != null ? 
+            jdbc.queryForList(sql, period, area) : 
+            jdbc.queryForList(sql, period);
+    }
+
+    private List<Map<String, Object>> generateWaterQualityReport(String period, String area) {
+        String sql = "SELECT " +
+                     "area, " +
+                     "AVG(turbidity) as avg_turbidity, " +
+                     "AVG(ph) as avg_ph, " +
+                     "AVG(residual_chlorine) as avg_residual_chlorine, " +
+                     "COUNT(*) as tests, " +
+                     "SUM(CASE WHEN is_qualified=1 THEN 1 ELSE 0 END)*100.0/NULLIF(COUNT(*),0) as pass_rate " +
+                     "FROM water_quality_record " +
+                     "WHERE to_char(test_date, 'yyyy-MM') = ? " +
+                     (area != null ? "AND area = ?" : "") +
+                     " GROUP BY area";
+        
+        return area != null ? 
+            jdbc.queryForList(sql, period, area) : 
+            jdbc.queryForList(sql, period);
+    }
+
+    private List<Map<String, Object>> generateWaterLevelReport(String period, String area) {
+        String sql = "SELECT " +
+                     "pmd.area, " +
+                     "AVG(prd.metric_value) as avg_level, " +
+                     "MAX(prd.metric_value) as max_level, " +
+                     "MIN(prd.metric_value) as min_level, " +
+                     "COUNT(*) as data_points " +
+                     "FROM prod_monitor_realtime_data prd " +
+                     "JOIN prod_monitor_device pmd ON prd.device_id = pmd.id " +
+                     "WHERE prd.metric_key = 'level' " +
+                     "AND to_char(prd.collect_time, 'yyyy-MM') = ? " +
+                     (area != null ? "AND pmd.area = ?" : "") +
+                     " GROUP BY pmd.area";
+        
+        return area != null ? 
+            jdbc.queryForList(sql, period, area) : 
+            jdbc.queryForList(sql, period);
+    }
+
+    private List<Map<String, Object>> getExportData(DataExportRequest request) {
+        String sql = "SELECT " +
+                     "to_char(prd.collect_time, 'yyyy-MM-dd HH24:MI:SS') as time, " +
+                     "pmd.area, " +
+                     "pmd.device_type, " +
+                     "prd.metric_key as metric, " +
+                     "prd.metric_value as value, " +
+                     "prd.unit, " +
+                     "prd.is_abnormal as status " +
+                     "FROM prod_monitor_realtime_data prd " +
+                     "JOIN prod_monitor_device pmd ON prd.device_id = pmd.id " +
+                     "WHERE prd.collect_time BETWEEN ? AND ? " +
+                     (request.getArea() != null ? "AND pmd.area = ?" : "") +
+                     (request.getDeviceType() != null ? " AND pmd.device_type = ?" : "") +
+                     " ORDER BY prd.collect_time DESC";
+        
+        List<Object> params = new ArrayList<>();
+        params.add(request.getStartTime());
+        params.add(request.getEndTime());
+        if (request.getArea() != null) {
+            params.add(request.getArea());
+        }
+        if (request.getDeviceType() != null) {
+            params.add(request.getDeviceType());
+        }
+        
+        return jdbc.queryForList(sql, params.toArray());
+    }
+
+    private List<Map<String, Object>> infoReleasesToMap(List<InfoRelease> releases) {
+        return releases.stream().map(release -> {
+            Map<String, Object> map = new LinkedHashMap<>();
+            map.put("id", release.getId());
+            map.put("type", release.getType());
+            map.put("title", release.getTitle());
+            map.put("content", release.getContent());
+            map.put("area", release.getArea());
+            map.put("publisherId", release.getPublisherId());
+            map.put("publishTime", release.getPublishTime());
+            map.put("status", release.getStatus());
+            return map;
+        }).collect(Collectors.toList());
+    }
+}

wm-production/src/main/java/com/water/production/vo/AlarmSchemeQueryVO.java

+package com.water.production.vo;
+
+import lombok.Data;
+
+/**
+ * 报警方案查询VO
+ * 对应 Issue 13: CFG-03 报警方案
+ */
+@Data
+public class AlarmSchemeQueryVO {
+    
+    /** 报警方案名称 */
+    private String schemeName;
+    
+    /** 报警级别 */
+    private String alertLevel;
+    
+    /** 区域 */
+    private String area;
+    
+    /** 是否启用 */
+    private Boolean enabled;
+    
+    /** 关键字搜索 */
+    private String keyword;
+    
+    /** 创建人ID */
+    private Long createdBy;
+    
+    /** 页码 */
+    private Integer page = 1;
+    
+    /** 页大小 */
+    private Integer size = 10;
+    
+    /** 排序字段 */
+    private String sortBy = "created_at";
+    
+    /** 排序方向 */
+    private String sortOrder = "desc";
+}