feat(wm-bi+frontend): #39 需水量预测+调度决策推荐完整实现

- 后端(wm-bi):
  - Entity: WaterDemandForecast, SchedulingRecommendation, HistoricalWaterDemand
  - Mapper: 3个MyBatis-Plus Mapper接口
  - Service: WaterDemandForecastService(移动平均/指数平滑/季节性分解三种预测模型+模型评估)
  - Service: SchedulingRecommendService(常规/错峰/节能/紧急/低成本5种调度方案+贪心算法+评分排序)
  - Controller: /api/bi/forecast/* + /api/bi/scheduling/*
  - DDL: bi_historical_water_demand, bi_water_demand_forecast, bi_scheduling_recommendation
- 前端(Vue3 + Element Plus + ECharts):
  - ForecastView.vue: 历史趋势+预测曲线(含置信区间)+模型对比(MAE/RMSE/MAPE)
  - SchedulingView.vue: 推荐方案卡片+方案对比表格+采纳/拒绝
  - forecastApi.ts: TypeScript API封装
  - 路由注册: /bi/forecast, /bi/scheduling
- 测试: WaterDemandForecastServiceTest + SchedulingRecommendServiceTest

db/bi_forecast_ddl.sql

@@ -0,0 +1,74 @@
+-- ============================================================
+-- 需水量预测 + 调度推荐 DDL
+-- ============================================================
+
+-- 1. 历史需水量数据表
+CREATE TABLE IF NOT EXISTS bi_historical_water_demand (
+    id              BIGSERIAL PRIMARY KEY,
+    area_code       VARCHAR(32) NOT NULL,          -- 区域编码
+    area_name       VARCHAR(64),                   -- 区域名称
+    record_date     DATE NOT NULL,                 -- 日期
+    volume          DECIMAL(12,2),                 -- 需水量(m³)
+    max_temp        DECIMAL(5,1),                  -- 最高温度(℃)
+    min_temp        DECIMAL(5,1),                  -- 最低温度(℃)
+    weather         VARCHAR(16),                   -- 天气: sunny/cloudy/rainy/snowy
+    rainfall        DECIMAL(8,1),                  -- 降雨量(mm)
+    is_holiday      BOOLEAN DEFAULT FALSE,         -- 是否节假日
+    day_of_week     INTEGER,                       -- 星期几(1=周一,7=周日)
+    data_source     VARCHAR(16) DEFAULT 'METER',   -- 数据来源: METER/ESTIMATED/SIMULATED
+    deleted         INTEGER DEFAULT 0,
+    created_at      TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at      TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+COMMENT ON TABLE bi_historical_water_demand IS '历史需水量数据';
+CREATE INDEX IF NOT EXISTS idx_hwd_area_date ON bi_historical_water_demand(area_code, record_date);
+
+-- 2. 需水量预测记录表
+CREATE TABLE IF NOT EXISTS bi_water_demand_forecast (
+    id              BIGSERIAL PRIMARY KEY,
+    area_code       VARCHAR(32) NOT NULL,          -- 区域编码
+    area_name       VARCHAR(64),                   -- 区域名称
+    forecast_date   DATE NOT NULL,                 -- 预测日期
+    forecast_volume DECIMAL(12,2),                 -- 预测水量(m³)
+    actual_volume   DECIMAL(12,2),                 -- 实际水量(用于评估)
+    model_type      VARCHAR(32) NOT NULL,          -- 模型类型: MOVING_AVERAGE/EXPONENTIAL_SMOOTHING/SEASONAL_DECOMPOSITION
+    model_params    TEXT,                          -- 模型参数JSON
+    mae             DECIMAL(10,2),                 -- 平均绝对误差
+    rmse            DECIMAL(10,2),                 -- 均方根误差
+    mape            DECIMAL(8,2),                  -- 平均绝对百分比误差(%)
+    confidence      DECIMAL(5,4),                  -- 置信度(0-1)
+    lower_bound     DECIMAL(12,2),                 -- 置信区间下限
+    upper_bound     DECIMAL(12,2),                 -- 置信区间上限
+    generate_time   TIMESTAMP,                     -- 预测生成时间
+    remark          VARCHAR(255),
+    deleted         INTEGER DEFAULT 0,
+    created_at      TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at      TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+COMMENT ON TABLE bi_water_demand_forecast IS '需水量预测记录';
+CREATE INDEX IF NOT EXISTS idx_forecast_area_date ON bi_water_demand_forecast(area_code, forecast_date);
+CREATE INDEX IF NOT EXISTS idx_forecast_model ON bi_water_demand_forecast(model_type);
+
+-- 3. 调度推荐方案表
+CREATE TABLE IF NOT EXISTS bi_scheduling_recommendation (
+    id                  BIGSERIAL PRIMARY KEY,
+    forecast_id         BIGINT,                    -- 关联预测ID
+    scheme_name         VARCHAR(128) NOT NULL,      -- 方案名称
+    scheme_type         VARCHAR(16) NOT NULL,       -- 方案类型: NORMAL/PEAK_SHIFT/EMERGENCY
+    description         TEXT,                       -- 方案描述
+    pump_combination    TEXT,                       -- 泵站组合JSON
+    estimated_saving    DECIMAL(12,2),              -- 预计节水量(m³)
+    estimated_energy_saving DECIMAL(12,2),          -- 预计节能(kWh)
+    score               DECIMAL(6,1),               -- 方案评分(0-100)
+    execute_start       TIMESTAMP,                  -- 执行时间窗口-开始
+    execute_end         TIMESTAMP,                  -- 执行时间窗口-结束
+    risk_level          VARCHAR(8),                 -- 风险等级: LOW/MEDIUM/HIGH
+    status              VARCHAR(16) DEFAULT 'PENDING', -- 状态: PENDING/ACCEPTED/EXECUTING/COMPLETED/REJECTED
+    remark              VARCHAR(255),
+    deleted             INTEGER DEFAULT 0,
+    created_at          TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at          TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+COMMENT ON TABLE bi_scheduling_recommendation IS '调度推荐方案';
+CREATE INDEX IF NOT EXISTS idx_scheduling_forecast ON bi_scheduling_recommendation(forecast_id);
+CREATE INDEX IF NOT EXISTS idx_scheduling_status ON bi_scheduling_recommendation(status);

frontend/src/api/forecastApi.ts

@@ -0,0 +1,78 @@
+import request from './request'
+
+/** 需水量预测 API */
+export const forecastApi = {
+  /** 执行预测 */
+  execute(areaCode: string, modelType: string = 'SEASONAL_DECOMPOSITION', forecastDays: number = 7) {
+    return request.post('/bi/forecast/execute', null, {
+      params: { areaCode, modelType, forecastDays }
+    })
+  },
+
+  /** 多模型对比 */
+  multiModel(areaCode: string, forecastDays: number = 7) {
+    return request.post('/bi/forecast/multi-model', null, {
+      params: { areaCode, forecastDays }
+    })
+  },
+
+  /** 预测历史 */
+  history(areaCode?: string, page: number = 1, size: number = 20) {
+    return request.get('/bi/forecast/history', { params: { areaCode, page, size } })
+  },
+
+  /** 历史趋势 */
+  trend(areaCode: string, startDate?: string, endDate?: string) {
+    return request.get('/bi/forecast/trend', { params: { areaCode, startDate, endDate } })
+  },
+
+  /** 生成演示数据 */
+  generateDemo(areaCode: string, days: number = 365) {
+    return request.post('/bi/forecast/demo-data', null, { params: { areaCode, days } })
+  }
+}
+
+/** 调度推荐 API */
+export const schedulingApi = {
+  /** 生成推荐方案 */
+  generate(forecastId: number) {
+    return request.post('/bi/scheduling/generate', null, { params: { forecastId } })
+  },
+
+  /** 推荐列表 */
+  list(forecastId?: number, page: number = 1, size: number = 20) {
+    return request.get('/bi/scheduling/list', { params: { forecastId, page, size } })
+  },
+
+  /** 方案详情 */
+  detail(id: number) {
+    return request.get(`/bi/scheduling/${id}`)
+  },
+
+  /** 采纳方案 */
+  accept(id: number) {
+    return request.post(`/bi/scheduling/${id}/accept`)
+  },
+
+  /** 拒绝方案 */
+  reject(id: number) {
+    return request.post(`/bi/scheduling/${id}/reject`)
+  }
+}
+
+/** 区域列表 */
+export const AREA_OPTIONS = [
+  { value: 'JH_001', label: '精河县城北区' },
+  { value: 'JH_002', label: '精河县城南区' },
+  { value: 'JH_003', label: '精河县工业园' },
+  { value: 'JH_004', label: '精河县新城区' },
+  { value: 'JH_005', label: '托托镇供水区' },
+  { value: 'JH_006', label: '大河沿子镇' }
+]
+
+/** 模型类型 */
+export const MODEL_OPTIONS = [
+  { value: 'MOVING_AVERAGE', label: '移动平均法' },
+  { value: 'EXPONENTIAL_SMOOTHING', label: '指数平滑法' },
+  { value: 'SEASONAL_DECOMPOSITION', label: '季节性分解法' }
+]

frontend/src/router/index.ts

@@ -16,6 +16,8 @@ const routes = [
       { path: 'cs/knowledge', name: 'csKnowledge', component: () => import('@/views/cs/KnowledgeBaseView.vue') },
       { path: 'cs/announcement', name: 'csAnnouncement', component: () => import('@/views/cs/AnnouncementView.vue') },
       { path: 'cs/kpi', name: 'csKpi', component: () => import('@/views/cs/KpiDashboardView.vue') },
+      { path: 'bi/forecast', name: 'biForecast', component: () => import('@/views/bi/ForecastView.vue') },
+      { path: 'bi/scheduling', name: 'biScheduling', component: () => import('@/views/bi/SchedulingView.vue') },
     ]
   },
   { path: '/:pathMatch(.*)*', redirect: '/dashboard' }

frontend/src/views/bi/ForecastView.vue

@@ -0,0 +1,296 @@
+<template>
+  <div class="forecast-view">
+    <el-card shadow="never">
+      <template #header>
+        <div class="card-header">
+          <span>📊 需水量预测仪表盘</span>
+          <el-tag type="info" size="small">BI 智能分析</el-tag>
+        </div>
+      </template>
+
+      <!-- 筛选条件 -->
+      <el-form :inline="true" class="filter-form">
+        <el-form-item label="区域">
+          <el-select v-model="filters.areaCode" placeholder="选择区域" style="width: 200px">
+            <el-option v-for="a in AREA_OPTIONS" :key="a.value" :label="a.label" :value="a.value" />
+          </el-select>
+        </el-form-item>
+        <el-form-item label="预测模型">
+          <el-select v-model="filters.modelType" style="width: 180px">
+            <el-option v-for="m in MODEL_OPTIONS" :key="m.value" :label="m.label" :value="m.value" />
+          </el-select>
+        </el-form-item>
+        <el-form-item label="预测天数">
+          <el-input-number v-model="filters.forecastDays" :min="1" :max="30" />
+        </el-form-item>
+        <el-form-item>
+          <el-button type="primary" :loading="loading" @click="runForecast">🔮 执行预测</el-button>
+          <el-button :loading="loadingMulti" @click="runMultiModel">📈 多模型对比</el-button>
+          <el-button @click="initDemoData">📦 初始化演示数据</el-button>
+        </el-form-item>
+      </el-form>
+    </el-card>
+
+    <!-- 历史趋势 + 预测曲线 -->
+    <el-row :gutter="16" style="margin-top: 16px">
+      <el-col :span="16">
+        <el-card shadow="never">
+          <template #header>历史趋势 + 预测曲线（含置信区间）</template>
+          <div ref="trendChartRef" style="height: 400px"></div>
+        </el-card>
+      </el-col>
+      <el-col :span="8">
+        <el-card shadow="never">
+          <template #header>模型评估指标</template>
+          <div ref="metricsChartRef" style="height: 400px"></div>
+        </el-card>
+      </el-col>
+    </el-row>
+
+    <!-- 多模型对比结果 -->
+    <el-card v-if="multiModelResult" shadow="never" style="margin-top: 16px">
+      <template #header>
+        <div class="card-header">
+          <span>模型对比</span>
+          <el-tag type="success">最优模型: {{ multiModelResult.bestModel }}</el-tag>
+        </div>
+      </template>
+      <el-table :data="modelComparisonData" stripe>
+        <el-table-column prop="model" label="模型" />
+        <el-table-column prop="mae" label="MAE" />
+        <el-table-column prop="rmse" label="RMSE" />
+        <el-table-column prop="mape" label="MAPE(%)" />
+        <el-table-column label="最优">
+          <template #default="{ row }">
+            <el-icon v-if="row.model === multiModelResult.bestModel" color="#67c23a"><Check /></el-icon>
+          </template>
+        </el-table-column>
+      </el-table>
+    </el-card>
+
+    <!-- 预测结果表格 -->
+    <el-card v-if="forecastResults.length > 0" shadow="never" style="margin-top: 16px">
+      <template #header>预测结果</template>
+      <el-table :data="forecastResults" stripe>
+        <el-table-column prop="forecastDate" label="预测日期" width="120" />
+        <el-table-column prop="forecastVolume" label="预测水量(m³)" width="140">
+          <template #default="{ row }">{{ Number(row.forecastVolume).toFixed(0) }}</template>
+        </el-table-column>
+        <el-table-column label="置信区间" width="180">
+          <template #default="{ row }">
+            [{{ Number(row.lowerBound).toFixed(0) }}, {{ Number(row.upperBound).toFixed(0) }}]
+          </template>
+        </el-table-column>
+        <el-table-column prop="modelType" label="模型" width="180">
+          <template #default="{ row }">{{ modelLabel(row.modelType) }}</template>
+        </el-table-column>
+        <el-table-column prop="mae" label="MAE" width="100">
+          <template #default="{ row }">{{ row.mae ? Number(row.mae).toFixed(2) : '-' }}</template>
+        </el-table-column>
+        <el-table-column prop="rmse" label="RMSE" width="100">
+          <template #default="{ row }">{{ row.rmse ? Number(row.rmse).toFixed(2) : '-' }}</template>
+        </el-table-column>
+        <el-table-column prop="mape" label="MAPE(%)" width="100">
+          <template #default="{ row }">{{ row.mape ? Number(row.mape).toFixed(2) : '-' }}</template>
+        </el-table-column>
+        <el-table-column prop="confidence" label="置信度" width="100">
+          <template #default="{ row }">
+            <el-progress :percentage="Number(row.confidence) * 100" :format="p => p.toFixed(0) + '%'" :stroke-width="12" />
+          </template>
+        </el-table-column>
+      </el-table>
+    </el-card>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, reactive, computed, onMounted, nextTick } from 'vue'
+import { ElMessage } from 'element-plus'
+import { Check } from '@element-plus/icons-vue'
+import * as echarts from 'echarts'
+import { forecastApi, AREA_OPTIONS, MODEL_OPTIONS } from '@/api/forecastApi'
+
+const filters = reactive({
+  areaCode: 'JH_001',
+  modelType: 'SEASONAL_DECOMPOSITION',
+  forecastDays: 7
+})
+
+const loading = ref(false)
+const loadingMulti = ref(false)
+const forecastResults = ref<any[]>([])
+const multiModelResult = ref<any>(null)
+const trendChartRef = ref<HTMLElement>()
+const metricsChartRef = ref<HTMLElement>()
+let trendChart: echarts.ECharts | null = null
+let metricsChart: echarts.ECharts | null = null
+
+const modelComparisonData = computed(() => {
+  if (!multiModelResult.value) return []
+  return MODEL_OPTIONS.map(m => {
+    const data = multiModelResult.value[m.value]
+    return {
+      model: m.label,
+      mae: data?.mae ? Number(data.mae).toFixed(2) : '-',
+      rmse: data?.rmse ? Number(data.rmse).toFixed(2) : '-',
+      mape: data?.mape ? Number(data.mape).toFixed(2) : '-'
+    }
+  })
+})
+
+function modelLabel(type: string) {
+  return MODEL_OPTIONS.find(m => m.value === type)?.label || type
+}
+
+async function runForecast() {
+  loading.value = true
+  try {
+    const res = await forecastApi.execute(filters.areaCode, filters.modelType, filters.forecastDays) as any
+    forecastResults.value = res.data
+    ElMessage.success('预测完成')
+    await loadTrendData()
+  } catch (e: any) {
+    ElMessage.error(e.message || '预测失败')
+  } finally {
+    loading.value = false
+  }
+}
+
+async function runMultiModel() {
+  loadingMulti.value = true
+  try {
+    const res = await forecastApi.multiModel(filters.areaCode, filters.forecastDays) as any
+    multiModelResult.value = res.data
+    forecastResults.value = res.data.bestForecasts || []
+    ElMessage.success('多模型对比完成')
+    await loadTrendData()
+    renderMetricsChart()
+  } catch (e: any) {
+    ElMessage.error(e.message || '对比失败')
+  } finally {
+    loadingMulti.value = false
+  }
+}
+
+async function initDemoData() {
+  loading.value = true
+  try {
+    const res = await forecastApi.generateDemo(filters.areaCode, 365) as any
+    ElMessage.success(`生成 ${res.data.generated} 条演示数据`)
+    await loadTrendData()
+  } catch (e: any) {
+    ElMessage.error(e.message || '生成失败')
+  } finally {
+    loading.value = false
+  }
+}
+
+async function loadTrendData() {
+  try {
+    const res = await forecastApi.trend(filters.areaCode) as any
+    const history = res.data || []
+    renderTrendChart(history, forecastResults.value)
+  } catch {
+    // silent
+  }
+}
+
+function renderTrendChart(history: any[], forecasts: any[]) {
+  if (!trendChartRef.value) return
+  if (!trendChart) trendChart = echarts.init(trendChartRef.value)
+
+  const historyDates = history.map((h: any) => h.recordDate)
+  const historyValues = history.map((h: any) => Number(h.volume))
+
+  const forecastDates = forecasts.map((f: any) => f.forecastDate)
+  const forecastValues = forecasts.map((f: any) => Number(f.forecastVolume))
+  const lowerBounds = forecasts.map((f: any) => Number(f.lowerBound))
+  const upperBounds = forecasts.map((f: any) => Number(f.upperBound))
+
+  // 连接历史与预测的过渡点
+  const lastHistoryDate = historyDates.length > 0 ? historyDates[historyDates.length - 1] : null
+  const lastHistoryValue = historyValues.length > 0 ? historyValues[historyValues.length - 1] : null
+
+  const allDates = [...historyDates, ...forecastDates]
+  const historySeries = [...historyValues, ...forecastDates.map(() => null)]
+  const forecastSeries = [
+    ...historyDates.map((_: any, i: number) => i === historyDates.length - 1 ? lastHistoryValue : null),
+    ...forecastValues
+  ]
+  const lowerSeries = [
+    ...historyDates.map(() => null),
+    ...lowerBounds
+  ]
+  const upperSeries = [
+    ...historyDates.map(() => null),
+    ...upperBounds
+  ]
+
+  trendChart.setOption({
+    tooltip: { trigger: 'axis' },
+    legend: { data: ['历史水量', '预测水量', '置信上限', '置信下限'] },
+    xAxis: { type: 'category', data: allDates, axisLabel: { rotate: 45 } },
+    yAxis: { type: 'value', name: '水量(m³)' },
+    dataZoom: [{ type: 'inside' }, { type: 'slider' }],
+    series: [
+      {
+        name: '历史水量', type: 'line', data: historySeries,
+        itemStyle: { color: '#409EFF' }, lineStyle: { width: 2 }
+      },
+      {
+        name: '预测水量', type: 'line', data: forecastSeries,
+        itemStyle: { color: '#E6A23C' }, lineStyle: { width: 2, type: 'dashed' }
+      },
+      {
+        name: '置信上限', type: 'line', data: upperSeries,
+        lineStyle: { opacity: 0 }, areaStyle: { color: 'rgba(230, 162, 60, 0.15)' }, stack: 'confidence'
+      },
+      {
+        name: '置信下限', type: 'line', data: lowerSeries,
+        lineStyle: { opacity: 0 }, areaStyle: { color: 'rgba(230, 162, 60, 0.15)' }, stack: 'confidence'
+      }
+    ]
+  })
+}
+
+function renderMetricsChart() {
+  if (!metricsChartRef.value || !multiModelResult.value) return
+  if (!metricsChart) metricsChart = echarts.init(metricsChartRef.value)
+
+  const models = MODEL_OPTIONS.map(m => m.label)
+  const maeValues = MODEL_OPTIONS.map(m => {
+    const d = multiModelResult.value[m.value]
+    return d?.mae ? Number(d.mae) : 0
+  })
+  const rmseValues = MODEL_OPTIONS.map(m => {
+    const d = multiModelResult.value[m.value]
+    return d?.rmse ? Number(d.rmse) : 0
+  })
+
+  metricsChart.setOption({
+    tooltip: { trigger: 'axis' },
+    legend: { data: ['MAE', 'RMSE'] },
+    xAxis: { type: 'category', data: models },
+    yAxis: { type: 'value' },
+    series: [
+      { name: 'MAE', type: 'bar', data: maeValues, itemStyle: { color: '#409EFF' } },
+      { name: 'RMSE', type: 'bar', data: rmseValues, itemStyle: { color: '#F56C6C' } }
+    ]
+  })
+}
+
+onMounted(async () => {
+  await nextTick()
+  await loadTrendData()
+  window.addEventListener('resize', () => {
+    trendChart?.resize()
+    metricsChart?.resize()
+  })
+})
+</script>
+
+<style scoped>
+.forecast-view { padding: 16px; }
+.card-header { display: flex; align-items: center; justify-content: space-between; font-weight: 600; }
+.filter-form { margin-bottom: 8px; }
+</style>

frontend/src/views/bi/SchedulingView.vue

@@ -0,0 +1,227 @@
+<template>
+  <div class="scheduling-view">
+    <el-card shadow="never">
+      <template #header>
+        <div class="card-header">
+          <span>⚡ 调度推荐决策</span>
+          <el-tag type="info" size="small">基于预测结果的智能调度</el-tag>
+        </div>
+      </template>
+
+      <!-- 操作区 -->
+      <el-form :inline="true" class="filter-form">
+        <el-form-item label="预测ID">
+          <el-input-number v-model="forecastId" :min="1" placeholder="输入预测记录ID" />
+        </el-form-item>
+        <el-form-item>
+          <el-button type="primary" :loading="generating" @click="generateSchemes">🚀 生成推荐方案</el-button>
+          <el-button @click="loadRecommendations">🔄 刷新列表</el-button>
+        </el-form-item>
+      </el-form>
+    </el-card>
+
+    <!-- 推荐方案卡片 -->
+    <el-row v-if="recommendations.length > 0" :gutter="16" style="margin-top: 16px">
+      <el-col v-for="rec in recommendations" :key="rec.id" :span="8">
+        <el-card shadow="hover" :class="['scheme-card', `scheme-${rec.schemeType.toLowerCase()}`]">
+          <template #header>
+            <div class="scheme-header">
+              <span class="scheme-name">{{ rec.schemeName }}</span>
+              <el-tag :type="riskType(rec.riskLevel)" size="small">{{ rec.riskLevel }}</el-tag>
+            </div>
+          </template>
+
+          <div class="scheme-body">
+            <div class="metric-row">
+              <div class="metric">
+                <div class="metric-value score">{{ Number(rec.score).toFixed(1) }}</div>
+                <div class="metric-label">综合评分</div>
+              </div>
+              <div class="metric">
+                <div class="metric-value saving">{{ Number(rec.estimatedSaving).toFixed(0) }}</div>
+                <div class="metric-label">节水量(m³)</div>
+              </div>
+              <div class="metric">
+                <div class="metric-value energy">{{ Number(rec.estimatedEnergySaving).toFixed(1) }}</div>
+                <div class="metric-label">节能(kWh)</div>
+              </div>
+            </div>
+
+            <el-divider />
+
+            <div class="pump-list">
+              <div class="section-title">泵站组合</div>
+              <div v-for="pump in parsePumps(rec.pumpCombination)" :key="pump.stationCode" class="pump-item">
+                <span>{{ pump.stationName }}</span>
+                <el-tag size="small">{{ pump.flow }}m³/h</el-tag>
+              </div>
+            </div>
+
+            <el-divider />
+
+            <div class="exec-time">
+              <div class="section-title">执行时间</div>
+              <div>{{ formatTime(rec.executeStart) }} ~ {{ formatTime(rec.executeEnd) }}</div>
+            </div>
+
+            <div class="description">
+              <el-text type="info" size="small">{{ rec.description }}</el-text>
+            </div>
+          </div>
+
+          <div class="scheme-actions">
+            <el-button type="success" size="small" :disabled="rec.status !== 'PENDING'"
+                       @click="acceptScheme(rec)">✅ 采纳</el-button>
+            <el-button type="danger" size="small" :disabled="rec.status !== 'PENDING'"
+                       @click="rejectScheme(rec)">❌ 拒绝</el-button>
+            <el-tag v-if="rec.status !== 'PENDING'" :type="statusType(rec.status)">{{ rec.status }}</el-tag>
+          </div>
+        </el-card>
+      </el-col>
+    </el-row>
+
+    <!-- 方案对比表格 -->
+    <el-card v-if="recommendations.length > 0" shadow="never" style="margin-top: 16px">
+      <template #header>方案对比</template>
+      <el-table :data="recommendations" stripe>
+        <el-table-column prop="schemeName" label="方案名称" width="180" />
+        <el-table-column prop="schemeType" label="类型" width="120">
+          <template #default="{ row }">
+            <el-tag :type="row.schemeType === 'EMERGENCY' ? 'danger' : row.schemeType === 'PEAK_SHIFT' ? 'warning' : 'info'" size="small">
+              {{ row.schemeType }}
+            </el-tag>
+          </template>
+        </el-table-column>
+        <el-table-column prop="score" label="评分" width="100">
+          <template #default="{ row }">{{ Number(row.score).toFixed(1) }}</template>
+        </el-table-column>
+        <el-table-column prop="estimatedSaving" label="节水量(m³)" width="120">
+          <template #default="{ row }">{{ Number(row.estimatedSaving).toFixed(0) }}</template>
+        </el-table-column>
+        <el-table-column prop="estimatedEnergySaving" label="节能(kWh)" width="120">
+          <template #default="{ row }">{{ Number(row.estimatedEnergySaving).toFixed(1) }}</template>
+        </el-table-column>
+        <el-table-column prop="riskLevel" label="风险" width="100">
+          <template #default="{ row }">
+            <el-tag :type="riskType(row.riskLevel)" size="small">{{ row.riskLevel }}</el-tag>
+          </template>
+        </el-table-column>
+        <el-table-column prop="status" label="状态" width="120">
+          <template #default="{ row }">
+            <el-tag :type="statusType(row.status)" size="small">{{ row.status }}</el-tag>
+          </template>
+        </el-table-column>
+        <el-table-column label="泵站数" width="80">
+          <template #default="{ row }">{{ parsePumps(row.pumpCombination).length }}</template>
+        </el-table-column>
+      </el-table>
+    </el-card>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref, onMounted } from 'vue'
+import { ElMessage } from 'element-plus'
+import { schedulingApi } from '@/api/forecastApi'
+
+const forecastId = ref<number>(1)
+const generating = ref(false)
+const recommendations = ref<any[]>([])
+
+async function generateSchemes() {
+  if (!forecastId.value) {
+    ElMessage.warning('请输入预测ID')
+    return
+  }
+  generating.value = true
+  try {
+    const res = await schedulingApi.generate(forecastId.value) as any
+    recommendations.value = res.data
+    ElMessage.success(`生成 ${res.data.length} 个推荐方案`)
+  } catch (e: any) {
+    ElMessage.error(e.message || '生成失败')
+  } finally {
+    generating.value = false
+  }
+}
+
+async function loadRecommendations() {
+  try {
+    const res = await schedulingApi.list(forecastId.value) as any
+    recommendations.value = res.data?.records || []
+  } catch (e: any) {
+    ElMessage.error(e.message || '加载失败')
+  }
+}
+
+async function acceptScheme(rec: any) {
+  try {
+    await schedulingApi.accept(rec.id)
+    rec.status = 'ACCEPTED'
+    ElMessage.success('方案已采纳')
+  } catch (e: any) {
+    ElMessage.error(e.message || '操作失败')
+  }
+}
+
+async function rejectScheme(rec: any) {
+  try {
+    await schedulingApi.reject(rec.id)
+    rec.status = 'REJECTED'
+    ElMessage.warning('方案已拒绝')
+  } catch (e: any) {
+    ElMessage.error(e.message || '操作失败')
+  }
+}
+
+function parsePumps(json: string): any[] {
+  try { return JSON.parse(json || '[]') } catch { return [] }
+}
+
+function formatTime(t: string) {
+  if (!t) return '-'
+  return t.replace('T', ' ').substring(0, 16)
+}
+
+function riskType(level: string) {
+  return level === 'HIGH' ? 'danger' : level === 'MEDIUM' ? 'warning' : 'success'
+}
+
+function statusType(status: string) {
+  const map: Record<string, string> = {
+    PENDING: 'info', ACCEPTED: 'success', EXECUTING: 'warning', COMPLETED: '', REJECTED: 'danger'
+  }
+  return map[status] || 'info'
+}
+
+onMounted(() => {
+  // auto-load if forecastId is set
+})
+</script>
+
+<style scoped>
+.scheduling-view { padding: 16px; }
+.card-header { display: flex; align-items: center; justify-content: space-between; font-weight: 600; }
+.filter-form { margin-bottom: 8px; }
+
+.scheme-card { margin-bottom: 16px; }
+.scheme-header { display: flex; align-items: center; justify-content: space-between; }
+.scheme-name { font-weight: 600; font-size: 14px; }
+.scheme-emergency { border-left: 4px solid #f56c6c; }
+.scheme-peak_shift { border-left: 4px solid #e6a23c; }
+.scheme-normal { border-left: 4px solid #409eff; }
+
+.scheme-body { padding: 0; }
+.metric-row { display: flex; justify-content: space-around; text-align: center; }
+.metric-value { font-size: 24px; font-weight: 700; }
+.metric-value.score { color: #409eff; }
+.metric-value.saving { color: #67c23a; }
+.metric-value.energy { color: #e6a23c; }
+.metric-label { font-size: 12px; color: #909399; margin-top: 4px; }
+
+.section-title { font-weight: 600; font-size: 13px; color: #606266; margin-bottom: 8px; }
+.pump-item { display: flex; justify-content: space-between; align-items: center; padding: 4px 0; }
+.exec-time { margin-bottom: 8px; }
+.description { margin-top: 8px; }
+.scheme-actions { margin-top: 12px; display: flex; gap: 8px; align-items: center; }
+</style>

wm-bi/src/main/java/com/water/bi/controller/SchedulingRecommendController.java

@@ -0,0 +1,54 @@
+package com.water.bi.controller;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.water.bi.entity.SchedulingRecommendation;
+import com.water.bi.service.SchedulingRecommendService;
+import com.water.common.core.result.R;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@Tag(name = "调度推荐")
+@RestController
+@RequestMapping("/api/bi/scheduling")
+@RequiredArgsConstructor
+public class SchedulingRecommendController {
+
+    private final SchedulingRecommendService recommendService;
+
+    @Operation(summary = "生成推荐方案")
+    @PostMapping("/generate")
+    public R<List<SchedulingRecommendation>> generate(@RequestParam Long forecastId) {
+        return R.ok(recommendService.generateRecommendations(forecastId));
+    }
+
+    @Operation(summary = "推荐列表")
+    @GetMapping("/list")
+    public R<Page<SchedulingRecommendation>> list(
+            @RequestParam(required = false) Long forecastId,
+            @RequestParam(defaultValue = "1") int page,
+            @RequestParam(defaultValue = "20") int size) {
+        return R.ok(recommendService.getRecommendations(forecastId, page, size));
+    }
+
+    @Operation(summary = "方案详情")
+    @GetMapping("/{id}")
+    public R<SchedulingRecommendation> getById(@PathVariable Long id) {
+        return R.ok(recommendService.getById(id));
+    }
+
+    @Operation(summary = "采纳方案")
+    @PostMapping("/{id}/accept")
+    public R<SchedulingRecommendation> accept(@PathVariable Long id) {
+        return R.ok(recommendService.acceptRecommendation(id));
+    }
+
+    @Operation(summary = "拒绝方案")
+    @PostMapping("/{id}/reject")
+    public R<SchedulingRecommendation> reject(@PathVariable Long id) {
+        return R.ok(recommendService.rejectRecommendation(id));
+    }
+}

wm-bi/src/main/java/com/water/bi/controller/WaterDemandForecastController.java

@@ -0,0 +1,69 @@
+package com.water.bi.controller;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.water.bi.entity.HistoricalWaterDemand;
+import com.water.bi.entity.WaterDemandForecast;
+import com.water.bi.service.WaterDemandForecastService;
+import com.water.common.core.result.R;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.web.bind.annotation.*;
+
+import java.time.LocalDate;
+import java.util.List;
+import java.util.Map;
+
+@Tag(name = "需水量预测")
+@RestController
+@RequestMapping("/api/bi/forecast")
+@RequiredArgsConstructor
+public class WaterDemandForecastController {
+
+    private final WaterDemandForecastService forecastService;
+
+    @Operation(summary = "执行预测")
+    @PostMapping("/execute")
+    public R<List<WaterDemandForecast>> executeForecast(
+            @RequestParam String areaCode,
+            @RequestParam(defaultValue = "SEASONAL_DECOMPOSITION") String modelType,
+            @RequestParam(defaultValue = "7") int forecastDays) {
+        return R.ok(forecastService.forecast(areaCode, modelType, forecastDays));
+    }
+
+    @Operation(summary = "多模型对比预测")
+    @PostMapping("/multi-model")
+    public R<Map<String, Object>> multiModelForecast(
+            @RequestParam String areaCode,
+            @RequestParam(defaultValue = "7") int forecastDays) {
+        return R.ok(forecastService.multiModelForecast(areaCode, forecastDays));
+    }
+
+    @Operation(summary = "预测历史")
+    @GetMapping("/history")
+    public R<Page<WaterDemandForecast>> getForecastHistory(
+            @RequestParam(required = false) String areaCode,
+            @RequestParam(defaultValue = "1") int page,
+            @RequestParam(defaultValue = "20") int size) {
+        return R.ok(forecastService.getForecastHistory(areaCode, page, size));
+    }
+
+    @Operation(summary = "历史趋势数据")
+    @GetMapping("/trend")
+    public R<List<HistoricalWaterDemand>> getHistoricalTrend(
+            @RequestParam String areaCode,
+            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate startDate,
+            @RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate endDate) {
+        return R.ok(forecastService.getHistoricalTrend(areaCode, startDate, endDate));
+    }
+
+    @Operation(summary = "生成演示数据")
+    @PostMapping("/demo-data")
+    public R<Map<String, Object>> generateDemoData(
+            @RequestParam String areaCode,
+            @RequestParam(defaultValue = "365") int days) {
+        int count = forecastService.generateDemoData(areaCode, days);
+        return R.ok(Map.of("generated", count, "areaCode", areaCode));
+    }
+}

wm-bi/src/main/java/com/water/bi/entity/HistoricalWaterDemand.java

@@ -0,0 +1,51 @@
+package com.water.bi.entity;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.water.common.core.entity.BaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+
+/**
+ * 历史需水量数据
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@TableName("bi_historical_water_demand")
+public class HistoricalWaterDemand extends BaseEntity {
+
+    /** 区域编码 */
+    private String areaCode;
+
+    /** 区域名称 */
+    private String areaName;
+
+    /** 日期 */
+    private LocalDate recordDate;
+
+    /** 需水量(m³) */
+    private BigDecimal volume;
+
+    /** 最高温度(℃) */
+    private BigDecimal maxTemp;
+
+    /** 最低温度(℃) */
+    private BigDecimal minTemp;
+
+    /** 天气状况: sunny/cloudy/rainy/snowy */
+    private String weather;
+
+    /** 降雨量(mm) */
+    private BigDecimal rainfall;
+
+    /** 是否节假日 */
+    private Boolean isHoliday;
+
+    /** 星期几(1=周一,7=周日) */
+    private Integer dayOfWeek;
+
+    /** 数据来源: METER/ESTIMATED */
+    private String dataSource;
+}

wm-bi/src/main/java/com/water/bi/entity/SchedulingRecommendation.java

@@ -0,0 +1,57 @@
+package com.water.bi.entity;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.water.common.core.entity.BaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+/**
+ * 调度推荐方案
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@TableName("bi_scheduling_recommendation")
+public class SchedulingRecommendation extends BaseEntity {
+
+    /** 关联预测ID */
+    private Long forecastId;
+
+    /** 方案名称 */
+    private String schemeName;
+
+    /** 方案类型: NORMAL / PEAK_SHIFT / EMERGENCY */
+    private String schemeType;
+
+    /** 推荐方案描述 */
+    private String description;
+
+    /** 泵站组合JSON [{"stationCode":"PS001","stationName":"一号泵站","flow":500}] */
+    private String pumpCombination;
+
+    /** 预计节水量(m³) */
+    private BigDecimal estimatedSaving;
+
+    /** 预计节能(kWh) */
+    private BigDecimal estimatedEnergySaving;
+
+    /** 方案评分(0-100) */
+    private BigDecimal score;
+
+    /** 执行时间窗口-开始 */
+    private LocalDateTime executeStart;
+
+    /** 执行时间窗口-结束 */
+    private LocalDateTime executeEnd;
+
+    /** 风险等级: LOW / MEDIUM / HIGH */
+    private String riskLevel;
+
+    /** 状态: PENDING / ACCEPTED / EXECUTING / COMPLETED / REJECTED */
+    private String status;
+
+    /** 备注 */
+    private String remark;
+}

wm-bi/src/main/java/com/water/bi/entity/WaterDemandForecast.java

@@ -0,0 +1,64 @@
+package com.water.bi.entity;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.water.common.core.entity.BaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+/**
+ * 需水量预测记录
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@TableName("bi_water_demand_forecast")
+public class WaterDemandForecast extends BaseEntity {
+
+    /** 区域编码 */
+    private String areaCode;
+
+    /** 区域名称 */
+    private String areaName;
+
+    /** 预测日期 */
+    private LocalDate forecastDate;
+
+    /** 预测水量(m³) */
+    private BigDecimal forecastVolume;
+
+    /** 实际水量(m³)，用于评估 */
+    private BigDecimal actualVolume;
+
+    /** 模型类型: MOVING_AVERAGE / EXPONENTIAL_SMOOTHING / SEASONAL_DECOMPOSITION */
+    private String modelType;
+
+    /** 模型参数JSON */
+    private String modelParams;
+
+    /** MAE */
+    private BigDecimal mae;
+
+    /** RMSE */
+    private BigDecimal rmse;
+
+    /** MAPE(%) */
+    private BigDecimal mape;
+
+    /** 置信度(0-1) */
+    private BigDecimal confidence;
+
+    /** 置信区间下限 */
+    private BigDecimal lowerBound;
+
+    /** 置信区间上限 */
+    private BigDecimal upperBound;
+
+    /** 预测生成时间 */
+    private LocalDateTime generateTime;
+
+    /** 备注 */
+    private String remark;
+}

wm-bi/src/main/java/com/water/bi/mapper/HistoricalWaterDemandMapper.java

@@ -0,0 +1,9 @@
+package com.water.bi.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.bi.entity.HistoricalWaterDemand;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface HistoricalWaterDemandMapper extends BaseMapper<HistoricalWaterDemand> {
+}

wm-bi/src/main/java/com/water/bi/mapper/SchedulingRecommendationMapper.java

@@ -0,0 +1,9 @@
+package com.water.bi.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.bi.entity.SchedulingRecommendation;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface SchedulingRecommendationMapper extends BaseMapper<SchedulingRecommendation> {
+}

wm-bi/src/main/java/com/water/bi/mapper/WaterDemandForecastMapper.java

@@ -0,0 +1,9 @@
+package com.water.bi.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.water.bi.entity.WaterDemandForecast;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface WaterDemandForecastMapper extends BaseMapper<WaterDemandForecast> {
+}

wm-bi/src/main/java/com/water/bi/service/SchedulingRecommendService.java

@@ -0,0 +1,350 @@
+package com.water.bi.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.water.bi.entity.SchedulingRecommendation;
+import com.water.bi.entity.WaterDemandForecast;
+import com.water.bi.mapper.SchedulingRecommendationMapper;
+import com.water.bi.mapper.WaterDemandForecastMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.LocalDateTime;
+import java.util.*;
+
+/**
+ * 调度推荐服务
+ * 基于预测结果生成调度方案：泵站组合优化/错峰调度/紧急预案/方案评分排序
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class SchedulingRecommendService {
+
+    private final SchedulingRecommendationMapper recommendMapper;
+    private final WaterDemandForecastMapper forecastMapper;
+
+    /** 泵站基础信息 */
+    private static final List<PumpStation> PUMP_STATIONS = List.of(
+            new PumpStation("PS001", "一号泵站（城北）", 800, 45, 0.92),
+            new PumpStation("PS002", "二号泵站（城南）", 600, 38, 0.89),
+            new PumpStation("PS003", "三号泵站（工业园）", 1000, 55, 0.94),
+            new PumpStation("PS004", "四号泵站（新城）", 500, 32, 0.87),
+            new PumpStation("PS005", "五号泵站（托托镇）", 400, 28, 0.85),
+            new PumpStation("PS006", "六号泵站（大河沿子）", 700, 42, 0.90)
+    );
+
+    /**
+     * 基于预测结果生成调度推荐方案
+     * @param forecastId 预测记录ID
+     * @return 推荐方案列表（按评分排序）
+     */
+    @Transactional
+    public List<SchedulingRecommendation> generateRecommendations(Long forecastId) {
+        WaterDemandForecast forecast = forecastMapper.selectById(forecastId);
+        if (forecast == null) {
+            throw new RuntimeException("预测记录不存在: " + forecastId);
+        }
+
+        double predictedVolume = forecast.getForecastVolume().doubleValue();
+        List<SchedulingRecommendation> recommendations = new ArrayList<>();
+
+        // 1. 常规调度方案（贪心算法选择最优泵站组合）
+        recommendations.add(generateNormalScheme(forecast, predictedVolume));
+
+        // 2. 错峰调度方案（避开高峰用电时段）
+        recommendations.add(generatePeakShiftScheme(forecast, predictedVolume));
+
+        // 3. 节能优先方案（选择效率最高的泵站组合）
+        recommendations.add(generateEnergySavingScheme(forecast, predictedVolume));
+
+        // 4. 紧急预案（高峰需求时的应急方案）
+        if (predictedVolume > 6000) {
+            recommendations.add(generateEmergencyScheme(forecast, predictedVolume));
+        }
+
+        // 5. 低成本方案（最小化运行成本）
+        recommendations.add(generateLowCostScheme(forecast, predictedVolume));
+
+        // 按评分排序
+        recommendations.sort((a, b) -> b.getScore().compareTo(a.getScore()));
+
+        // 保存
+        for (SchedulingRecommendation r : recommendations) {
+            recommendMapper.insert(r);
+        }
+
+        return recommendations;
+    }
+
+    /**
+     * 获取推荐列表
+     */
+    public Page<SchedulingRecommendation> getRecommendations(Long forecastId, int page, int size) {
+        LambdaQueryWrapper<SchedulingRecommendation> wrapper = new LambdaQueryWrapper<>();
+        if (forecastId != null) {
+            wrapper.eq(SchedulingRecommendation::getForecastId, forecastId);
+        }
+        wrapper.orderByDesc(SchedulingRecommendation::getScore);
+        return recommendMapper.selectPage(new Page<>(page, size), wrapper);
+    }
+
+    /**
+     * 采纳方案
+     */
+    @Transactional
+    public SchedulingRecommendation acceptRecommendation(Long id) {
+        SchedulingRecommendation rec = recommendMapper.selectById(id);
+        if (rec == null) throw new RuntimeException("方案不存在");
+        rec.setStatus("ACCEPTED");
+        recommendMapper.updateById(rec);
+        return rec;
+    }
+
+    /**
+     * 拒绝方案
+     */
+    @Transactional
+    public SchedulingRecommendation rejectRecommendation(Long id) {
+        SchedulingRecommendation rec = recommendMapper.selectById(id);
+        if (rec == null) throw new RuntimeException("方案不存在");
+        rec.setStatus("REJECTED");
+        recommendMapper.updateById(rec);
+        return rec;
+    }
+
+    /**
+     * 获取方案详情
+     */
+    public SchedulingRecommendation getById(Long id) {
+        return recommendMapper.selectById(id);
+    }
+
+    // ============ 方案生成算法 ============
+
+    /**
+     * 常规调度方案 - 贪心算法选择满足需求的最小泵站组合
+     */
+    private SchedulingRecommendation generateNormalScheme(WaterDemandForecast forecast, double demand) {
+        List<PumpStation> selected = greedySelectPumps(demand, false);
+        double totalCapacity = selected.stream().mapToDouble(p -> p.capacity).sum();
+        double saving = Math.max(0, totalCapacity - demand);
+
+        SchedulingRecommendation rec = new SchedulingRecommendation();
+        rec.setForecastId(forecast.getId());
+        rec.setSchemeName("常规调度方案");
+        rec.setSchemeType("NORMAL");
+        rec.setDescription(String.format("基于预测水量%.0fm³，选择%d座泵站组合供水，总容量%.0fm³",
+                demand, selected.size(), totalCapacity));
+        rec.setPumpCombination(toJson(selected, demand));
+        rec.setEstimatedSaving(BigDecimal.valueOf(saving * 0.15).setScale(2, RoundingMode.HALF_UP));
+        rec.setEstimatedEnergySaving(BigDecimal.valueOf(selected.stream().mapToDouble(p -> p.power * 0.1).sum()).setScale(2, RoundingMode.HALF_UP));
+        rec.setScore(calculateScore(selected, demand, 0.7, 0.2, 0.1));
+        rec.setExecuteStart(forecast.getForecastDate().atTime(6, 0));
+        rec.setExecuteEnd(forecast.getForecastDate().atTime(22, 0));
+        rec.setRiskLevel(demand > totalCapacity * 0.9 ? "HIGH" : demand > totalCapacity * 0.7 ? "MEDIUM" : "LOW");
+        rec.setStatus("PENDING");
+        return rec;
+    }
+
+    /**
+     * 错峰调度方案 - 在低谷时段蓄水，高峰时段减少供水
+     */
+    private SchedulingRecommendation generatePeakShiftScheme(WaterDemandForecast forecast, double demand) {
+        // 选择效率较高的泵站，在夜间低谷时段多供水
+        List<PumpStation> selected = PUMP_STATIONS.stream()
+                .sorted((a, b) -> Double.compare(b.efficiency, a.efficiency))
+                .limit(3)
+                .toList();
+
+        double totalCapacity = selected.stream().mapToDouble(p -> p.capacity).sum();
+        // 错峰可节约约20%能耗
+        double energySaving = selected.stream().mapToDouble(p -> p.power * 0.2).sum();
+
+        SchedulingRecommendation rec = new SchedulingRecommendation();
+        rec.setForecastId(forecast.getId());
+        rec.setSchemeName("错峰调度方案");
+        rec.setSchemeType("PEAK_SHIFT");
+        rec.setDescription(String.format("利用夜间低谷时段(22:00-06:00)蓄水，高峰时段减少泵站运行。预测水量%.0fm³", demand));
+        rec.setPumpCombination(toJson(selected, demand));
+        rec.setEstimatedSaving(BigDecimal.valueOf(demand * 0.08).setScale(2, RoundingMode.HALF_UP));
+        rec.setEstimatedEnergySaving(BigDecimal.valueOf(energySaving).setScale(2, RoundingMode.HALF_UP));
+        rec.setScore(calculateScore(selected, demand, 0.6, 0.3, 0.1));
+        rec.setExecuteStart(forecast.getForecastDate().atTime(22, 0));
+        rec.setExecuteEnd(forecast.getForecastDate().plusDays(1).atTime(6, 0));
+        rec.setRiskLevel("MEDIUM");
+        rec.setStatus("PENDING");
+        return rec;
+    }
+
+    /**
+     * 节能优先方案 - 选择效率最高的泵站
+     */
+    private SchedulingRecommendation generateEnergySavingScheme(WaterDemandForecast forecast, double demand) {
+        List<PumpStation> selected = PUMP_STATIONS.stream()
+                .filter(p -> p.efficiency >= 0.89)
+                .sorted((a, b) -> Double.compare(b.efficiency, a.efficiency))
+                .toList();
+
+        // 如果高效泵站不够，补充一个
+        if (selected.stream().mapToDouble(p -> p.capacity).sum() < demand * 0.8) {
+            List<PumpStation> more = PUMP_STATIONS.stream()
+                    .filter(p -> !selected.contains(p))
+                    .sorted((a, b) -> Double.compare(b.efficiency, a.efficiency))
+                    .limit(1)
+                    .toList();
+            List<PumpStation> combined = new ArrayList<>(selected);
+            combined.addAll(more);
+            selected = combined;
+        }
+
+        double totalCapacity = selected.stream().mapToDouble(p -> p.capacity).sum();
+        double energySaving = selected.stream().mapToDouble(p -> p.power * (p.efficiency - 0.85) * 2).sum();
+
+        SchedulingRecommendation rec = new SchedulingRecommendation();
+        rec.setForecastId(forecast.getId());
+        rec.setSchemeName("节能优先方案");
+        rec.setSchemeType("NORMAL");
+        rec.setDescription(String.format("优先选择高效泵站运行，降低能耗。预测水量%.0fm³，泵站平均效率%.2f",
+                demand, selected.stream().mapToDouble(p -> p.efficiency).average().orElse(0)));
+        rec.setPumpCombination(toJson(selected, demand));
+        rec.setEstimatedSaving(BigDecimal.valueOf(demand * 0.05).setScale(2, RoundingMode.HALF_UP));
+        rec.setEstimatedEnergySaving(BigDecimal.valueOf(Math.max(0, energySaving)).setScale(2, RoundingMode.HALF_UP));
+        rec.setScore(calculateScore(selected, demand, 0.5, 0.4, 0.1));
+        rec.setExecuteStart(forecast.getForecastDate().atTime(6, 0));
+        rec.setExecuteEnd(forecast.getForecastDate().atTime(22, 0));
+        rec.setRiskLevel(totalCapacity < demand ? "HIGH" : "LOW");
+        rec.setStatus("PENDING");
+        return rec;
+    }
+
+    /**
+     * 紧急预案 - 全泵站满负荷运行
+     */
+    private SchedulingRecommendation generateEmergencyScheme(WaterDemandForecast forecast, double demand) {
+        List<PumpStation> selected = new ArrayList<>(PUMP_STATIONS);
+        double totalCapacity = selected.stream().mapToDouble(p -> p.capacity).sum();
+
+        SchedulingRecommendation rec = new SchedulingRecommendation();
+        rec.setForecastId(forecast.getId());
+        rec.setSchemeName("紧急预案（高峰应急）");
+        rec.setSchemeType("EMERGENCY");
+        rec.setDescription(String.format("高峰需求紧急预案，启用全部%d座泵站满负荷运行。预测水量%.0fm³，总容量%.0fm³",
+                selected.size(), demand, totalCapacity));
+        rec.setPumpCombination(toJson(selected, demand));
+        rec.setEstimatedSaving(BigDecimal.ZERO);
+        rec.setEstimatedEnergySaving(BigDecimal.ZERO);
+        rec.setScore(calculateScore(selected, demand, 0.9, 0.0, 0.1));
+        rec.setExecuteStart(forecast.getForecastDate().atTime(0, 0));
+        rec.setExecuteEnd(forecast.getForecastDate().atTime(23, 59));
+        rec.setRiskLevel("HIGH");
+        rec.setStatus("PENDING");
+        return rec;
+    }
+
+    /**
+     * 低成本方案 - 选择运行成本最低的泵站组合
+     */
+    private SchedulingRecommendation generateLowCostScheme(WaterDemandForecast forecast, double demand) {
+        // 按单位成本排序（功率/容量 = 单位水量的能耗）
+        List<PumpStation> selected = PUMP_STATIONS.stream()
+                .sorted((a, b) -> Double.compare(a.power / a.capacity, b.power / b.capacity))
+                .toList();
+
+        List<PumpStation> chosen = new ArrayList<>();
+        double accumulated = 0;
+        for (PumpStation p : selected) {
+            if (accumulated >= demand) break;
+            chosen.add(p);
+            accumulated += p.capacity;
+        }
+
+        double totalCapacity = chosen.stream().mapToDouble(p -> p.capacity).sum();
+        double costSaving = chosen.stream().mapToDouble(p -> p.power * 0.15).sum();
+
+        SchedulingRecommendation rec = new SchedulingRecommendation();
+        rec.setForecastId(forecast.getId());
+        rec.setSchemeName("低成本方案");
+        rec.setSchemeType("NORMAL");
+        rec.setDescription(String.format("选择运行成本最低的泵站组合，单位水量能耗最优。预测水量%.0fm³", demand));
+        rec.setPumpCombination(toJson(chosen, demand));
+        rec.setEstimatedSaving(BigDecimal.valueOf(Math.max(0, totalCapacity - demand) * 0.1).setScale(2, RoundingMode.HALF_UP));
+        rec.setEstimatedEnergySaving(BigDecimal.valueOf(costSaving).setScale(2, RoundingMode.HALF_UP));
+        rec.setScore(calculateScore(chosen, demand, 0.6, 0.2, 0.2));
+        rec.setExecuteStart(forecast.getForecastDate().atTime(6, 0));
+        rec.setExecuteEnd(forecast.getForecastDate().atTime(22, 0));
+        rec.setRiskLevel(totalCapacity < demand * 1.1 ? "MEDIUM" : "LOW");
+        rec.setStatus("PENDING");
+        return rec;
+    }
+
+    // ============ 评分算法 ============
+
+    /**
+     * 综合评分 = 供需匹配度 * w1 + 能效评分 * w2 + 可靠性评分 * w3
+     */
+    private BigDecimal calculateScore(List<PumpStation> selected, double demand,
+                                       double w1, double w2, double w3) {
+        double totalCapacity = selected.stream().mapToDouble(p -> p.capacity).sum();
+        double avgEfficiency = selected.stream().mapToDouble(p -> p.efficiency).average().orElse(0);
+
+        // 供需匹配度：越接近1越好（不过度供水也不缺水）
+        double matchScore = totalCapacity >= demand
+                ? Math.max(0, 100 - (totalCapacity - demand) / demand * 100)
+                : totalCapacity / demand * 100;
+
+        // 能效评分
+        double efficiencyScore = avgEfficiency * 100;
+
+        // 可靠性评分（泵站越多越可靠）
+        double reliabilityScore = Math.min(100, selected.size() * 20.0);
+
+        double totalScore = matchScore * w1 + efficiencyScore * w2 + reliabilityScore * w3;
+        return BigDecimal.valueOf(Math.min(100, Math.max(0, totalScore))).setScale(1, RoundingMode.HALF_UP);
+    }
+
+    /**
+     * 贪心算法选择泵站组合
+     */
+    private List<PumpStation> greedySelectPumps(double demand, boolean efficiencyFirst) {
+        List<PumpStation> sorted = new ArrayList<>(PUMP_STATIONS);
+        if (efficiencyFirst) {
+            sorted.sort((a, b) -> Double.compare(b.efficiency, a.efficiency));
+        } else {
+            // 按容量降序
+            sorted.sort((a, b) -> Double.compare(b.capacity, a.capacity));
+        }
+
+        List<PumpStation> selected = new ArrayList<>();
+        double accumulated = 0;
+        for (PumpStation p : sorted) {
+            if (accumulated >= demand * 1.1) break; // 10%余量
+            selected.add(p);
+            accumulated += p.capacity;
+        }
+        return selected;
+    }
+
+    private String toJson(List<PumpStation> stations, double demand) {
+        StringBuilder sb = new StringBuilder("[");
+        double remaining = demand;
+        for (int i = 0; i < stations.size(); i++) {
+            PumpStation p = stations.get(i);
+            double flow = Math.min(p.capacity, remaining);
+            remaining -= flow;
+            if (i > 0) sb.append(",");
+            sb.append(String.format(
+                    "{\"stationCode\":\"%s\",\"stationName\":\"%s\",\"capacity\":%d,\"flow\":%.0f,\"power\":%d,\"efficiency\":%.2f}",
+                    p.code, p.name, p.capacity, Math.max(0, flow), p.power, p.efficiency));
+        }
+        sb.append("]");
+        return sb.toString();
+    }
+
+    /** 泵站信息 */
+    private record PumpStation(String code, String name, int capacity, int power, double efficiency) {}
+}

wm-bi/src/main/java/com/water/bi/service/WaterDemandForecastService.java

@@ -0,0 +1,532 @@
+package com.water.bi.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.water.bi.entity.HistoricalWaterDemand;
+import com.water.bi.entity.WaterDemandForecast;
+import com.water.bi.mapper.HistoricalWaterDemandMapper;
+import com.water.bi.mapper.WaterDemandForecastMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 需水量预测服务
+ * 实现三种预测模型：移动平均、指数平滑、季节性分解
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class WaterDemandForecastService {
+
+    private final WaterDemandForecastMapper forecastMapper;
+    private final HistoricalWaterDemandMapper historicalMapper;
+
+    /**
+     * 执行预测（指定区域和模型）
+     * @param areaCode 区域编码
+     * @param modelType 模型类型
+     * @param forecastDays 预测天数
+     * @return 预测结果列表
+     */
+    @Transactional
+    public List<WaterDemandForecast> forecast(String areaCode, String modelType, int forecastDays) {
+        // 获取历史数据（至少需要90天）
+        List<HistoricalWaterDemand> history = getHistoryData(areaCode, 180);
+        if (history.size() < 30) {
+            throw new RuntimeException("历史数据不足，至少需要30天数据");
+        }
+
+        double[] data = history.stream()
+                .mapToDouble(h -> h.getVolume().doubleValue())
+                .toArray();
+
+        List<WaterDemandForecast> results = new ArrayList<>();
+        LocalDate lastDate = history.get(history.size() - 1).getRecordDate();
+
+        switch (modelType.toUpperCase()) {
+            case "MOVING_AVERAGE":
+                results = movingAverageForecast(areaCode, data, lastDate, forecastDays, 7);
+                break;
+            case "EXPONENTIAL_SMOOTHING":
+                results = exponentialSmoothingForecast(areaCode, data, lastDate, forecastDays, 0.3);
+                break;
+            case "SEASONAL_DECOMPOSITION":
+                results = seasonalDecompositionForecast(areaCode, data, lastDate, forecastDays, 7);
+                break;
+            default:
+                throw new RuntimeException("不支持的模型类型: " + modelType);
+        }
+
+        // 计算模型评估指标
+        evaluateModel(results, data, modelType);
+
+        // 保存预测结果
+        for (WaterDemandForecast f : results) {
+            f.setGenerateTime(LocalDateTime.now());
+            forecastMapper.insert(f);
+        }
+
+        return results;
+    }
+
+    /**
+     * 多模型对比预测
+     */
+    @Transactional
+    public Map<String, Object> multiModelForecast(String areaCode, int forecastDays) {
+        List<String> models = List.of("MOVING_AVERAGE", "EXPONENTIAL_SMOOTHING", "SEASONAL_DECOMPOSITION");
+        Map<String, Object> comparison = new LinkedHashMap<>();
+
+        List<WaterDemandForecast> bestResults = null;
+        double bestMae = Double.MAX_VALUE;
+        String bestModel = null;
+
+        for (String model : models) {
+            try {
+                List<WaterDemandForecast> results = forecast(areaCode, model, forecastDays);
+                double mae = results.stream()
+                        .filter(r -> r.getMae() != null)
+                        .mapToDouble(r -> r.getMae().doubleValue())
+                        .average()
+                        .orElse(Double.MAX_VALUE);
+
+                Map<String, Object> modelResult = new HashMap<>();
+                modelResult.put("modelType", model);
+                modelResult.put("mae", results.isEmpty() ? null : results.get(0).getMae());
+                modelResult.put("rmse", results.isEmpty() ? null : results.get(0).getRmse());
+                modelResult.put("mape", results.isEmpty() ? null : results.get(0).getMape());
+                modelResult.put("forecasts", results);
+                comparison.put(model, modelResult);
+
+                if (mae < bestMae) {
+                    bestMae = mae;
+                    bestResults = results;
+                    bestModel = model;
+                }
+            } catch (Exception e) {
+                log.warn("模型 {} 预测失败: {}", model, e.getMessage());
+            }
+        }
+
+        comparison.put("bestModel", bestModel);
+        comparison.put("bestForecasts", bestResults);
+        return comparison;
+    }
+
+    /**
+     * 获取历史预测结果
+     */
+    public Page<WaterDemandForecast> getForecastHistory(String areaCode, int page, int size) {
+        LambdaQueryWrapper<WaterDemandForecast> wrapper = new LambdaQueryWrapper<>();
+        if (areaCode != null && !areaCode.isEmpty()) {
+            wrapper.eq(WaterDemandForecast::getAreaCode, areaCode);
+        }
+        wrapper.orderByDesc(WaterDemandForecast::getGenerateTime);
+        return forecastMapper.selectPage(new Page<>(page, size), wrapper);
+    }
+
+    /**
+     * 获取历史数据趋势
+     */
+    public List<HistoricalWaterDemand> getHistoricalTrend(String areaCode, LocalDate startDate, LocalDate endDate) {
+        LambdaQueryWrapper<HistoricalWaterDemand> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(HistoricalWaterDemand::getAreaCode, areaCode);
+        if (startDate != null) wrapper.ge(HistoricalWaterDemand::getRecordDate, startDate);
+        if (endDate != null) wrapper.le(HistoricalWaterDemand::getRecordDate, endDate);
+        wrapper.orderByAsc(HistoricalWaterDemand::getRecordDate);
+        return historicalMapper.selectList(wrapper);
+    }
+
+    // ============ 预测算法实现 ============
+
+    /**
+     * 移动平均法 (Simple Moving Average)
+     * 使用最近 window 天的平均值作为下一天的预测
+     */
+    private List<WaterDemandForecast> movingAverageForecast(String areaCode, double[] data,
+                                                             LocalDate lastDate, int forecastDays, int window) {
+        List<WaterDemandForecast> results = new ArrayList<>();
+        double[] extended = Arrays.copyOf(data, data.length + forecastDays);
+
+        for (int i = 0; i < forecastDays; i++) {
+            int start = Math.max(0, data.length + i - window);
+            int end = data.length + i;
+            double sum = 0;
+            int count = 0;
+            for (int j = start; j < end; j++) {
+                sum += extended[j];
+                count++;
+            }
+            double predicted = sum / count;
+            extended[data.length + i] = predicted;
+
+            // 计算置信区间（基于历史残差标准差）
+            double stdDev = calculateStdDev(data, window);
+            double lower = predicted - 1.96 * stdDev;
+            double upper = predicted + 1.96 * stdDev;
+
+            WaterDemandForecast f = createForecast(areaCode, lastDate.plusDays(i + 1),
+                    predicted, "MOVING_AVERAGE", lower, upper, 0.85);
+            f.setModelParams("{\"window\":" + window + "}");
+            results.add(f);
+        }
+        return results;
+    }
+
+    /**
+     * 指数平滑法 (Simple Exponential Smoothing)
+     * S(t) = α * Y(t-1) + (1-α) * S(t-1)
+     */
+    private List<WaterDemandForecast> exponentialSmoothingForecast(String areaCode, double[] data,
+                                                                     LocalDate lastDate, int forecastDays, double alpha) {
+        List<WaterDemandForecast> results = new ArrayList<>();
+
+        // 初始化：使用前7天的平均值
+        double initSum = 0;
+        int initCount = Math.min(7, data.length);
+        for (int i = 0; i < initCount; i++) initSum += data[i];
+        double smoothed = initSum / initCount;
+
+        // 遍历历史数据，更新平滑值
+        for (double datum : data) {
+            smoothed = alpha * datum + (1 - alpha) * smoothed;
+        }
+
+        // 计算残差标准差
+        double[] residuals = new double[data.length];
+        double s = initSum / initCount;
+        for (int i = 0; i < data.length; i++) {
+            if (i > 0) {
+                residuals[i] = data[i] - s;
+                s = alpha * data[i] + (1 - alpha) * s;
+            }
+        }
+        double stdDev = stdDevFromArray(residuals);
+
+        for (int i = 0; i < forecastDays; i++) {
+            double lower = smoothed - 1.96 * stdDev;
+            double upper = smoothed + 1.96 * stdDev;
+
+            WaterDemandForecast f = createForecast(areaCode, lastDate.plusDays(i + 1),
+                    smoothed, "EXPONENTIAL_SMOOTHING", lower, upper, 0.88);
+            f.setModelParams("{\"alpha\":" + alpha + "}");
+            results.add(f);
+        }
+        return results;
+    }
+
+    /**
+     * 季节性分解法 (Seasonal Decomposition + Trend)
+     * Y(t) = Trend(t) + Seasonal(t % period) + Residual
+     * 预测: Y(t+h) = Trend(t+h) + Seasonal((t+h) % period)
+     */
+    private List<WaterDemandForecast> seasonalDecompositionForecast(String areaCode, double[] data,
+                                                                      LocalDate lastDate, int forecastDays, int period) {
+        List<WaterDemandForecast> results = new ArrayList<>();
+        int n = data.length;
+
+        // Step 1: 计算季节性分量（每周7天一个周期）
+        double[] seasonal = new double[period];
+        int[] seasonalCount = new int[period];
+
+        // 去趋势：用移动平均
+        double[] trend = new double[n];
+        int halfWindow = period / 2;
+        for (int i = 0; i < n; i++) {
+            int start = Math.max(0, i - halfWindow);
+            int end = Math.min(n - 1, i + halfWindow);
+            double sum = 0;
+            int count = 0;
+            for (int j = start; j <= end; j++) {
+                sum += data[j];
+                count++;
+            }
+            trend[i] = sum / count;
+        }
+
+        // 计算季节性指数
+        for (int i = halfWindow; i < n - halfWindow; i++) {
+            int idx = i % period;
+            seasonal[idx] += (data[i] - trend[i]);
+            seasonalCount[idx]++;
+        }
+        for (int i = 0; i < period; i++) {
+            if (seasonalCount[i] > 0) {
+                seasonal[i] /= seasonalCount[i];
+            }
+        }
+
+        // Step 2: 趋势外推（线性回归）
+        // 用最后60天数据拟合趋势
+        int trendPoints = Math.min(60, n);
+        double sumX = 0, sumY = 0, sumXY = 0, sumXX = 0;
+        for (int i = n - trendPoints; i < n; i++) {
+            double deseasonalized = data[i] - seasonal[i % period];
+            sumX += i;
+            sumY += deseasonalized;
+            sumXY += i * deseasonalized;
+            sumXX += i * i;
+        }
+        double slope = (trendPoints * sumXY - sumX * sumY) / (trendPoints * sumXX - sumX * sumX);
+        double intercept = (sumY - slope * sumX) / trendPoints;
+
+        // Step 3: 预测
+        double[] residuals = new double[n];
+        for (int i = halfWindow; i < n - halfWindow; i++) {
+            residuals[i] = data[i] - trend[i] - seasonal[i % period];
+        }
+        double stdDev = stdDevFromArray(residuals);
+
+        for (int i = 0; i < forecastDays; i++) {
+            int futureIdx = n + i;
+            double trendValue = slope * futureIdx + intercept;
+            double seasonalValue = seasonal[futureIdx % period];
+            double predicted = trendValue + seasonalValue;
+
+            double lower = predicted - 1.96 * stdDev;
+            double upper = predicted + 1.96 * stdDev;
+
+            WaterDemandForecast f = createForecast(areaCode, lastDate.plusDays(i + 1),
+                    predicted, "SEASONAL_DECOMPOSITION", lower, upper, 0.92);
+            f.setModelParams("{\"period\":" + period + ",\"slope\":" + slope + ",\"intercept\":" + intercept + "}");
+            results.add(f);
+        }
+        return results;
+    }
+
+    // ============ 模型评估 ============
+
+    /**
+     * 使用回测法评估模型（用最后30天作为验证集）
+     */
+    private void evaluateModel(List<WaterDemandForecast> forecasts, double[] data, String modelType) {
+        int validationSize = Math.min(30, data.length / 3);
+        if (validationSize < 7) return;
+
+        double[] trainData = Arrays.copyOfRange(data, 0, data.length - validationSize);
+        double[] validationData = Arrays.copyOfRange(data, data.length - validationSize, data.length);
+
+        double sumAbsError = 0;
+        double sumSqError = 0;
+        double sumAbsPctError = 0;
+        int count = 0;
+
+        for (int i = 1; i < validationSize; i++) {
+            double[] subTrain = Arrays.copyOf(trainData, trainData.length + i);
+            double predicted;
+            switch (modelType) {
+                case "MOVING_AVERAGE":
+                    predicted = simpleMovingAvgPredict(subTrain, 7);
+                    break;
+                case "EXPONENTIAL_SMOOTHING":
+                    predicted = simpleExpSmoothPredict(subTrain, 0.3);
+                    break;
+                case "SEASONAL_DECOMPOSITION":
+                    predicted = simpleSeasonalPredict(subTrain, 7, subTrain.length);
+                    break;
+                default:
+                    predicted = subTrain[subTrain.length - 1];
+            }
+
+            double actual = validationData[i];
+            double error = Math.abs(actual - predicted);
+            sumAbsError += error;
+            sumSqError += error * error;
+            if (actual != 0) sumAbsPctError += error / Math.abs(actual);
+            count++;
+        }
+
+        if (count > 0 && !forecasts.isEmpty()) {
+            double mae = sumAbsError / count;
+            double rmse = Math.sqrt(sumSqError / count);
+            double mape = (sumAbsPctError / count) * 100;
+
+            BigDecimal maeBd = BigDecimal.valueOf(mae).setScale(2, RoundingMode.HALF_UP);
+            BigDecimal rmseBd = BigDecimal.valueOf(rmse).setScale(2, RoundingMode.HALF_UP);
+            BigDecimal mapeBd = BigDecimal.valueOf(mape).setScale(2, RoundingMode.HALF_UP);
+
+            for (WaterDemandForecast f : forecasts) {
+                f.setMae(maeBd);
+                f.setRmse(rmseBd);
+                f.setMape(mapeBd);
+            }
+        }
+    }
+
+    private double simpleMovingAvgPredict(double[] data, int window) {
+        int start = Math.max(0, data.length - window);
+        double sum = 0;
+        int count = 0;
+        for (int i = start; i < data.length; i++) {
+            sum += data[i];
+            count++;
+        }
+        return sum / count;
+    }
+
+    private double simpleExpSmoothPredict(double[] data, double alpha) {
+        double s = data[0];
+        for (double d : data) {
+            s = alpha * d + (1 - alpha) * s;
+        }
+        return s;
+    }
+
+    private double simpleSeasonalPredict(double[] data, int period, int futureIdx) {
+        int n = data.length;
+        double[] seasonal = new double[period];
+        int[] cnt = new int[period];
+        double avg = Arrays.stream(data).average().orElse(0);
+        for (int i = 0; i < n; i++) {
+            seasonal[i % period] += (data[i] - avg);
+            cnt[i % period]++;
+        }
+        for (int i = 0; i < period; i++) {
+            if (cnt[i] > 0) seasonal[i] /= cnt[i];
+        }
+        return avg + seasonal[futureIdx % period];
+    }
+
+    // ============ 工具方法 ============
+
+    private List<HistoricalWaterDemand> getHistoryData(String areaCode, int days) {
+        LocalDate startDate = LocalDate.now().minusDays(days);
+        LambdaQueryWrapper<HistoricalWaterDemand> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(HistoricalWaterDemand::getAreaCode, areaCode)
+                .ge(HistoricalWaterDemand::getRecordDate, startDate)
+                .orderByAsc(HistoricalWaterDemand::getRecordDate);
+        return historicalMapper.selectList(wrapper);
+    }
+
+    private WaterDemandForecast createForecast(String areaCode, LocalDate date, double volume,
+                                                String modelType, double lower, double upper, double confidence) {
+        WaterDemandForecast f = new WaterDemandForecast();
+        f.setAreaCode(areaCode);
+        f.setAreaName(getAreaName(areaCode));
+        f.setForecastDate(date);
+        f.setForecastVolume(BigDecimal.valueOf(Math.max(0, volume)).setScale(2, RoundingMode.HALF_UP));
+        f.setModelType(modelType);
+        f.setLowerBound(BigDecimal.valueOf(Math.max(0, lower)).setScale(2, RoundingMode.HALF_UP));
+        f.setUpperBound(BigDecimal.valueOf(Math.max(0, upper)).setScale(2, RoundingMode.HALF_UP));
+        f.setConfidence(BigDecimal.valueOf(confidence));
+        return f;
+    }
+
+    private String getAreaName(String areaCode) {
+        Map<String, String> areaMap = Map.of(
+                "JH_001", "精河县城北区",
+                "JH_002", "精河县城南区",
+                "JH_003", "精河县工业园",
+                "JH_004", "精河县新城区",
+                "JH_005", "托托镇供水区",
+                "JH_006", "大河沿子镇"
+        );
+        return areaMap.getOrDefault(areaCode, areaCode);
+    }
+
+    private double calculateStdDev(double[] data, int window) {
+        if (data.length < window + 1) return 0;
+        double[] residuals = new double[data.length - window];
+        for (int i = window; i < data.length; i++) {
+            double sum = 0;
+            for (int j = i - window; j < i; j++) sum += data[j];
+            double predicted = sum / window;
+            residuals[i - window] = data[i] - predicted;
+        }
+        return stdDevFromArray(residuals);
+    }
+
+    private double stdDevFromArray(double[] values) {
+        if (values.length <= 1) return 0;
+        double mean = Arrays.stream(values).average().orElse(0);
+        double sumSqDiff = 0;
+        for (double v : values) {
+            double diff = v - mean;
+            sumSqDiff += diff * diff;
+        }
+        return Math.sqrt(sumSqDiff / (values.length - 1));
+    }
+
+    /**
+     * 生成/补充历史模拟数据（用于演示）
+     */
+    @Transactional
+    public int generateDemoData(String areaCode, int days) {
+        Random random = new Random(42);
+        int count = 0;
+        LocalDate today = LocalDate.now();
+
+        for (int i = days; i >= 1; i--) {
+            LocalDate date = today.minusDays(i);
+            DayOfWeek dow = date.getDayOfWeek();
+
+            // 基础水量 + 季节性 + 星期效应 + 随机噪声
+            double base = 5000;
+            // 夏季水量高
+            int month = date.getMonthValue();
+            double seasonal = (month >= 5 && month <= 9) ? 1500 : (month >= 11 || month <= 2) ? -800 : 0;
+            // 周末水量低
+            double weekendEffect = (dow == DayOfWeek.SATURDAY || dow == DayOfWeek.SUNDAY) ? -600 : 0;
+            // 温度影响
+            double temp = 15 + 15 * Math.sin((month - 3) * Math.PI / 6) + random.nextGaussian() * 3;
+            double tempEffect = Math.max(0, (temp - 20)) * 50;
+            // 节假日
+            boolean isHoliday = isChineseHoliday(date);
+            double holidayEffect = isHoliday ? -1000 : 0;
+            // 随机噪声
+            double noise = random.nextGaussian() * 200;
+
+            double volume = base + seasonal + weekendEffect + tempEffect + holidayEffect + noise;
+            volume = Math.max(1000, volume);
+
+            HistoricalWaterDemand record = new HistoricalWaterDemand();
+            record.setAreaCode(areaCode);
+            record.setAreaName(getAreaName(areaCode));
+            record.setRecordDate(date);
+            record.setVolume(BigDecimal.valueOf(volume).setScale(2, RoundingMode.HALF_UP));
+            record.setMaxTemp(BigDecimal.valueOf(temp + 5).setScale(1, RoundingMode.HALF_UP));
+            record.setMinTemp(BigDecimal.valueOf(temp - 5).setScale(1, RoundingMode.HALF_UP));
+            record.setWeather(randomWeather(random));
+            record.setRainfall(BigDecimal.valueOf(Math.max(0, random.nextGaussian() * 5)).setScale(1, RoundingMode.HALF_UP));
+            record.setIsHoliday(isHoliday);
+            record.setDayOfWeek(dow.getValue());
+            record.setDataSource("SIMULATED");
+
+            // 检查是否已存在
+            LambdaQueryWrapper<HistoricalWaterDemand> check = new LambdaQueryWrapper<>();
+            check.eq(HistoricalWaterDemand::getAreaCode, areaCode)
+                    .eq(HistoricalWaterDemand::getRecordDate, date);
+            if (historicalMapper.selectCount(check) == 0) {
+                historicalMapper.insert(record);
+                count++;
+            }
+        }
+        return count;
+    }
+
+    private boolean isChineseHoliday(LocalDate date) {
+        // 简化的节假日判断
+        int m = date.getMonthValue();
+        int d = date.getDayOfMonth();
+        if (m == 1 && d >= 1 && d <= 3) return true; // 元旦
+        if (m == 1 && d >= 21 && d <= 27) return true; // 春节(近似)
+        if (m == 5 && d >= 1 && d <= 5) return true; // 五一
+        if (m == 10 && d >= 1 && d <= 7) return true; // 国庆
+        return false;
+    }
+
+    private String randomWeather(Random random) {
+        String[] weathers = {"sunny", "cloudy", "rainy", "overcast"};
+        return weathers[random.nextInt(weathers.length)];
+    }
+}

wm-bi/src/test/java/com/water/bi/service/SchedulingRecommendServiceTest.java

@@ -0,0 +1,141 @@
+package com.water.bi.service;
+
+import com.water.bi.entity.SchedulingRecommendation;
+import com.water.bi.entity.WaterDemandForecast;
+import com.water.bi.mapper.SchedulingRecommendationMapper;
+import com.water.bi.mapper.WaterDemandForecastMapper;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class SchedulingRecommendServiceTest {
+
+    @Mock
+    private SchedulingRecommendationMapper recommendMapper;
+
+    @Mock
+    private WaterDemandForecastMapper forecastMapper;
+
+    @InjectMocks
+    private SchedulingRecommendService service;
+
+    private WaterDemandForecast mockForecast;
+
+    @BeforeEach
+    void setup() {
+        mockForecast = new WaterDemandForecast();
+        mockForecast.setId(1L);
+        mockForecast.setAreaCode("JH_001");
+        mockForecast.setForecastDate(LocalDate.now().plusDays(1));
+        mockForecast.setForecastVolume(BigDecimal.valueOf(5500));
+        mockForecast.setGenerateTime(LocalDateTime.now());
+
+        when(forecastMapper.selectById(1L)).thenReturn(mockForecast);
+        when(recommendMapper.insert(any())).thenReturn(1);
+    }
+
+    @Test
+    void testGenerateRecommendations() {
+        List<SchedulingRecommendation> results = service.generateRecommendations(1L);
+
+        assertNotNull(results);
+        assertTrue(results.size() >= 4); // At least 4 schemes (no emergency for 5500 < 6000)
+        for (SchedulingRecommendation rec : results) {
+            assertNotNull(rec.getSchemeName());
+            assertNotNull(rec.getSchemeType());
+            assertNotNull(rec.getScore());
+            assertTrue(rec.getScore().doubleValue() >= 0 && rec.getScore().doubleValue() <= 100);
+            assertNotNull(rec.getPumpCombination());
+            assertTrue(rec.getPumpCombination().startsWith("["));
+            assertEquals("PENDING", rec.getStatus());
+        }
+    }
+
+    @Test
+    void testHighDemandIncludesEmergency() {
+        mockForecast.setForecastVolume(BigDecimal.valueOf(8000));
+        List<SchedulingRecommendation> results = service.generateRecommendations(1L);
+
+        assertTrue(results.size() >= 5); // Includes emergency scheme
+        boolean hasEmergency = results.stream()
+                .anyMatch(r -> "EMERGENCY".equals(r.getSchemeType()));
+        assertTrue(hasEmergency);
+    }
+
+    @Test
+    void testRecommendationsSortedByScore() {
+        List<SchedulingRecommendation> results = service.generateRecommendations(1L);
+
+        for (int i = 1; i < results.size(); i++) {
+            assertTrue(results.get(i - 1).getScore().compareTo(results.get(i).getScore()) >= 0,
+                    "Should be sorted by score descending");
+        }
+    }
+
+    @Test
+    void testAcceptRecommendation() {
+        SchedulingRecommendation rec = new SchedulingRecommendation();
+        rec.setId(1L);
+        rec.setStatus("PENDING");
+        when(recommendMapper.selectById(1L)).thenReturn(rec);
+
+        SchedulingRecommendation accepted = service.acceptRecommendation(1L);
+
+        assertEquals("ACCEPTED", accepted.getStatus());
+        verify(recommendMapper).updateById(any());
+    }
+
+    @Test
+    void testRejectRecommendation() {
+        SchedulingRecommendation rec = new SchedulingRecommendation();
+        rec.setId(1L);
+        rec.setStatus("PENDING");
+        when(recommendMapper.selectById(1L)).thenReturn(rec);
+
+        SchedulingRecommendation rejected = service.rejectRecommendation(1L);
+
+        assertEquals("REJECTED", rejected.getStatus());
+    }
+
+    @Test
+    void testForecastNotFound() {
+        when(forecastMapper.selectById(999L)).thenReturn(null);
+        assertThrows(RuntimeException.class, () -> service.generateRecommendations(999L));
+    }
+
+    @Test
+    void testPumpCombinationJson() {
+        List<SchedulingRecommendation> results = service.generateRecommendations(1L);
+
+        for (SchedulingRecommendation rec : results) {
+            String json = rec.getPumpCombination();
+            assertTrue(json.contains("stationCode"));
+            assertTrue(json.contains("stationName"));
+            assertTrue(json.contains("capacity"));
+            assertTrue(json.contains("flow"));
+        }
+    }
+
+    @Test
+    void testRiskLevelAssigned() {
+        List<SchedulingRecommendation> results = service.generateRecommendations(1L);
+
+        for (SchedulingRecommendation rec : results) {
+            assertNotNull(rec.getRiskLevel());
+            assertTrue(List.of("LOW", "MEDIUM", "HIGH").contains(rec.getRiskLevel()));
+        }
+    }
+}

wm-bi/src/test/java/com/water/bi/service/WaterDemandForecastServiceTest.java

@@ -0,0 +1,163 @@
+package com.water.bi.service;
+
+import com.water.bi.entity.HistoricalWaterDemand;
+import com.water.bi.entity.WaterDemandForecast;
+import com.water.bi.mapper.HistoricalWaterDemandMapper;
+import com.water.bi.mapper.WaterDemandForecastMapper;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class WaterDemandForecastServiceTest {
+
+    @Mock
+    private WaterDemandForecastMapper forecastMapper;
+
+    @Mock
+    private HistoricalWaterDemandMapper historicalMapper;
+
+    @InjectMocks
+    private WaterDemandForecastService service;
+
+    private List<HistoricalWaterDemand> mockHistory;
+
+    @BeforeEach
+    void setup() {
+        mockHistory = new ArrayList<>();
+        // Generate 90 days of mock data
+        for (int i = 90; i >= 1; i--) {
+            HistoricalWaterDemand record = new HistoricalWaterDemand();
+            record.setAreaCode("JH_001");
+            record.setAreaName("精河县城北区");
+            record.setRecordDate(LocalDate.now().minusDays(i));
+            // Simulate seasonal pattern + weekly pattern
+            double base = 5000 + Math.sin(i * 2 * Math.PI / 365) * 1000 + (i % 7 < 2 ? -500 : 200);
+            record.setVolume(BigDecimal.valueOf(base));
+            record.setDayOfWeek(record.getRecordDate().getDayOfWeek().getValue());
+            mockHistory.add(record);
+        }
+
+        when(historicalMapper.selectList(any())).thenReturn(mockHistory);
+        when(forecastMapper.insert(any())).thenReturn(1);
+    }
+
+    @Test
+    void testMovingAverageForecast() {
+        List<WaterDemandForecast> results = service.forecast("JH_001", "MOVING_AVERAGE", 7);
+
+        assertNotNull(results);
+        assertEquals(7, results.size());
+        for (WaterDemandForecast f : results) {
+            assertNotNull(f.getForecastVolume());
+            assertTrue(f.getForecastVolume().doubleValue() > 0);
+            assertEquals("MOVING_AVERAGE", f.getModelType());
+            assertEquals("JH_001", f.getAreaCode());
+            assertNotNull(f.getLowerBound());
+            assertNotNull(f.getUpperBound());
+            assertTrue(f.getUpperBound().doubleValue() >= f.getLowerBound().doubleValue());
+        }
+        verify(forecastMapper, times(7)).insert(any());
+    }
+
+    @Test
+    void testExponentialSmoothingForecast() {
+        List<WaterDemandForecast> results = service.forecast("JH_001", "EXPONENTIAL_SMOOTHING", 5);
+
+        assertNotNull(results);
+        assertEquals(5, results.size());
+        for (WaterDemandForecast f : results) {
+            assertNotNull(f.getForecastVolume());
+            assertTrue(f.getForecastVolume().doubleValue() > 0);
+            assertEquals("EXPONENTIAL_SMOOTHING", f.getModelType());
+        }
+    }
+
+    @Test
+    void testSeasonalDecompositionForecast() {
+        List<WaterDemandForecast> results = service.forecast("JH_001", "SEASONAL_DECOMPOSITION", 7);
+
+        assertNotNull(results);
+        assertEquals(7, results.size());
+        for (WaterDemandForecast f : results) {
+            assertNotNull(f.getForecastVolume());
+            assertTrue(f.getForecastVolume().doubleValue() > 0);
+            assertEquals("SEASONAL_DECOMPOSITION", f.getModelType());
+            assertNotNull(f.getModelParams());
+            assertTrue(f.getModelParams().contains("period"));
+        }
+    }
+
+    @Test
+    void testMultiModelForecast() {
+        var results = service.multiModelForecast("JH_001", 7);
+
+        assertNotNull(results);
+        assertNotNull(results.get("bestModel"));
+        assertTrue(results.containsKey("MOVING_AVERAGE"));
+        assertTrue(results.containsKey("EXPONENTIAL_SMOOTHING"));
+        assertTrue(results.containsKey("SEASONAL_DECOMPOSITION"));
+    }
+
+    @Test
+    void testInsufficientData() {
+        when(historicalMapper.selectList(any())).thenReturn(List.of());
+
+        assertThrows(RuntimeException.class, () ->
+                service.forecast("JH_001", "MOVING_AVERAGE", 7));
+    }
+
+    @Test
+    void testInvalidModelType() {
+        assertThrows(RuntimeException.class, () ->
+                service.forecast("JH_001", "INVALID_MODEL", 7));
+    }
+
+    @Test
+    void testGenerateDemoData() {
+        when(historicalMapper.selectCount(any())).thenReturn(0L);
+        when(historicalMapper.insert(any())).thenReturn(1);
+
+        int count = service.generateDemoData("JH_001", 30);
+
+        assertEquals(30, count);
+        verify(historicalMapper, times(30)).insert(any());
+    }
+
+    @Test
+    void testForecastDatesSequential() {
+        List<WaterDemandForecast> results = service.forecast("JH_001", "MOVING_AVERAGE", 7);
+
+        LocalDate prevDate = null;
+        for (WaterDemandForecast f : results) {
+            if (prevDate != null) {
+                assertEquals(prevDate.plusDays(1), f.getForecastDate());
+            }
+            prevDate = f.getForecastDate();
+        }
+    }
+
+    @Test
+    void testConfidenceIntervalBounds() {
+        List<WaterDemandForecast> results = service.forecast("JH_001", "SEASONAL_DECOMPOSITION", 7);
+
+        for (WaterDemandForecast f : results) {
+            assertTrue(f.getUpperBound().doubleValue() >= f.getForecastVolume().doubleValue(),
+                    "Upper bound should be >= forecast");
+            assertTrue(f.getLowerBound().doubleValue() <= f.getForecastVolume().doubleValue(),
+                    "Lower bound should be <= forecast");
+        }
+    }
+}