refactor: 重构设备同步服务支持多公司动态数据源

@@ -9,6 +9,7 @@ import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.bind.annotation.RestController;
 
 
+import java.util.Collections;
 import java.util.Map;
 import java.util.Map;
 
 
 @RestController
 @RestController
@@ -23,217 +24,208 @@ public class HealthController {
     @Resource
     @Resource
     private EnergyPullService energyPullService;
     private EnergyPullService energyPullService;
 
 
+    /**
+     * corpCode为空时的统一空数据响应
+     */
+    private static Map<String, Object> emptyResult() {
+        return Collections.emptyMap();
+    }
+
     @GetMapping("/health")
     @GetMapping("/health")
-    public String health() throws Exception {
-        devicePullService.pullDeviceAndPushToIot();
+    public String health(@RequestParam(required = false) String corpCode) throws Exception {
+        if (!isValidCorpCode(corpCode)) return "corpCode不能为空";
+        devicePullService.pullDeviceAndPushToIot(corpCode);
         return "IoT Scheduler is running...";
         return "IoT Scheduler is running...";
     }
     }
 
 
     @GetMapping("/device/list")
     @GetMapping("/device/list")
     public Map<String, Object> deviceList(
     public Map<String, Object> deviceList(
+            @RequestParam(required = false) String corpCode,
             @RequestParam(required = false) String deviceName,
             @RequestParam(required = false) String deviceName,
             @RequestParam(required = false) String lampState,
             @RequestParam(required = false) String lampState,
             @RequestParam(defaultValue = "1") Integer pageNo,
             @RequestParam(defaultValue = "1") Integer pageNo,
             @RequestParam(defaultValue = "10") Integer pageSize) {
             @RequestParam(defaultValue = "10") Integer pageSize) {
-        return deviceSearchService.queryDeviceList(deviceName, lampState, pageNo, pageSize);
+        if (!isValidCorpCode(corpCode)) return emptyResult();
+        return deviceSearchService.queryDeviceList(corpCode, deviceName, lampState, pageNo, pageSize);
     }
     }
 
 
     @GetMapping("/device/stats")
     @GetMapping("/device/stats")
-    public Map<String, Object> deviceStats() {
-        return deviceSearchService.queryDeviceStats();
+    public Map<String, Object> deviceStats(@RequestParam(required = false) String corpCode) {
+        if (!isValidCorpCode(corpCode)) return emptyResult();
+        return deviceSearchService.queryDeviceStats(corpCode);
     }
     }
 
 
     @GetMapping("/device/lampData")
     @GetMapping("/device/lampData")
     public Map<String, Object> lampData(
     public Map<String, Object> lampData(
+            @RequestParam(required = false) String corpCode,
             @RequestParam String dtuSn,
             @RequestParam String dtuSn,
             @RequestParam String date) {
             @RequestParam String date) {
-        return deviceSearchService.queryLampData(dtuSn, date);
+        if (!isValidCorpCode(corpCode)) return emptyResult();
+        return deviceSearchService.queryLampData(corpCode, dtuSn, date);
     }
     }
 
 
     @GetMapping("/device/syncDevUtil")
     @GetMapping("/device/syncDevUtil")
-    public String syncDevUtil() {
-        devicePullService.pullDevUtilAndSave();
+    public String syncDevUtil(@RequestParam(required = false) String corpCode) {
+        if (!isValidCorpCode(corpCode)) return "corpCode不能为空";
+        devicePullService.pullDevUtilAndSave(corpCode);
         return "设备利用率数据同步完成";
         return "设备利用率数据同步完成";
     }
     }
 
 
     @GetMapping("/device/syncOee")
     @GetMapping("/device/syncOee")
-    public String syncOee() {
-        devicePullService.pullOeeAndSave();
+    public String syncOee(@RequestParam(required = false) String corpCode) {
+        if (!isValidCorpCode(corpCode)) return "corpCode不能为空";
+        devicePullService.pullOeeAndSave(corpCode);
         return "OEE时序数据同步完成";
         return "OEE时序数据同步完成";
     }
     }
 
 
     @GetMapping("/device/oeeStats")
     @GetMapping("/device/oeeStats")
     public Map<String, Object> oeeStats(
     public Map<String, Object> oeeStats(
+            @RequestParam(required = false) String corpCode,
             @RequestParam String dtuSn,
             @RequestParam String dtuSn,
             @RequestParam(defaultValue = "day") String type,
             @RequestParam(defaultValue = "day") String type,
             @RequestParam(required = false) String startDate,
             @RequestParam(required = false) String startDate,
             @RequestParam(required = false) String endDate) {
             @RequestParam(required = false) String endDate) {
-        return deviceSearchService.queryOeeStats(dtuSn, type, startDate, endDate);
+        if (!isValidCorpCode(corpCode)) return emptyResult();
+        return deviceSearchService.queryOeeStats(corpCode, dtuSn, type, startDate, endDate);
     }
     }
 
 
     /**
     /**
      * OEE时序图分页查询（含稼动率）
      * OEE时序图分页查询（含稼动率）
-     * 查询所有设备在指定日期范围内的OEE时序数据，分页返回（每页最多20条）
-     *
-     * @param startDate 开始日期 yyyy-MM-dd
-     * @param endDate   结束日期 yyyy-MM-dd
-     * @param pageNo    页码，默认1
-     * @param pageSize  每页条数，最大20，默认20
      */
      */
     @GetMapping("/device/oeeTimeline")
     @GetMapping("/device/oeeTimeline")
     public Map<String, Object> oeeTimeline(
     public Map<String, Object> oeeTimeline(
+            @RequestParam(required = false) String corpCode,
             @RequestParam String startDate,
             @RequestParam String startDate,
             @RequestParam String endDate,
             @RequestParam String endDate,
             @RequestParam(defaultValue = "1") Integer pageNo,
             @RequestParam(defaultValue = "1") Integer pageNo,
             @RequestParam(defaultValue = "20") Integer pageSize) {
             @RequestParam(defaultValue = "20") Integer pageSize) {
-        return deviceSearchService.queryOeeTimeline(startDate, endDate, pageNo, pageSize);
+        if (!isValidCorpCode(corpCode)) return emptyResult();
+        return deviceSearchService.queryOeeTimeline(corpCode, startDate, endDate, pageNo, pageSize);
     }
     }
 
 
     /**
     /**
      * 智能灯统计稼动率查询（仪表盘）
      * 智能灯统计稼动率查询（仪表盘）
-     * 支持日/周/月查询，返回总时长、稼动率、当前机台状态、异常排行榜、每设备状态时长
-     *
-     * @param startDate 开始日期 yyyy-MM-dd (day模式必填)
-     * @param endDate   结束日期 yyyy-MM-dd (day模式必填)
      */
      */
     @GetMapping("/device/lampStatistics")
     @GetMapping("/device/lampStatistics")
     public Map<String, Object> lampStatistics(
     public Map<String, Object> lampStatistics(
+            @RequestParam(required = false) String corpCode,
             @RequestParam(required = false) String startDate,
             @RequestParam(required = false) String startDate,
             @RequestParam(required = false) String endDate) {
             @RequestParam(required = false) String endDate) {
-        return deviceSearchService.queryLampStatistics(startDate, endDate);
+        if (!isValidCorpCode(corpCode)) return emptyResult();
+        return deviceSearchService.queryLampStatistics(corpCode, startDate, endDate);
     }
     }
 
 
     /**
     /**
      * 开机率查询（基于 dev_util 表）
      * 开机率查询（基于 dev_util 表）
-     * 灭灯(state=0)=未开机，其他灯=开机，每台设备单独计算，不分页
-     *
-     * @param startDate 开始日期 yyyy-MM-dd
-     * @param endDate   结束日期 yyyy-MM-dd
      */
      */
     @GetMapping("/device/bootRate")
     @GetMapping("/device/bootRate")
     public Map<String, Object> bootRate(
     public Map<String, Object> bootRate(
+            @RequestParam(required = false) String corpCode,
             @RequestParam String startDate,
             @RequestParam String startDate,
             @RequestParam String endDate) {
             @RequestParam String endDate) {
-        return deviceSearchService.queryBootRate(startDate, endDate);
+        if (!isValidCorpCode(corpCode)) return emptyResult();
+        return deviceSearchService.queryBootRate(corpCode, startDate, endDate);
     }
     }
 
 
     @GetMapping("/energy/history")
     @GetMapping("/energy/history")
-    public void energyHistory() {
-        energyPullService.pullEnergyHistoryAndSave();
+    public void energyHistory(@RequestParam(required = false) String corpCode) {
+        if (isValidCorpCode(corpCode)) energyPullService.pullEnergyHistoryAndSave(corpCode);
     }
     }
 
 
     /**
     /**
      * 分页查询能耗设备信息
      * 分页查询能耗设备信息
-     *
-     * @param deviceName 设备名称（模糊匹配）
-     * @param runStatus  状态（0：离线，1：停机，2：待机，3：运行）
-     * @param pageNo     页码，默认1
-     * @param pageSize   每页条数，默认10
      */
      */
     @GetMapping("/energy/list")
     @GetMapping("/energy/list")
     public Map<String, Object> energyList(
     public Map<String, Object> energyList(
+            @RequestParam(required = false) String corpCode,
             @RequestParam(required = false) String deviceName,
             @RequestParam(required = false) String deviceName,
             @RequestParam(required = false) String runStatus,
             @RequestParam(required = false) String runStatus,
             @RequestParam(defaultValue = "1") Integer pageNo,
             @RequestParam(defaultValue = "1") Integer pageNo,
             @RequestParam(defaultValue = "10") Integer pageSize) {
             @RequestParam(defaultValue = "10") Integer pageSize) {
-        return energySearchService.queryEnergyList(deviceName, runStatus, pageNo, pageSize);
+        if (!isValidCorpCode(corpCode)) return emptyResult();
+        return energySearchService.queryEnergyList(corpCode, deviceName, runStatus, pageNo, pageSize);
     }
     }
 
 
     @GetMapping("/energy/stats")
     @GetMapping("/energy/stats")
-    public Map<String, Object> energyStats() {
-        return energySearchService.queryEnergyStats();
+    public Map<String, Object> energyStats(@RequestParam(required = false) String corpCode) {
+        if (!isValidCorpCode(corpCode)) return emptyResult();
+        return energySearchService.queryEnergyStats(corpCode);
     }
     }
 
 
     /**
     /**
      * 根据dtuSn查询指定日期的设备时用电量和OEE时序
      * 根据dtuSn查询指定日期的设备时用电量和OEE时序
-     * 返回时用电量数组、总用电量、OEE时序、总时长、各状态运行时长和占比
-     *
-     * @param dtuSn 设备序列号
-     * @param date  查询日期 yyyy-MM-dd
      */
      */
     @GetMapping("/energy/detail")
     @GetMapping("/energy/detail")
     public Map<String, Object> energyDetail(
     public Map<String, Object> energyDetail(
+            @RequestParam(required = false) String corpCode,
             @RequestParam String dtuSn,
             @RequestParam String dtuSn,
             @RequestParam String date) {
             @RequestParam String date) {
-        return energySearchService.queryEnergyDetailByDate(dtuSn, date);
+        if (!isValidCorpCode(corpCode)) return emptyResult();
+        return energySearchService.queryEnergyDetailByDate(corpCode, dtuSn, date);
     }
     }
 
 
     /**
     /**
      * 根据dtuSn查询指定设备的运行时长明细
      * 根据dtuSn查询指定设备的运行时长明细
-     * type=1(时): 传startDate，获取指定日期的运行时长明细
-     * type=2(天): 传startDate和endDate，按日统计
-     * type=3(月): 查本年年初到现在，按月统计
-     *
-     * @param dtuSn     设备序列号
-     * @param type      类型：1-时，2-天，3-月
-     * @param startDate 开始日期 yyyy-MM-dd (type=1,2必填)
-     * @param endDate   结束日期 yyyy-MM-dd (type=2必填)
      */
      */
     @GetMapping("/energy/runtimeDetail")
     @GetMapping("/energy/runtimeDetail")
     public Map<String, Object> energyRuntimeDetail(
     public Map<String, Object> energyRuntimeDetail(
+            @RequestParam(required = false) String corpCode,
             @RequestParam String dtuSn,
             @RequestParam String dtuSn,
             @RequestParam(defaultValue = "1") String type,
             @RequestParam(defaultValue = "1") String type,
             @RequestParam(required = false) String startDate,
             @RequestParam(required = false) String startDate,
             @RequestParam(required = false) String endDate) {
             @RequestParam(required = false) String endDate) {
-        return energySearchService.queryEnergyRuntimeDetail(dtuSn, type, startDate, endDate);
+        if (!isValidCorpCode(corpCode)) return emptyResult();
+        return energySearchService.queryEnergyRuntimeDetail(corpCode, dtuSn, type, startDate, endDate);
     }
     }
 
 
     /**
     /**
      * 查询能耗时序状态 - 分页查询
      * 查询能耗时序状态 - 分页查询
-     * 获取指定日期所有设备的用电量数据，计算稼动率和总用电量
-     *
-     * @param date     查询日期 yyyy-MM-dd
-     * @param pageNo   页码，默认1
-     * @param pageSize 每页条数，默认12
      */
      */
     @GetMapping("/energy/timelineStatus")
     @GetMapping("/energy/timelineStatus")
     public Map<String, Object> energyTimelineStatus(
     public Map<String, Object> energyTimelineStatus(
+            @RequestParam(required = false) String corpCode,
             @RequestParam String date,
             @RequestParam String date,
             @RequestParam(defaultValue = "1") Integer pageNo,
             @RequestParam(defaultValue = "1") Integer pageNo,
             @RequestParam(defaultValue = "12") Integer pageSize) {
             @RequestParam(defaultValue = "12") Integer pageSize) {
-        return energySearchService.queryEnergyTimelineStatus(date, pageNo, pageSize);
+        if (!isValidCorpCode(corpCode)) return emptyResult();
+        return energySearchService.queryEnergyTimelineStatus(corpCode, date, pageNo, pageSize);
     }
     }
 
 
     /**
     /**
      * eq_kwh综合统计查询
      * eq_kwh综合统计查询
-     * 查询指定日期范围内所有设备的稼动率、各状态时长、异常排名等
-     *
-     * @param startDate 开始日期 yyyy-MM-dd
-     * @param endDate   结束日期 yyyy-MM-dd
-     * @return 包含: 总稼动率、各状态时间(xxx.xx时)、当前运行状态、异常机台排名、每设备0/1/2/3状态时间
      */
      */
     @GetMapping("/energy/eqKwhStatistics")
     @GetMapping("/energy/eqKwhStatistics")
     public Map<String, Object> eqKwhStatistics(
     public Map<String, Object> eqKwhStatistics(
+            @RequestParam(required = false) String corpCode,
             @RequestParam String startDate,
             @RequestParam String startDate,
             @RequestParam String endDate) {
             @RequestParam String endDate) {
-        return energySearchService.queryEqKwhStatistics(startDate, endDate);
+        if (!isValidCorpCode(corpCode)) return emptyResult();
+        return energySearchService.queryEqKwhStatistics(corpCode, startDate, endDate);
     }
     }
 
 
     /**
     /**
      * 查询eq_kwh多设备能耗数据(按 时/日/月 聚合)
      * 查询eq_kwh多设备能耗数据(按 时/日/月 聚合)
-     * type=1 (时): 传startDate，返回该日所有设备的原始用电量明细
-     * type=2 (日):
-     * - 传startDate+endDate: 按此范围每日统计每台设备能耗
-     * - 只传startDate: 自动取当月1号~月末，按日统计
-     * type=3 (月): 自动取本年1月~当前月，按月统计每台能耗数据
-     *
-     * @param type      类型: 1-时, 2-日, 3-月
-     * @param startDate 开始日期 yyyy-MM-dd
-     * @param endDate   结束日期 yyyy-MM-dd (type=2时可选)
      */
      */
     @GetMapping("/energy/eqKwhByType")
     @GetMapping("/energy/eqKwhByType")
     public Map<String, Object> eqKwhByType(
     public Map<String, Object> eqKwhByType(
+            @RequestParam(required = false) String corpCode,
             @RequestParam(defaultValue = "1") String type,
             @RequestParam(defaultValue = "1") String type,
             @RequestParam(required = false) String startDate,
             @RequestParam(required = false) String startDate,
             @RequestParam(required = false) String endDate) {
             @RequestParam(required = false) String endDate) {
-        return energySearchService.queryEqKwhByType(type, startDate, endDate);
+        if (!isValidCorpCode(corpCode)) return emptyResult();
+        return energySearchService.queryEqKwhByType(corpCode, type, startDate, endDate);
     }
     }
 
 
     /**
     /**
      * 调试：查看eq_kwh表中的数据概况
      * 调试：查看eq_kwh表中的数据概况
      */
      */
     @GetMapping("/energy/debug/eqKwhInfo")
     @GetMapping("/energy/debug/eqKwhInfo")
-    public Map<String, Object> debugEqKwhInfo() {
-        return energySearchService.debugEqKwhInfo();
+    public Map<String, Object> debugEqKwhInfo(@RequestParam(required = false) String corpCode) {
+        if (!isValidCorpCode(corpCode)) return emptyResult();
+        return energySearchService.debugEqKwhInfo(corpCode);
+    }
+
+    private boolean isValidCorpCode(String corpCode) {
+        return corpCode != null && !corpCode.trim().isEmpty();
     }
     }
 }
 }

+package com.iot.scheduler.model;
+
+import lombok.Data;
+
+/**
+ * 公司配置信息（来自 t_auto_ymk_ccfg_corp_conf 表）
+ */
+@Data
+public class CorpConf {
+
+    /**
+     * 公司名称
+     */
+    private String corpName;
+    /**
+     * 数据源连接地址
+     */
+    private String datasourceUrl;
+    /**
+     * 数据源用户名
+     */
+    private String datasourceName;
+    /**
+     * 数据源密码
+     */
+    private String datasourcePassword;
+    /**
+     * 描述
+     */
+    private String description;
+    /**
+     * 公司编码（target_corp）
+     */
+    private String targetCorp;
+    /**
+     * IoT平台部门名称
+     */
+    private String iotOrg;
+    /**
+     * IoT平台密码（token.password）
+     */
+    private String iotPassword;
+    /**
+     * IoT平台用户名（token.userName）
+     */
+    private String iotUsername;
+}

+package com.iot.scheduler.service;
+
+import com.iot.scheduler.model.CorpConf;
+import jakarta.annotation.PostConstruct;
+import jakarta.annotation.Resource;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Service;
+
+import javax.sql.DataSource;
+import java.sql.DriverManager;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * 公司配置服务
+ * - 根据 corpCode 查询 t_auto_ymk_ccfg_corp_conf 表获取公司配置
+ * - 数据源策略：公司配置了独立数据源则走独立库，否则使用 application.yml 默认库
+ * - 每个公司的表通过 t_auto_{corpCode}_iot_xxx 隔离，不同公司数据互不影响
+ */
+@Slf4j
+@Service
+public class CorpConfigService {
+
+    @Value("${corp.config.tableName}")
+    private String corpConfigTableName;
+
+    @Value("${spring.datasource.url}")
+    private String defaultDatasourceUrl;
+    @Value("${spring.datasource.username}")
+    private String defaultDatasourceUsername;
+    @Value("${spring.datasource.password}")
+    private String defaultDatasourcePassword;
+
+    @Resource
+    private JdbcTemplate masterJdbcTemplate;
+
+    /**
+     * 配置缓存，避免频繁查数据库
+     */
+    private final Map<String, CorpConf> confCache = new ConcurrentHashMap<>();
+
+    @PostConstruct
+    public void init() {
+        log.info("【公司配置服务】初始化完成, 配置表: {}, 默认数据库: {}", corpConfigTableName, defaultDatasourceUrl);
+    }
+
+    /**
+     * 根据 corpCode 获取公司配置信息（带缓存）
+     *
+     * @param corpCode 公司编码
+     * @return 公司配置，未找到返回null
+     */
+    public CorpConf getCorpConf(String corpCode) {
+        if (corpCode == null || corpCode.isEmpty()) return null;
+        return confCache.computeIfAbsent(corpCode, this::loadCorpConfFromDb);
+    }
+
+    /**
+     * 清除指定公司缓存
+     */
+    public void clearCache(String corpCode) {
+        if (corpCode != null) confCache.remove(corpCode);
+    }
+
+    /**
+     * 获取所有已配置的公司编码列表
+     * 从配置表查询所有有效的 target_corp，用于定时任务遍历
+     *
+     * @return 公司编码列表（不为null）
+     */
+    public List<String> getAllCorpCodes() {
+        try {
+            String sql = "SELECT DISTINCT target_corp FROM " + corpConfigTableName +
+                    " WHERE target_corp IS NOT NULL AND target_corp != '' ORDER BY target_corp";
+            List<Map<String, Object>> rows = masterJdbcTemplate.queryForList(sql);
+            List<String> result = new ArrayList<>(rows.size());
+            for (Map<String, Object> row : rows) {
+                String code = getStringVal(row.get("target_corp"));
+                if (code != null) result.add(code);
+            }
+            log.info("【公司配置】查询到 {} 个已配置公司: {}", result.size(), result);
+            return result;
+        } catch (Exception e) {
+            log.error("【公司配置】查询所有公司编码异常", e);
+            return Collections.emptyList();
+        }
+    }
+
+    /**
+     * 清除全部缓存
+     */
+    public void clearAllCache() {
+        confCache.clear();
+    }
+
+    /**
+     * 从数据库加载公司配置
+     */
+    private CorpConf loadCorpConfFromDb(String corpCode) {
+        try {
+            String sql = "SELECT corp_name, datasource_name, datasource_password, datasource_url, description, " +
+                    "target_corp, iot_org, iot_password, iot_username FROM " + corpConfigTableName +
+                    " WHERE target_corp = ? LIMIT 1";
+            Map<String, Object> row = masterJdbcTemplate.queryForMap(sql, corpCode);
+            CorpConf conf = new CorpConf();
+            conf.setCorpName(getStringVal(row.get("corp_name")));
+            conf.setDatasourceName(getStringVal(row.get("datasource_name")));
+            conf.setDatasourcePassword(getStringVal(row.get("datasource_password")));
+            conf.setDatasourceUrl(getStringVal(row.get("datasource_url")));
+            conf.setDescription(getStringVal(row.get("description")));
+            conf.setTargetCorp(getStringVal(row.get("target_corp")));
+            conf.setIotOrg(getStringVal(row.get("iot_org")));
+            conf.setIotPassword(getStringVal(row.get("iot_password")));
+            conf.setIotUsername(getStringVal(row.get("iot_username")));
+            log.info("【公司配置】加载成功, corpCode={}, corpName={}, hasCustomDs={}",
+                    corpCode, conf.getCorpName(), hasCustomDatasource(conf));
+            return conf;
+        } catch (org.springframework.dao.EmptyResultDataAccessException e) {
+            // 查询无结果，属于正常情况（该corpCode未在配置表中注册）
+            log.warn("【公司配置】未找到corpCode={}的配置记录", corpCode);
+            return null;
+        } catch (Exception e) {
+            log.error("【公司配置】查询corpCode={}异常", corpCode, e);
+            return null;
+        }
+    }
+
+    /**
+     * 获取公司的 JdbcTemplate（动态数据源）
+     * <p>
+     * 数据源选择策略：
+     * 1. 如果 t_auto_ymk_ccfg_corp_conf 中该公司配置了 datasource_url → 使用该独立数据源
+     * 2. 如果该公司未配置数据源 → 使用 application.yml 中的默认数据源
+     * </p>
+     *
+     * @param corpCode 公司编码
+     * @return JdbcTemplate
+     */
+    public JdbcTemplate getJdbcTemplate(String corpCode) {
+        CorpConf conf = getCorpConf(corpCode);
+        if (conf == null || !hasCustomDatasource(conf)) {
+            log.info("【公司数据源】corpCode={}, 未配置独立数据源, 使用application.yml默认数据源: {}", corpCode, defaultDatasourceUrl);
+            return masterJdbcTemplate;
+        }
+        try {
+            DataSource ds = DriverManager.getConnection(
+                    conf.getDatasourceUrl(),
+                    conf.getDatasourceName(),
+                    conf.getDatasourcePassword()
+            ).unwrap(DataSource.class);
+            JdbcTemplate jt = new JdbcTemplate(ds);
+            log.info("【公司数据源】corpCode={}, 使用独立数据源: {}", corpCode, conf.getDatasourceUrl());
+            return jt;
+        } catch (Exception e) {
+            log.error("【公司数据源】corpCode={} 连接独立数据源失败! url={}, error={}", corpCode, conf.getDatasourceUrl(), e.getMessage());
+            throw new RuntimeException("公司 " + corpCode + " 的独立数据源连接失败: " + e.getMessage(), e);
+        }
+    }
+
+    /**
+     * 获取IoT平台部门名称（groupName），无配置返回null
+     */
+    public String getIotOrg(String corpCode) {
+        CorpConf conf = getCorpConf(corpCode);
+        if (conf != null && conf.getIotOrg() != null && !conf.getIotOrg().isEmpty()) {
+            return conf.getIotOrg();
+        }
+        return null;
+    }
+
+    /**
+     * 获取IoT平台用户名（token.userName），无配置返回null
+     */
+    public String getIotUsername(String corpCode) {
+        CorpConf conf = getCorpConf(corpCode);
+        if (conf != null && conf.getIotUsername() != null && !conf.getIotUsername().isEmpty()) {
+            return conf.getIotUsername();
+        }
+        return null;
+    }
+
+    /**
+     * 获取IoT平台密码（token.password），无配置返回null
+     */
+    public String getIotPassword(String corpCode) {
+        CorpConf conf = getCorpConf(corpCode);
+        if (conf != null && conf.getIotPassword() != null && !conf.getIotPassword().isEmpty()) {
+            return conf.getIotPassword();
+        }
+        return null;
+    }
+
+    /**
+     * 检查公司是否配置了有效的IoT平台凭证（org/username/password）
+     */
+    public boolean hasValidIotCredentials(String corpCode) {
+        String org = getIotOrg(corpCode);
+        String username = getIotUsername(corpCode);
+        String password = getIotPassword(corpCode);
+        boolean valid = StringUtils.isNotBlank(org)
+                && StringUtils.isNotBlank(username)
+                && StringUtils.isNotBlank(password);
+        if (!valid) {
+            log.warn("【IoT凭证】corpCode={} 的IoT配置不完整: org={}, username={}, password={}",
+                    corpCode, org != null ? "***" : "null",
+                    username != null ? "***" : "null",
+                    password != null ? "***" : "null");
+        }
+        return valid;
+    }
+
+    // ==================== 表名工具方法 ====================
+
+    /**
+     * 生成设备主表名: t_auto_{corpCode}_iot_device
+     */
+    public String getDeviceTableName(String corpCode) {
+        return "t_auto_" + corpCode + "_iot_device";
+    }
+
+    /**
+     * 生成设备利用率表名: t_auto_{corpCode}_iot_dev_util
+     */
+    public String getDevUtilTableName(String corpCode) {
+        return "t_auto_" + corpCode + "_iot_dev_util";
+    }
+
+    /**
+     * 生成OEE表名: t_auto_{corpCode}_iot_dev_oee
+     */
+    public String getOeeTableName(String corpCode) {
+        return "t_auto_" + corpCode + "_iot_dev_oee";
+    }
+
+    /**
+     * 生成能耗主表名: t_auto_{corpCode}_iot_energy
+     */
+    public String getEnergyTableName(String corpCode) {
+        return "t_auto_" + corpCode + "_iot_energy";
+    }
+
+    /**
+     * 生成能耗用电量表名: t_auto_{corpCode}_iot_eq_kwh
+     */
+    public String getEqKwhTableName(String corpCode) {
+        return "t_auto_" + corpCode + "_iot_eq_kwh";
+    }
+
+    /**
+     * 生成能耗运行状态明细表名: t_auto_{corpCode}_iot_e_run_dtl
+     */
+    public String getERunDtlTableName(String corpCode) {
+        return "t_auto_" + corpCode + "_iot_e_run_dtl";
+    }
+
+    // ==================== 内部工具 ====================
+
+    private boolean hasCustomDatasource(CorpConf conf) {
+        return conf.getDatasourceUrl() != null && !conf.getDatasourceUrl().isEmpty();
+    }
+
+    private String getStringVal(Object val) {
+        return val != null ? String.valueOf(val) : null;
+    }
+}

@@ -40,13 +40,8 @@ import org.springframework.scheduling.annotation.Scheduled;
 @Service
 @Service
 public class DevicePullService {
 public class DevicePullService {
 
 
-
     @Value("${device.token.url}")
     @Value("${device.token.url}")
     private String deviceTokenUrl;
     private String deviceTokenUrl;
-    @Value("${device.token.userName}")
-    private String deviceUserName;
-    @Value("${device.token.password}")
-    private String devicePassword;
     @Value("${device.info.url}")
     @Value("${device.info.url}")
     private String deviceInfoUrl;
     private String deviceInfoUrl;
     @Value("${device.detail.url}")
     @Value("${device.detail.url}")
@@ -55,14 +50,6 @@ public class DevicePullService {
     private String deviceSnRateUrl;
     private String deviceSnRateUrl;
     @Value("${device.energyInfo.url}")
     @Value("${device.energyInfo.url}")
     private String energyInfoUrl;
     private String energyInfoUrl;
-    @Value("${device.db.corpCode}")
-    private String deviceCorpCode;
-    @Value("${device.db.tableName}")
-    private String deviceTableName;
-    @Value("${device.db.devUtilTableName}")
-    private String devUtilTableName;
-    @Value("${device.db.oeeTableName}")
-    private String oeeTableName;
     @Value("${device.lamp.url}")
     @Value("${device.lamp.url}")
     private String deviceLampUrl;
     private String deviceLampUrl;
 
 
@@ -70,11 +57,17 @@ public class DevicePullService {
     private RedisTemplate<String, String> redisTemplate;
     private RedisTemplate<String, String> redisTemplate;
     @Resource
     @Resource
     private JdbcTemplate jdbcTemplate;
     private JdbcTemplate jdbcTemplate;
+    @Resource
+    private CorpConfigService corpConfigService;
 
 
     final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
     final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
 
-    public void pullDeviceAndPushToIot() throws ParseException {
-        String deviceResult = getDeviceInfo();
+    public void pullDeviceAndPushToIot(String corpCode) throws ParseException {
+        if (!corpConfigService.hasValidIotCredentials(corpCode)) {
+            log.warn("【设备同步】IoT凭证为空, 跳过同步, corpCode={}", corpCode);
+            return;
+        }
+        String deviceResult = getDeviceInfo(corpCode);
         Map<String, Object> deviceInfos = JSON.parseObject(deviceResult, new TypeReference<>() {
         Map<String, Object> deviceInfos = JSON.parseObject(deviceResult, new TypeReference<>() {
         });
         });
 
 
@@ -89,21 +82,19 @@ public class DevicePullService {
             String deviceId = deviceInfoJson.getString("deviceId");
             String deviceId = deviceInfoJson.getString("deviceId");
             String dtuSn = deviceInfoJson.getString("dtuSn");
             String dtuSn = deviceInfoJson.getString("dtuSn");
 
 
-            String deviceInfoDetails = getDeviceInfoDetail(dtuSn);
+            String deviceInfoDetails = getDeviceInfoDetail(corpCode, dtuSn);
             if (StringUtils.isBlank(deviceInfoDetails)) {
             if (StringUtils.isBlank(deviceInfoDetails)) {
                 return;
                 return;
             }
             }
 
 
             Map<String, Object> deviceInfoDetailMap = JSON.parseObject(deviceInfoDetails, new TypeReference<>() {
             Map<String, Object> deviceInfoDetailMap = JSON.parseObject(deviceInfoDetails, new TypeReference<>() {
             });
             });
-
             JSONArray deviceInfoDetailList = (JSONArray) deviceInfoDetailMap.get("data");
             JSONArray deviceInfoDetailList = (JSONArray) deviceInfoDetailMap.get("data");
             if (CollectionUtils.isEmpty(deviceInfoDetailList)) {
             if (CollectionUtils.isEmpty(deviceInfoDetailList)) {
                 return;
                 return;
             }
             }
 
 
             JSONObject deviceInfoDetailJson = (JSONObject) deviceInfoDetailList.get(0);
             JSONObject deviceInfoDetailJson = (JSONObject) deviceInfoDetailList.get(0);
-
             String lampState = deviceInfoDetailJson.getString("lampState");
             String lampState = deviceInfoDetailJson.getString("lampState");
             String startTime = deviceInfoDetailJson.getString("startTime");
             String startTime = deviceInfoDetailJson.getString("startTime");
 
 
@@ -118,111 +109,74 @@ public class DevicePullService {
             long minutes = (diffMillis % (1000 * 60 * 60)) / (1000 * 60);
             long minutes = (diffMillis % (1000 * 60 * 60)) / (1000 * 60);
             long seconds = (diffMillis % (1000 * 60)) / 1000;
             long seconds = (diffMillis % (1000 * 60)) / 1000;
             StringBuilder durationBuilder = new StringBuilder();
             StringBuilder durationBuilder = new StringBuilder();
-            if (hours > 0) {
-                durationBuilder.append(hours).append("时");
-            }
-
-            if (minutes > 0) {
-                durationBuilder.append(minutes).append("分");
-            }
-
+            if (hours > 0) durationBuilder.append(hours).append("时");
+            if (minutes > 0) durationBuilder.append(minutes).append("分");
             durationBuilder.append(seconds).append("秒");
             durationBuilder.append(seconds).append("秒");
             String duration = durationBuilder.toString();
             String duration = durationBuilder.toString();
 
 
-            // 获取稼动率
-            String utilizationRate = getUtilizationRate(dtuSn);
+            String utilizationRate = getUtilizationRate(corpCode, dtuSn);
 
 
-            log.info("设备数据汇总 - projectState:{}, projectType:{}, deviceName:{}, dtuId:{}, deviceId:{}, dtuSn:{}, " +
+            log.info("设备数据汇总 - corpCode:{}, projectState:{}, projectType:{}, deviceName:{}, dtuId:{}, deviceId:{}, dtuSn:{}, " +
                             "lampState:{}, duration:{}, utilizationRate:{}",
                             "lampState:{}, duration:{}, utilizationRate:{}",
-                    projectState, projectType, deviceName, dtuId, deviceId, dtuSn,
+                    corpCode, projectState, projectType, deviceName, dtuId, deviceId, dtuSn,
                     lampState, duration, utilizationRate);
                     lampState, duration, utilizationRate);
 
 
-            // 保存或更新数据库
-            saveOrUpdateDevice(projectState, projectType, deviceName, dtuId, deviceId, dtuSn,
+            saveOrUpdateDevice(corpCode, projectState, projectType, deviceName, dtuId, deviceId, dtuSn,
                     lampState, startTime, duration, utilizationRate);
                     lampState, startTime, duration, utilizationRate);
         }
         }
-
-
     }
     }
 
 
-    public String getDeviceInfoDetail(String dtuSn) {
-        String accessToken = getAccessToken();
+    public String getDeviceInfoDetail(String corpCode, String dtuSn) {
+        String accessToken = getAccessToken(corpCode);
         Map<String, String> dtuSnOb = new HashMap<>(1);
         Map<String, String> dtuSnOb = new HashMap<>(1);
         dtuSnOb.put("dtuSn", dtuSn);
         dtuSnOb.put("dtuSn", dtuSn);
         Map<String, String> headerMap = new HashMap<>(1);
         Map<String, String> headerMap = new HashMap<>(1);
         headerMap.put("Authorization", "Bearer " + accessToken);
         headerMap.put("Authorization", "Bearer " + accessToken);
         String deviceInfoDetail = sendRequestGet(deviceDetailUrl, dtuSnOb, headerMap);
         String deviceInfoDetail = sendRequestGet(deviceDetailUrl, dtuSnOb, headerMap);
-        if (StringUtils.isBlank(deviceInfoDetail)) {
-            return null;
-        }
+        if (StringUtils.isBlank(deviceInfoDetail)) return null;
 
 
-        Map<String, Object> deviceInfoDetailMap = JSON.parseObject(deviceInfoDetail,
-                new TypeReference<>() {
-                });
+        Map<String, Object> deviceInfoDetailMap = JSON.parseObject(deviceInfoDetail, new TypeReference<>() {
+        });
         Integer deviceInfoDetailCode = (Integer) deviceInfoDetailMap.get("code");
         Integer deviceInfoDetailCode = (Integer) deviceInfoDetailMap.get("code");
-        if (deviceInfoDetailCode != 200) {
-            return null;
-        }
+        if (deviceInfoDetailCode != 200) return null;
 
 
         JSONArray deviceInfoDetailList = (JSONArray) deviceInfoDetailMap.get("data");
         JSONArray deviceInfoDetailList = (JSONArray) deviceInfoDetailMap.get("data");
-        if (CollectionUtils.isEmpty(deviceInfoDetailList)) {
-            return null;
-        }
+        if (CollectionUtils.isEmpty(deviceInfoDetailList)) return null;
 
 
         JSONObject deviceInfoDetailJson = (JSONObject) deviceInfoDetailList.get(0);
         JSONObject deviceInfoDetailJson = (JSONObject) deviceInfoDetailList.get(0);
-        //灯详情数据
-        //灯状态(0:灭灯，1：红，2：黄，3：绿，4：蓝)
         Integer lampState = deviceInfoDetailJson.getInteger("lampState");
         Integer lampState = deviceInfoDetailJson.getInteger("lampState");
-        if (lampState == null) {
-            return null;
-        }
-
+        if (lampState == null) return null;
         return deviceInfoDetail;
         return deviceInfoDetail;
     }
     }
 
 
-    public String getDtuSnRateOfAction(String dtuSn, String startDate, String endDate) {
-        String accessToken = getAccessToken();
+    public String getDtuSnRateOfAction(String corpCode, String dtuSn, String startDate, String endDate) {
+        String accessToken = getAccessToken(corpCode);
         Map<String, String> headerMap = new HashMap<>(1);
         Map<String, String> headerMap = new HashMap<>(1);
         headerMap.put("Authorization", "Bearer " + accessToken);
         headerMap.put("Authorization", "Bearer " + accessToken);
-
         Map<String, String> paramsMap = new HashMap<>();
         Map<String, String> paramsMap = new HashMap<>();
         paramsMap.put("startDate", startDate);
         paramsMap.put("startDate", startDate);
         paramsMap.put("endDate", endDate);
         paramsMap.put("endDate", endDate);
         paramsMap.put("dtuSn", dtuSn);
         paramsMap.put("dtuSn", dtuSn);
-
         String rateResult = sendRequestGet(deviceSnRateUrl, paramsMap, headerMap);
         String rateResult = sendRequestGet(deviceSnRateUrl, paramsMap, headerMap);
-        if (StringUtils.isBlank(rateResult)) {
-            return null;
-        }
-
-        Map<String, Object> rateMap = JSON.parseObject(rateResult, new TypeReference<>() {});
+        if (StringUtils.isBlank(rateResult)) return null;
+        Map<String, Object> rateMap = JSON.parseObject(rateResult, new TypeReference<>() {
+        });
         Integer rateCode = (Integer) rateMap.get("code");
         Integer rateCode = (Integer) rateMap.get("code");
-        if (rateCode != 200) {
-            return null;
-        }
-
+        if (rateCode != 200) return null;
         return rateResult;
         return rateResult;
     }
     }
 
 
-    public String getUtilizationRate(String dtuSn) {
+    public String getUtilizationRate(String corpCode, String dtuSn) {
         String today = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
         String today = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
-        String rateResult = getDtuSnRateOfAction(dtuSn, today, today);
-        if (StringUtils.isBlank(rateResult)) {
-            return "0%";
-        }
-
-        Map<String, Object> rateMap = JSON.parseObject(rateResult, new TypeReference<>() {});
+        String rateResult = getDtuSnRateOfAction(corpCode, dtuSn, today, today);
+        if (StringUtils.isBlank(rateResult)) return "0%";
+        Map<String, Object> rateMap = JSON.parseObject(rateResult, new TypeReference<>() {
+        });
         JSONArray dataList = (JSONArray) rateMap.get("data");
         JSONArray dataList = (JSONArray) rateMap.get("data");
-        if (CollectionUtils.isEmpty(dataList)) {
-            return "0%";
-        }
-
+        if (CollectionUtils.isEmpty(dataList)) return "0%";
         JSONObject todayData = (JSONObject) dataList.get(0);
         JSONObject todayData = (JSONObject) dataList.get(0);
         JSONArray realRateList = todayData.getJSONArray("realRate");
         JSONArray realRateList = todayData.getJSONArray("realRate");
-        if (CollectionUtils.isEmpty(realRateList)) {
-            return "0%";
-        }
-
+        if (CollectionUtils.isEmpty(realRateList)) return "0%";
         JSONObject rateObj = (JSONObject) realRateList.get(0);
         JSONObject rateObj = (JSONObject) realRateList.get(0);
         long state0 = rateObj.getLongValue("0");
         long state0 = rateObj.getLongValue("0");
         long state1 = rateObj.getLongValue("1");
         long state1 = rateObj.getLongValue("1");
@@ -231,149 +185,132 @@ public class DevicePullService {
         long state4 = rateObj.getLongValue("4");
         long state4 = rateObj.getLongValue("4");
         long state5 = rateObj.getLongValue("5");
         long state5 = rateObj.getLongValue("5");
         long totalTime = state0 + state1 + state2 + state3 + state4 + state5;
         long totalTime = state0 + state1 + state2 + state3 + state4 + state5;
-        if (totalTime == 0) {
-            return "0%";
-        }
-
+        if (totalTime == 0) return "0%";
         double rate = (double) state3 / totalTime * 100;
         double rate = (double) state3 / totalTime * 100;
         return String.format("%.2f%%", rate);
         return String.format("%.2f%%", rate);
     }
     }
 
 
-    public String getLampData(String dtuSn, String date) {
-        String accessToken = getAccessToken();
+    public String getLampData(String corpCode, String dtuSn, String date) {
+        String accessToken = getAccessToken(corpCode);
         Map<String, String> headerMap = new HashMap<>(1);
         Map<String, String> headerMap = new HashMap<>(1);
         headerMap.put("Authorization", "Bearer " + accessToken);
         headerMap.put("Authorization", "Bearer " + accessToken);
-
         Map<String, String> paramsMap = new HashMap<>();
         Map<String, String> paramsMap = new HashMap<>();
         paramsMap.put("dtuSn", dtuSn);
         paramsMap.put("dtuSn", dtuSn);
         paramsMap.put("date", date);
         paramsMap.put("date", date);
-
         return sendRequestGet(deviceLampUrl, paramsMap, headerMap);
         return sendRequestGet(deviceLampUrl, paramsMap, headerMap);
     }
     }
 
 
-    public void saveOrUpdateDevice(String projectState, String projectType, String deviceName, String dtuId,
+    private void saveOrUpdateDevice(String corpCode, String projectState, String projectType, String deviceName, String dtuId,
                                     String deviceId, String dtuSn, String lampState, String startTime,
                                     String deviceId, String dtuSn, String lampState, String startTime,
                                     String duration, String utilizationRate) {
                                     String duration, String utilizationRate) {
-        // 查询是否已存在（按公司+dtuSn判断）
-        List<Map<String, Object>> existList = jdbcTemplate.queryForList(
-                "SELECT id FROM " + deviceTableName + " WHERE corp_code = ? AND dtuSn = ?", deviceCorpCode, dtuSn);
+        String tableName = corpConfigService.getDeviceTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
 
 
+        List<Map<String, Object>> existList = jt.queryForList(
+                "SELECT id FROM " + tableName + " WHERE corp_code = ? AND dtuSn = ?", corpCode, dtuSn);
         Date now = new Date();
         Date now = new Date();
         if (!existList.isEmpty()) {
         if (!existList.isEmpty()) {
-            // 更新
-            jdbcTemplate.update("UPDATE " + deviceTableName + " SET projectState = ?, projectType = ?, deviceName = ?, " +
+            jt.update("UPDATE " + tableName + " SET projectState = ?, projectType = ?, deviceName = ?, " +
                             "dtuId = ?, deviceId = ?, lampState = ?, startTime = ?, duration = ?, utilizationRate = ?, updated_at = ? WHERE dtuSn = ?",
                             "dtuId = ?, deviceId = ?, lampState = ?, startTime = ?, duration = ?, utilizationRate = ?, updated_at = ? WHERE dtuSn = ?",
-                    projectState, projectType, deviceName, dtuId, deviceId, lampState,
-                    startTime, duration, utilizationRate, now, dtuSn);
-            log.info("设备数据更新成功 - dtuSn:{}", dtuSn);
+                    projectState, projectType, deviceName, dtuId, deviceId, lampState, startTime, duration, utilizationRate, now, dtuSn);
+            log.info("设备数据更新成功 - corpCode:{}, dtuSn:{}", corpCode, dtuSn);
         } else {
         } else {
-            // 新增
             String id = UUID.randomUUID().toString().replace("-", "");
             String id = UUID.randomUUID().toString().replace("-", "");
-            jdbcTemplate.update("INSERT INTO " + deviceTableName + " (id, corp_code, created_at, created_by, updated_at, updated_by, " +
+            jt.update("INSERT INTO " + tableName + " (id, corp_code, created_at, created_by, updated_at, updated_by, " +
                             "deviceName, projectType, projectState, dtuSn, dtuId, deviceId, lampState, startTime, duration, utilizationRate) " +
                             "deviceName, projectType, projectState, dtuSn, dtuId, deviceId, lampState, startTime, duration, utilizationRate) " +
-                            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
-                    id, deviceCorpCode, now, "system", now, "system",
-                    deviceName, projectType, projectState, dtuSn, dtuId, deviceId, lampState,
-                    startTime, duration, utilizationRate);
-            log.info("设备数据新增成功 - dtuSn:{}", dtuSn);
+                            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                    id, corpCode, now, "system", now, "system",
+                    deviceName, projectType, projectState, dtuSn, dtuId, deviceId, lampState, startTime, duration, utilizationRate);
+            log.info("设备数据新增成功 - corpCode:{}, dtuSn:{}", corpCode, dtuSn);
         }
         }
     }
     }
 
 
     /**
     /**
-     * 首次全量同步：本年1月1日 ~ 昨天（手动触发一次）
+     * 首次全量同步
      */
      */
-    public void pullDevUtilAndSave() {
+    public void pullDevUtilAndSave(String corpCode) {
+        if (!corpConfigService.hasValidIotCredentials(corpCode)) {
+            log.warn("【全量同步-利用率】IoT凭证为空, 跳过同步, corpCode={}", corpCode);
+            return;
+        }
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         Calendar cal = Calendar.getInstance();
         Calendar cal = Calendar.getInstance();
-        cal.add(Calendar.DAY_OF_MONTH, -1); // 昨天
+        cal.add(Calendar.DAY_OF_MONTH, -1);
         String endDate = sdf.format(cal.getTime());
         String endDate = sdf.format(cal.getTime());
         cal.set(cal.get(Calendar.YEAR), Calendar.JANUARY, 1);
         cal.set(cal.get(Calendar.YEAR), Calendar.JANUARY, 1);
         String startDate = sdf.format(cal.getTime());
         String startDate = sdf.format(cal.getTime());
-
-        log.info("【全量同步】设备利用率，日期范围: {} ~ {}", startDate, endDate);
-        doSyncDevUtil(startDate, endDate);
+        log.info("【全量同步】设备利用率, corpCode:{}, 日期范围: {} ~ {}", corpCode, startDate, endDate);
+        doSyncDevUtil(corpCode, "2026-05-01", endDate);
     }
     }
 
 
-    /**
-     * 每日增量同步：仅同步昨天的数据（定时任务自动触发）
-     */
     @Scheduled(cron = "${scheduler.devUtil.cron:0 30 2 * * ?}")
     @Scheduled(cron = "${scheduler.devUtil.cron:0 30 2 * * ?}")
     public void pullDevUtilDaily() {
     public void pullDevUtilDaily() {
+        List<String> corpCodes = corpConfigService.getAllCorpCodes();
+        if (corpCodes.isEmpty()) {
+            log.warn("【每日增量】设备利用率: 未找到任何公司配置，跳过");
+            return;
+        }
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         Calendar cal = Calendar.getInstance();
         Calendar cal = Calendar.getInstance();
         cal.add(Calendar.DAY_OF_MONTH, -1);
         cal.add(Calendar.DAY_OF_MONTH, -1);
         String yesterday = sdf.format(cal.getTime());
         String yesterday = sdf.format(cal.getTime());
-
-        log.info("【每日增量】同步设备利用率，日期: {}", yesterday);
-        doSyncDevUtil(yesterday, yesterday);
+        for (String corpCode : corpCodes) {
+            log.info("【每日增量】同步设备利用率, corpCode:{}, 日期: {}", corpCode, yesterday);
+            doSyncDevUtil(corpCode, yesterday, yesterday);
+        }
     }
     }
 
 
-    /**
-     * 核心同步逻辑：获取设备列表 → 按每31天分批调用 dtuSnRateOfAction → 写入/更新 t_auto_ymk_iot_dev_util
-     */
-    private void doSyncDevUtil(String startDate, String endDate) {
-        String deviceResult = getDeviceInfo();
+    private void doSyncDevUtil(String corpCode, String startDate, String endDate) {
+        String deviceResult = getDeviceInfo(corpCode);
         if (StringUtils.isBlank(deviceResult)) {
         if (StringUtils.isBlank(deviceResult)) {
             log.error("获取设备列表失败");
             log.error("获取设备列表失败");
             return;
             return;
         }
         }
-        Map<String, Object> deviceInfos = JSON.parseObject(deviceResult, new TypeReference<>() {});
+        Map<String, Object> deviceInfos = JSON.parseObject(deviceResult, new TypeReference<>() {
+        });
         JSONArray deviceInfoList = (JSONArray) deviceInfos.get("data");
         JSONArray deviceInfoList = (JSONArray) deviceInfos.get("data");
         if (CollectionUtils.isEmpty(deviceInfoList)) {
         if (CollectionUtils.isEmpty(deviceInfoList)) {
             log.warn("设备列表为空");
             log.warn("设备列表为空");
             return;
             return;
         }
         }
 
 
-        // 按最多31天拆分为多个日期区间
         List<DateRange> batches = splitDateRange(startDate, endDate);
         List<DateRange> batches = splitDateRange(startDate, endDate);
-        log.info("开始同步设备利用率数据，设备数: {}, 日期范围: {} ~ {}, 共分{}批次",
-                deviceInfoList.size(), startDate, endDate, batches.size());
-        int totalSaved = 0;
+        log.info("开始同步设备利用率数据, corpCode:{}, 设备数:{}, 日期范围: {} ~ {}, 共分{}批次",
+                corpCode, deviceInfoList.size(), startDate, endDate, batches.size());
 
 
         for (Object o : deviceInfoList) {
         for (Object o : deviceInfoList) {
             JSONObject deviceInfoJson = (JSONObject) o;
             JSONObject deviceInfoJson = (JSONObject) o;
             String dtuSn = deviceInfoJson.getString("dtuSn");
             String dtuSn = deviceInfoJson.getString("dtuSn");
-
-            // 每个设备按31天一批次逐批调用
             for (DateRange batch : batches) {
             for (DateRange batch : batches) {
                 try {
                 try {
-                    String rateResult = getDtuSnRateOfAction(dtuSn, batch.start, batch.end);
+                    String rateResult = getDtuSnRateOfAction(corpCode, dtuSn, batch.start, batch.end);
                     if (StringUtils.isBlank(rateResult)) continue;
                     if (StringUtils.isBlank(rateResult)) continue;
-
-                    Map<String, Object> rateMap = JSON.parseObject(rateResult, new TypeReference<>() {});
+                    Map<String, Object> rateMap = JSON.parseObject(rateResult, new TypeReference<>() {
+                    });
                     Integer code = (Integer) rateMap.get("code");
                     Integer code = (Integer) rateMap.get("code");
                     if (code == null || code != 200) continue;
                     if (code == null || code != 200) continue;
-
                     JSONArray dataList = (JSONArray) rateMap.get("data");
                     JSONArray dataList = (JSONArray) rateMap.get("data");
                     if (CollectionUtils.isEmpty(dataList)) continue;
                     if (CollectionUtils.isEmpty(dataList)) continue;
-
                     for (int i = 0; i < dataList.size(); i++) {
                     for (int i = 0; i < dataList.size(); i++) {
                         JSONObject dayData = (JSONObject) dataList.get(i);
                         JSONObject dayData = (JSONObject) dataList.get(i);
                         String dateStr = dayData.getString("date");
                         String dateStr = dayData.getString("date");
                         JSONArray realRateList = dayData.getJSONArray("realRate");
                         JSONArray realRateList = dayData.getJSONArray("realRate");
                         if (CollectionUtils.isEmpty(realRateList)) continue;
                         if (CollectionUtils.isEmpty(realRateList)) continue;
-
                         JSONObject rateObj = (JSONObject) realRateList.get(0);
                         JSONObject rateObj = (JSONObject) realRateList.get(0);
-                        double state0 = rateObj.getDoubleValue("0");
-                        double state1 = rateObj.getDoubleValue("1");
-                        double state2 = rateObj.getDoubleValue("2");
-                        double state3 = rateObj.getDoubleValue("3");
-                        double state4 = rateObj.getDoubleValue("4");
-
-                        saveOrUpdateDevUtil(dtuSn, dateStr, state0, state1, state2, state3, state4);
-                        totalSaved++;
+                        double s0 = rateObj.getDoubleValue("0");
+                        double s1 = rateObj.getDoubleValue("1");
+                        double s2 = rateObj.getDoubleValue("2");
+                        double s3 = rateObj.getDoubleValue("3");
+                        double s4 = rateObj.getDoubleValue("4");
+                        saveOrUpdateDevUtil(corpCode, dtuSn, dateStr, s0, s1, s2, s3, s4);
                     }
                     }
                 } catch (Exception e) {
                 } catch (Exception e) {
                     log.error("处理设备 {} 数据异常 - 批次:{}~{}", dtuSn, batch.start, batch.end, e);
                     log.error("处理设备 {} 数据异常 - 批次:{}~{}", dtuSn, batch.start, batch.end, e);
                 }
                 }
             }
             }
         }
         }
-        log.info("设备利用率数据同步完成，共保存 {} 条记录", totalSaved);
     }
     }
 
 
-    /**
-     * 按最大31天将日期范围拆分为多段
-     */
     private static List<DateRange> splitDateRange(String startDate, String endDate) {
     private static List<DateRange> splitDateRange(String startDate, String endDate) {
         List<DateRange> ranges = new ArrayList<>();
         List<DateRange> ranges = new ArrayList<>();
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
@@ -382,21 +319,13 @@ public class DevicePullService {
             cur.setTime(sdf.parse(startDate));
             cur.setTime(sdf.parse(startDate));
             Calendar endCal = Calendar.getInstance();
             Calendar endCal = Calendar.getInstance();
             endCal.setTime(sdf.parse(endDate));
             endCal.setTime(sdf.parse(endDate));
-
             while (!cur.after(endCal)) {
             while (!cur.after(endCal)) {
                 DateRange range = new DateRange(sdf.format(cur.getTime()), null);
                 DateRange range = new DateRange(sdf.format(cur.getTime()), null);
-
-                // 向后推进30天（即当前日+30，共31天）
                 Calendar batchEnd = Calendar.getInstance();
                 Calendar batchEnd = Calendar.getInstance();
                 batchEnd.setTime(cur.getTime());
                 batchEnd.setTime(cur.getTime());
                 batchEnd.add(Calendar.DAY_OF_MONTH, 30);
                 batchEnd.add(Calendar.DAY_OF_MONTH, 30);
-
-                if (!batchEnd.after(endCal)) {
-                    range.end = sdf.format(batchEnd.getTime());
-                } else {
-                    range.end = sdf.format(endCal.getTime());
-                }
-
+                if (!batchEnd.after(endCal)) range.end = sdf.format(batchEnd.getTime());
+                else range.end = sdf.format(endCal.getTime());
                 ranges.add(range);
                 ranges.add(range);
                 cur.add(Calendar.DAY_OF_MONTH, 31);
                 cur.add(Calendar.DAY_OF_MONTH, 31);
             }
             }
@@ -406,7 +335,7 @@ public class DevicePullService {
         return ranges;
         return ranges;
     }
     }
 
 
-    private static class DateRange {
+    static class DateRange {
         String start;
         String start;
         String end;
         String end;
 
 
@@ -416,67 +345,66 @@ public class DevicePullService {
         }
         }
     }
     }
 
 
-    private void saveOrUpdateDevUtil(String dtuSn, String dateUtil,
-                                     double s0, double s1, double s2, double s3, double s4) {
-        List<Map<String, Object>> existList = jdbcTemplate.queryForList(
-                "SELECT id FROM " + devUtilTableName + " WHERE corp_code = ? AND dtuSn = ? AND date_util = ?",
-                deviceCorpCode, dtuSn, dateUtil);
+    private void saveOrUpdateDevUtil(String corpCode, String dtuSn, String dateUtil, double s0, double s1, double s2, double s3, double s4) {
+        String devUtilTableName = corpConfigService.getDevUtilTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
 
 
+        List<Map<String, Object>> existList = jt.queryForList(
+                "SELECT id FROM " + devUtilTableName + " WHERE corp_code = ? AND dtuSn = ? AND date_util = ?",
+                corpCode, dtuSn, dateUtil);
         Date now = new Date();
         Date now = new Date();
         if (!existList.isEmpty()) {
         if (!existList.isEmpty()) {
-            jdbcTemplate.update(
-                    "UPDATE " + devUtilTableName + " SET `0`=?,`1`=?,`2`=?,`3`=?,`4`=?,updated_at=? WHERE dtuSn=? AND date_util=?",
+            jt.update("UPDATE " + devUtilTableName + " SET `0`=?,`1`=?,`2`=?,`3`=?,`4`=?,updated_at=? WHERE dtuSn=? AND date_util=?",
                     s0, s1, s2, s3, s4, now, dtuSn, dateUtil);
                     s0, s1, s2, s3, s4, now, dtuSn, dateUtil);
         } else {
         } else {
             String id = UUID.randomUUID().toString().replace("-", "");
             String id = UUID.randomUUID().toString().replace("-", "");
-            jdbcTemplate.update(
-                    "INSERT INTO " + devUtilTableName + " (id,corp_code,created_at,created_by,updated_at,updated_by,date_util,dtuSn,`0`,`1`,`2`,`3`,`4`) " +
-                            "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                    id, deviceCorpCode, now, "system", now, "system", dateUtil, dtuSn, s0, s1, s2, s3, s4);
+            jt.update("INSERT INTO " + devUtilTableName + " (id,corp_code,created_at,created_by,updated_at,updated_by,date_util,dtuSn,`0`,`1`,`2`,`3`,`4`) " +
+                    "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", id, corpCode, now, "system", now, "system", dateUtil, dtuSn, s0, s1, s2, s3, s4);
         }
         }
     }
     }
 
 
     // ==================== OEE 时序数据同步 ====================
     // ==================== OEE 时序数据同步 ====================
 
 
-    /**
-     * 首次全量同步 OEE：本年1月1日 ~ 昨天（手动触发一次）
-     */
-    public void pullOeeAndSave() {
+    public void pullOeeAndSave(String corpCode) {
+        if (!corpConfigService.hasValidIotCredentials(corpCode)) {
+            log.warn("【全量同步-OEE】IoT凭证为空, 跳过同步, corpCode={}", corpCode);
+            return;
+        }
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         Calendar cal = Calendar.getInstance();
         Calendar cal = Calendar.getInstance();
         cal.add(Calendar.DAY_OF_MONTH, -1);
         cal.add(Calendar.DAY_OF_MONTH, -1);
         String endDate = sdf.format(cal.getTime());
         String endDate = sdf.format(cal.getTime());
         cal.set(cal.get(Calendar.YEAR), Calendar.JANUARY, 1);
         cal.set(cal.get(Calendar.YEAR), Calendar.JANUARY, 1);
         String startDate = sdf.format(cal.getTime());
         String startDate = sdf.format(cal.getTime());
-
-        log.info("【全量同步】OEE时序数据，日期范围: {} ~ {}", startDate, endDate);
-        doSyncOee(startDate, endDate);
+        log.info("【全量同步】OEE时序数据, corpCode:{}, 日期范围: {} ~ {}", corpCode, startDate, endDate);
+        doSyncOee(corpCode, "2026-05-01", endDate);
     }
     }
 
 
-    /**
-     * 每日增量同步 OEE：仅同步昨天（定时任务自动触发）
-     */
     @Scheduled(cron = "${scheduler.oee.cron:0 35 2 * * ?}")
     @Scheduled(cron = "${scheduler.oee.cron:0 35 2 * * ?}")
     public void pullOeeDaily() {
     public void pullOeeDaily() {
+        List<String> corpCodes = corpConfigService.getAllCorpCodes();
+        if (corpCodes.isEmpty()) {
+            log.warn("OEE: no corp config found, skip");
+            return;
+        }
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         Calendar cal = Calendar.getInstance();
         Calendar cal = Calendar.getInstance();
         cal.add(Calendar.DAY_OF_MONTH, -1);
         cal.add(Calendar.DAY_OF_MONTH, -1);
         String yesterday = sdf.format(cal.getTime());
         String yesterday = sdf.format(cal.getTime());
-
-        log.info("【每日增量】同步OEE时序数据，日期: {}", yesterday);
-        doSyncOee(yesterday, yesterday);
+        for (String corpCode : corpCodes) {
+            log.info("[Daily] sync OEE, corpCode:{}, date: {}", corpCode, yesterday);
+            doSyncOee(corpCode, yesterday, yesterday);
+        }
     }
     }
 
 
-    /**
-     * OEE 核心同步：获取设备列表 → 每个设备每天调用 /triColorLamp/dtuSn → lampData JSON 存入 description
-     */
-    private void doSyncOee(String startDate, String endDate) {
-        String deviceResult = getDeviceInfo();
+    private void doSyncOee(String corpCode, String startDate, String endDate) {
+        String deviceResult = getDeviceInfo(corpCode);
         if (StringUtils.isBlank(deviceResult)) {
         if (StringUtils.isBlank(deviceResult)) {
             log.error("获取设备列表失败");
             log.error("获取设备列表失败");
             return;
             return;
         }
         }
-        Map<String, Object> deviceInfos = JSON.parseObject(deviceResult, new TypeReference<>() {});
+        Map<String, Object> deviceInfos = JSON.parseObject(deviceResult, new TypeReference<>() {
+        });
         JSONArray deviceInfoList = (JSONArray) deviceInfos.get("data");
         JSONArray deviceInfoList = (JSONArray) deviceInfos.get("data");
         if (CollectionUtils.isEmpty(deviceInfoList)) {
         if (CollectionUtils.isEmpty(deviceInfoList)) {
             log.warn("设备列表为空");
             log.warn("设备列表为空");
@@ -499,30 +427,24 @@ public class DevicePullService {
             return;
             return;
         }
         }
 
 
-        log.info("开始同步OEE时序数据，设备数: {}, 天数: {}", deviceInfoList.size(), dateList.size());
         int totalSaved = 0;
         int totalSaved = 0;
-
         for (Object o : deviceInfoList) {
         for (Object o : deviceInfoList) {
             JSONObject deviceInfoJson = (JSONObject) o;
             JSONObject deviceInfoJson = (JSONObject) o;
             String dtuSn = deviceInfoJson.getString("dtuSn");
             String dtuSn = deviceInfoJson.getString("dtuSn");
-
             for (String dateStr : dateList) {
             for (String dateStr : dateList) {
                 try {
                 try {
-                    String lampResult = getLampData(dtuSn, dateStr);
+                    String lampResult = getLampData(corpCode, dtuSn, dateStr);
                     if (StringUtils.isBlank(lampResult)) continue;
                     if (StringUtils.isBlank(lampResult)) continue;
-
-                    Map<String, Object> lampMap = JSON.parseObject(lampResult, new TypeReference<>() {});
+                    Map<String, Object> lampMap = JSON.parseObject(lampResult, new TypeReference<>() {
+                    });
                     Integer code = (Integer) lampMap.get("code");
                     Integer code = (Integer) lampMap.get("code");
                     if (code == null || code != 200) continue;
                     if (code == null || code != 200) continue;
-
                     JSONArray dataList = (JSONArray) lampMap.get("data");
                     JSONArray dataList = (JSONArray) lampMap.get("data");
                     if (CollectionUtils.isEmpty(dataList)) continue;
                     if (CollectionUtils.isEmpty(dataList)) continue;
-
                     JSONObject dataObj = (JSONObject) dataList.get(0);
                     JSONObject dataObj = (JSONObject) dataList.get(0);
                     JSONArray lampDataArr = dataObj.getJSONArray("lampData");
                     JSONArray lampDataArr = dataObj.getJSONArray("lampData");
                     String description = lampDataArr != null ? lampDataArr.toJSONString() : "[]";
                     String description = lampDataArr != null ? lampDataArr.toJSONString() : "[]";
-
-                    saveOrUpdateOee(dtuSn, dateStr, description);
+                    saveOrUpdateOee(corpCode, dtuSn, dateStr, description);
                     totalSaved++;
                     totalSaved++;
                 } catch (Exception e) {
                 } catch (Exception e) {
                     log.error("处理OEE设备 {} 数据异常 - date:{}", dtuSn, dateStr, e);
                     log.error("处理OEE设备 {} 数据异常 - date:{}", dtuSn, dateStr, e);
@@ -532,11 +454,12 @@ public class DevicePullService {
         log.info("OEE时序数据同步完成，共保存 {} 条记录", totalSaved);
         log.info("OEE时序数据同步完成，共保存 {} 条记录", totalSaved);
     }
     }
 
 
-    private void saveOrUpdateOee(String dtuSn, String oeeDate, String description) {
+    private void saveOrUpdateOee(String corpCode, String dtuSn, String oeeDate, String description) {
+        String oeeTableName = corpConfigService.getOeeTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
         int maxLen = 60000;
         int maxLen = 60000;
         String lamp1 = "";
         String lamp1 = "";
         String lamp2 = "";
         String lamp2 = "";
-
         if (description.length() > maxLen) {
         if (description.length() > maxLen) {
             lamp1 = description.substring(0, maxLen);
             lamp1 = description.substring(0, maxLen);
             lamp2 = description.substring(maxLen);
             lamp2 = description.substring(maxLen);
@@ -544,175 +467,107 @@ public class DevicePullService {
             lamp1 = description;
             lamp1 = description;
         }
         }
 
 
-        List<Map<String, Object>> existList = jdbcTemplate.queryForList(
+        List<Map<String, Object>> existList = jt.queryForList(
                 "SELECT id FROM " + oeeTableName + " WHERE corp_code = ? AND dtuSn = ? AND oee_date = ?",
                 "SELECT id FROM " + oeeTableName + " WHERE corp_code = ? AND dtuSn = ? AND oee_date = ?",
-                deviceCorpCode, dtuSn, oeeDate);
-
+                corpCode, dtuSn, oeeDate);
         Date now = new Date();
         Date now = new Date();
         if (!existList.isEmpty()) {
         if (!existList.isEmpty()) {
-            jdbcTemplate.update(
-                    "UPDATE " + oeeTableName + " SET triColorLamp1=?, triColorLamp2=?, updated_at=? WHERE dtuSn=? AND oee_date=?",
-                    lamp1, lamp2, now, dtuSn, oeeDate);
+            jt.update("UPDATE " + oeeTableName + " SET triColorLamp1=?, triColorLamp2=?, updated_at=? WHERE dtuSn=? AND oee_date=?", lamp1, lamp2, now, dtuSn, oeeDate);
         } else {
         } else {
             String id = UUID.randomUUID().toString().replace("-", "");
             String id = UUID.randomUUID().toString().replace("-", "");
-            jdbcTemplate.update(
-                    "INSERT INTO " + oeeTableName + " (id,corp_code,created_at,created_by,updated_at,updated_by,dtuSn,oee_date,triColorLamp1,triColorLamp2) " +
-                            "VALUES (?,?,?,?,?,?,?,?,?,?)",
-                    id, deviceCorpCode, now, "system", now, "system", dtuSn, oeeDate, lamp1, lamp2);
+            jt.update("INSERT INTO " + oeeTableName + " (id,corp_code,created_at,created_by,updated_at,updated_by,dtuSn,oee_date,triColorLamp1,triColorLamp2) " +
+                    "VALUES (?,?,?,?,?,?,?,?,?,?)", id, corpCode, now, "system", now, "system", dtuSn, oeeDate, lamp1, lamp2);
         }
         }
     }
     }
 
 
-    public String getEnergyInfo() {
-        String accessToken = getAccessToken();
+    public String getEnergyInfo(String corpCode) {
+        String accessToken = getAccessToken(corpCode);
         Map<String, String> headerMap = new HashMap<>(1);
         Map<String, String> headerMap = new HashMap<>(1);
         headerMap.put("Authorization", "Bearer " + accessToken);
         headerMap.put("Authorization", "Bearer " + accessToken);
-
         Map<String, String> paramsMap = new HashMap<>();
         Map<String, String> paramsMap = new HashMap<>();
-        paramsMap.put("groupName", "SHC");
-
+        paramsMap.put("groupName", corpConfigService.getIotOrg(corpCode));
         String energyInfoResult = sendRequestGet(energyInfoUrl, paramsMap, headerMap);
         String energyInfoResult = sendRequestGet(energyInfoUrl, paramsMap, headerMap);
-        if (StringUtils.isBlank(energyInfoResult)) {
-            return null;
-        }
-
-        // 解析设备信息
+        if (StringUtils.isBlank(energyInfoResult)) return null;
         Map<String, Object> energyInfos = JSON.parseObject(energyInfoResult, new TypeReference<>() {
         Map<String, Object> energyInfos = JSON.parseObject(energyInfoResult, new TypeReference<>() {
         });
         });
         Integer energyInfoCode = (Integer) energyInfos.get("code");
         Integer energyInfoCode = (Integer) energyInfos.get("code");
-
-        // 如果code不为200，可能是accessToken失效，重新获取token并重试
         if (energyInfoCode != 200) {
         if (energyInfoCode != 200) {
-            accessToken = getAccessToken();
-            if (StringUtils.isEmpty(accessToken)) {
-                return null;
-            }
-
-            // 更新headerMap中的Authorization
+            accessToken = getAccessToken(corpCode);
+            if (StringUtils.isEmpty(accessToken)) return null;
             headerMap.put("Authorization", "Bearer " + accessToken);
             headerMap.put("Authorization", "Bearer " + accessToken);
-
-            // 第二次请求设备信息
             energyInfoResult = sendRequestGet(energyInfoUrl, paramsMap, headerMap);
             energyInfoResult = sendRequestGet(energyInfoUrl, paramsMap, headerMap);
-            if (StringUtils.isBlank(energyInfoResult)) {
-                return null;
-            }
-
-            // 重新解析设备信息
+            if (StringUtils.isBlank(energyInfoResult)) return null;
             energyInfos = JSON.parseObject(energyInfoResult, new TypeReference<Map<String, Object>>() {
             energyInfos = JSON.parseObject(energyInfoResult, new TypeReference<Map<String, Object>>() {
             });
             });
             energyInfoCode = (Integer) energyInfos.get("code");
             energyInfoCode = (Integer) energyInfos.get("code");
-
-            // 如果第二次请求仍然失败，返回错误信息
-            if (energyInfoCode != 200) {
-                return null;
-            }
+            if (energyInfoCode != 200) return null;
         }
         }
-
-        // 返回成功的设备信息
         return energyInfoResult;
         return energyInfoResult;
     }
     }
 
 
-    public String getDeviceInfo() {
-        String accessToken = getAccessToken();
-        // 初始化headerMap并设置Authorization
+    public String getDeviceInfo(String corpCode) {
+        String accessToken = getAccessToken(corpCode);
         Map<String, String> headerMap = new HashMap<>(1);
         Map<String, String> headerMap = new HashMap<>(1);
         headerMap.put("Authorization", "Bearer " + accessToken);
         headerMap.put("Authorization", "Bearer " + accessToken);
-
         Map<String, String> paramsMap = new HashMap<>();
         Map<String, String> paramsMap = new HashMap<>();
-        paramsMap.put("groupName", "SHC");
-
-        // 第一次请求设备信息
+        paramsMap.put("groupName", corpConfigService.getIotOrg(corpCode));
         String deviceResult = sendRequestGet(deviceInfoUrl, paramsMap, headerMap);
         String deviceResult = sendRequestGet(deviceInfoUrl, paramsMap, headerMap);
-
-        // 检查设备信息是否为空
-        if (StringUtils.isBlank(deviceResult)) {
-            return null;
-        }
-
-        // 解析设备信息
+        if (StringUtils.isBlank(deviceResult)) return null;
         Map<String, Object> deviceInfos = JSON.parseObject(deviceResult, new TypeReference<Map<String, Object>>() {
         Map<String, Object> deviceInfos = JSON.parseObject(deviceResult, new TypeReference<Map<String, Object>>() {
         });
         });
         Integer deviceInfoCode = (Integer) deviceInfos.get("code");
         Integer deviceInfoCode = (Integer) deviceInfos.get("code");
-
-        // 如果code不为200，可能是accessToken失效，重新获取token并重试
         if (deviceInfoCode != 200) {
         if (deviceInfoCode != 200) {
-            accessToken = getAccessToken();
-            if (StringUtils.isEmpty(accessToken)) {
-                return null;
-            }
-
-            // 更新headerMap中的Authorization
+            accessToken = getAccessToken(corpCode);
+            if (StringUtils.isEmpty(accessToken)) return null;
             headerMap.put("Authorization", "Bearer " + accessToken);
             headerMap.put("Authorization", "Bearer " + accessToken);
-
-            // 第二次请求设备信息
             deviceResult = sendRequestGet(deviceInfoUrl, paramsMap, headerMap);
             deviceResult = sendRequestGet(deviceInfoUrl, paramsMap, headerMap);
-            if (StringUtils.isBlank(deviceResult)) {
-                return null;
-            }
-
-            // 重新解析设备信息
+            if (StringUtils.isBlank(deviceResult)) return null;
             deviceInfos = JSON.parseObject(deviceResult, new TypeReference<Map<String, Object>>() {
             deviceInfos = JSON.parseObject(deviceResult, new TypeReference<Map<String, Object>>() {
             });
             });
             deviceInfoCode = (Integer) deviceInfos.get("code");
             deviceInfoCode = (Integer) deviceInfos.get("code");
-
-            // 如果第二次请求仍然失败，返回错误信息
-            if (deviceInfoCode != 200) {
-                return null;
-            }
+            if (deviceInfoCode != 200) return null;
         }
         }
-
-        // 返回成功的设备信息
         return deviceResult;
         return deviceResult;
     }
     }
 
 
-    private String getAccessToken() {
+    private String getAccessToken(String corpCode) {
+        String redisKey = "hnyssl_device_token_" + corpCode;
         String accessToken = "";
         String accessToken = "";
-        String redisKey = "hnyssl_device_token";
         if (StringUtils.isNotBlank(redisTemplate.opsForValue().get(redisKey)) && redisTemplate.getExpire(redisKey) > 0) {
         if (StringUtils.isNotBlank(redisTemplate.opsForValue().get(redisKey)) && redisTemplate.getExpire(redisKey) > 0) {
             return redisTemplate.opsForValue().get(redisKey);
             return redisTemplate.opsForValue().get(redisKey);
         }
         }
-
+        // 使用公司配置中的用户名密码，如果没有则用默认值
+        String userName = corpConfigService.getIotUsername(corpCode);
+        String password = corpConfigService.getIotPassword(corpCode);
         Map<String, String> param = new HashMap<>(2);
         Map<String, String> param = new HashMap<>(2);
-        param.put("username", deviceUserName);
-        param.put("password", devicePassword);
+        param.put("username", userName);
+        param.put("password", password);
         HttpPost httpPost = new HttpPost(deviceTokenUrl);
         HttpPost httpPost = new HttpPost(deviceTokenUrl);
         String result = sendPost(httpPost, JSON.toJSONString(param));
         String result = sendPost(httpPost, JSON.toJSONString(param));
-        if (StringUtils.isBlank(result)) {
-            return accessToken;
-        }
-
+        if (StringUtils.isBlank(result)) return accessToken;
         Map<String, Object> res = JSON.parseObject(result, new TypeReference<>() {
         Map<String, Object> res = JSON.parseObject(result, new TypeReference<>() {
         });
         });
-
         Integer code = (Integer) res.get("code");
         Integer code = (Integer) res.get("code");
         if (code == 200) {
         if (code == 200) {
             JSONObject data = (JSONObject) res.get("data");
             JSONObject data = (JSONObject) res.get("data");
             accessToken = (String) data.get("token");
             accessToken = (String) data.get("token");
-            redisTemplate.opsForValue().set(redisKey, accessToken, 3600, TimeUnit.SECONDS); // 一小时过期
+            redisTemplate.opsForValue().set(redisKey, accessToken, 3600, TimeUnit.SECONDS);
         }
         }
-
         return accessToken;
         return accessToken;
     }
     }
 
 
     public static String sendRequestGet(String url, Map<String, String> params, Map<String, String> header) {
     public static String sendRequestGet(String url, Map<String, String> params, Map<String, String> header) {
-        //实例化httpclient
         CloseableHttpClient httpclient = HttpClients.createDefault();
         CloseableHttpClient httpclient = HttpClients.createDefault();
         url = builderUrl(url, params);
         url = builderUrl(url, params);
-        //请求结果
         String content = "";
         String content = "";
-        //实例化get方法
         HttpGet httpget = new HttpGet(url);
         HttpGet httpget = new HttpGet(url);
         if (!CollectionUtils.isEmpty(header)) {
         if (!CollectionUtils.isEmpty(header)) {
-            for (Map.Entry<String, String> entry : header.entrySet()) {
+            for (Map.Entry<String, String> entry : header.entrySet())
                 httpget.setHeader(entry.getKey(), entry.getValue());
                 httpget.setHeader(entry.getKey(), entry.getValue());
-            }
         }
         }
-
         try (CloseableHttpResponse response = httpclient.execute(httpget)) {
         try (CloseableHttpResponse response = httpclient.execute(httpget)) {
-
-            //执行get方法
-            if (response.getStatusLine().getStatusCode() == 200) {
+            if (response.getStatusLine().getStatusCode() == 200)
                 content = EntityUtils.toString(response.getEntity(), "UTF-8");
                 content = EntityUtils.toString(response.getEntity(), "UTF-8");
-            }
         } catch (IOException e) {
         } catch (IOException e) {
             log.error("sendRequest---GET Error!", e);
             log.error("sendRequest---GET Error!", e);
         }
         }
@@ -723,13 +578,9 @@ public class DevicePullService {
         UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromHttpUrl(url);
         UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromHttpUrl(url);
         if (!CollectionUtils.isEmpty(params)) {
         if (!CollectionUtils.isEmpty(params)) {
             MultiValueMap<String, String> paramsValue = new LinkedMultiValueMap<>();
             MultiValueMap<String, String> paramsValue = new LinkedMultiValueMap<>();
-            for (Map.Entry<String, String> entry : params.entrySet()) {
-                paramsValue.add(entry.getKey(), entry.getValue());
-            }
-
+            for (Map.Entry<String, String> entry : params.entrySet()) paramsValue.add(entry.getKey(), entry.getValue());
             uriBuilder = uriBuilder.queryParams(paramsValue);
             uriBuilder = uriBuilder.queryParams(paramsValue);
         }
         }
-
         return uriBuilder.toUriString();
         return uriBuilder.toUriString();
     }
     }
 
 
@@ -745,9 +596,7 @@ public class DevicePullService {
             int len;
             int len;
             byte[] buf = new byte[128];
             byte[] buf = new byte[128];
             ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
             ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
-            while ((len = is.read(buf)) != -1) {
-                byteArrayOutputStream.write(buf, 0, len);
-            }
+            while ((len = is.read(buf)) != -1) byteArrayOutputStream.write(buf, 0, len);
             result = byteArrayOutputStream.toString();
             result = byteArrayOutputStream.toString();
         } catch (IOException e) {
         } catch (IOException e) {
             e.printStackTrace();
             e.printStackTrace();

@@ -4,7 +4,6 @@ import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.alibaba.fastjson.JSONObject;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 import org.springframework.util.StringUtils;
 import org.springframework.util.StringUtils;
@@ -18,26 +17,22 @@ import java.util.*;
 @Service
 @Service
 public class DeviceSearchService {
 public class DeviceSearchService {
 
 
-    @Value("${device.db.corpCode}")
-    private String deviceCorpCode;
-    @Value("${device.db.tableName}")
-    private String deviceTableName;
-    @Value("${device.db.oeeTableName}")
-    private String oeeTableName;
-    @Value("${device.db.devUtilTableName}")
-    private String devUtilTableName;
-
     @Resource
     @Resource
     private JdbcTemplate jdbcTemplate;
     private JdbcTemplate jdbcTemplate;
     @Resource
     @Resource
     private DevicePullService devicePullService;
     private DevicePullService devicePullService;
+    @Resource
+    private CorpConfigService corpConfigService;
 
 
-    public Map<String, Object> queryDeviceList(String deviceName, String lampState, Integer pageNo, Integer pageSize) {
-        StringBuilder countSql = new StringBuilder("SELECT COUNT(*) FROM " + deviceTableName + " WHERE corp_code = ?");
+    public Map<String, Object> queryDeviceList(String corpCode, String deviceName, String lampState, Integer pageNo, Integer pageSize) {
+        String tableName = corpConfigService.getDeviceTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
+
+        StringBuilder countSql = new StringBuilder("SELECT COUNT(*) FROM " + tableName + " WHERE corp_code = ?");
         StringBuilder querySql = new StringBuilder("SELECT id, deviceName, projectType, projectState, dtuSn, dtuId, deviceId, " +
         StringBuilder querySql = new StringBuilder("SELECT id, deviceName, projectType, projectState, dtuSn, dtuId, deviceId, " +
-                "lampState, startTime, duration, utilizationRate FROM " + deviceTableName + " WHERE corp_code = ?");
+                "lampState, startTime, duration, utilizationRate FROM " + tableName + " WHERE corp_code = ?");
         List<Object> params = new java.util.ArrayList<>();
         List<Object> params = new java.util.ArrayList<>();
-        params.add(deviceCorpCode);
+        params.add(corpCode);
 
 
         if (StringUtils.hasText(deviceName)) {
         if (StringUtils.hasText(deviceName)) {
             countSql.append(" AND deviceName LIKE ?");
             countSql.append(" AND deviceName LIKE ?");
@@ -50,13 +45,13 @@ public class DeviceSearchService {
             params.add(lampState);
             params.add(lampState);
         }
         }
 
 
-        Long total = jdbcTemplate.queryForObject(countSql.toString(), Long.class, params.toArray());
+        Long total = jt.queryForObject(countSql.toString(), Long.class, params.toArray());
         int offset = (pageNo - 1) * pageSize;
         int offset = (pageNo - 1) * pageSize;
         querySql.append(" ORDER BY created_at DESC LIMIT ?, ?");
         querySql.append(" ORDER BY created_at DESC LIMIT ?, ?");
         params.add(offset);
         params.add(offset);
         params.add(pageSize);
         params.add(pageSize);
 
 
-        List<Map<String, Object>> list = jdbcTemplate.queryForList(querySql.toString(), params.toArray());
+        List<Map<String, Object>> list = jt.queryForList(querySql.toString(), params.toArray());
 
 
         return Map.of(
         return Map.of(
                 "total", total != null ? total : 0,
                 "total", total != null ? total : 0,
@@ -66,10 +61,13 @@ public class DeviceSearchService {
         );
         );
     }
     }
 
 
-    public Map<String, Object> queryDeviceStats() {
-        String sql = "SELECT lampState, COUNT(*) as cnt FROM " + deviceTableName +
+    public Map<String, Object> queryDeviceStats(String corpCode) {
+        String tableName = corpConfigService.getDeviceTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
+
+        String sql = "SELECT lampState, COUNT(*) as cnt FROM " + tableName +
                 " WHERE corp_code = ? GROUP BY lampState";
                 " WHERE corp_code = ? GROUP BY lampState";
-        List<Map<String, Object>> rows = jdbcTemplate.queryForList(sql, deviceCorpCode);
+        List<Map<String, Object>> rows = jt.queryForList(sql, corpCode);
 
 
         long all = 0;
         long all = 0;
         long red = 0, yellow = 0, green = 0, blue = 0, off = 0;
         long red = 0, yellow = 0, green = 0, blue = 0, off = 0;
@@ -96,9 +94,10 @@ public class DeviceSearchService {
         );
         );
     }
     }
 
 
-    public Map<String, Object> queryLampData(String dtuSn, String date) {
-        String result = devicePullService.getLampData(dtuSn, date);
-        Map<String, Object> res = com.alibaba.fastjson.JSON.parseObject(result, new com.alibaba.fastjson.TypeReference<>() {});
+    public Map<String, Object> queryLampData(String corpCode, String dtuSn, String date) {
+        String result = devicePullService.getLampData(corpCode, dtuSn, date);
+        Map<String, Object> res = com.alibaba.fastjson.JSON.parseObject(result, new com.alibaba.fastjson.TypeReference<>() {
+        });
         Integer code = (Integer) res.get("code");
         Integer code = (Integer) res.get("code");
         if (code == null || code != 200) {
         if (code == null || code != 200) {
             return Map.of("lampDurationStats", Map.of(), "list", List.of());
             return Map.of("lampDurationStats", Map.of(), "list", List.of());
@@ -159,28 +158,29 @@ public class DeviceSearchService {
 
 
     /**
     /**
      * 稼动率/OEE统计查询
      * 稼动率/OEE统计查询
-     * @param dtuSn   设备序列号（可选，为空查全部）
-     * @param type    查询类型：day-日(按日期段), week-周(今年第1周~本周), month-月(今年1月~本月)
+     *
+     * @param corpCode  公司编码
+     * @param dtuSn     设备序列号（可选，为空查全部）
+     * @param type      查询类型：day-日(按日期段), week-周(今年第1周~本周), month-月(今年1月~本月)
      * @param startDate 日模式下的开始日期(yyyy-MM-dd)
      * @param startDate 日模式下的开始日期(yyyy-MM-dd)
      * @param endDate   日模式下的结束日期(yyyy-MM-dd)
      * @param endDate   日模式下的结束日期(yyyy-MM-dd)
      */
      */
-    public Map<String, Object> queryOeeStats(String dtuSn, String type, String startDate, String endDate) {
+    public Map<String, Object> queryOeeStats(String corpCode, String dtuSn, String type, String startDate, String endDate) {
         // 1. 根据类型确定日期范围
         // 1. 根据类型确定日期范围
         List<String> dates = buildDateRange(type, startDate, endDate);
         List<String> dates = buildDateRange(type, startDate, endDate);
-        log.info("OEE查询 - type:{}, dtuSn:{}, 日期范围:{}天, 起始:{}, 结束:{}", type, dtuSn, dates.size(), dates.get(0), dates.get(dates.size() - 1));
+        log.info("OEE查询 - corpCode:{}, type:{}, dtuSn:{}, 日期范围:{}天, 起始:{}, 结束:{}", corpCode, type, dtuSn, dates.size(), dates.get(0), dates.get(dates.size() - 1));
 
 
         // 判断是否包含今天
         // 判断是否包含今天
         String todayStr = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
         String todayStr = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
         boolean includeToday = dates.contains(todayStr);
         boolean includeToday = dates.contains(todayStr);
 
 
         // 2. 从数据库查询 oee 表数据
         // 2. 从数据库查询 oee 表数据
-        List<Map<String, Object>> dbRecords = queryOeeFromDb(dtuSn, dates, includeToday ? todayStr : null);
+        List<Map<String, Object>> dbRecords = queryOeeFromDb(corpCode, dtuSn, dates, includeToday ? todayStr : null);
         log.info("OEE查询 - DB返回记录数:{}, 排除today:{}", dbRecords.size(), includeToday ? todayStr : "无");
         log.info("OEE查询 - DB返回记录数:{}, 排除today:{}", dbRecords.size(), includeToday ? todayStr : "无");
-        
+
         Map<String, JSONObject> dbDataMap = new LinkedHashMap<>();
         Map<String, JSONObject> dbDataMap = new LinkedHashMap<>();
         for (Map<String, Object> record : dbRecords) {
         for (Map<String, Object> record : dbRecords) {
             String oeeDate = String.valueOf(record.get("oee_date"));
             String oeeDate = String.valueOf(record.get("oee_date"));
-            // 截断时间部分，只保留日期 yyyy-MM-dd
             if (oeeDate.length() > 10) {
             if (oeeDate.length() > 10) {
                 oeeDate = oeeDate.substring(0, 10);
                 oeeDate = oeeDate.substring(0, 10);
             }
             }
@@ -200,10 +200,11 @@ public class DeviceSearchService {
         // 3. 如果包含今天且数据库没有今天的实时数据，则调用接口获取
         // 3. 如果包含今天且数据库没有今天的实时数据，则调用接口获取
         if (includeToday && !dbDataMap.containsKey(todayStr)) {
         if (includeToday && !dbDataMap.containsKey(todayStr)) {
             if (StringUtils.hasText(dtuSn)) {
             if (StringUtils.hasText(dtuSn)) {
-                String apiResult = devicePullService.getLampData(dtuSn, todayStr);
+                String apiResult = devicePullService.getLampData(corpCode, dtuSn, todayStr);
                 if (StringUtils.hasText(apiResult)) {
                 if (StringUtils.hasText(apiResult)) {
                     Map<String, Object> res = com.alibaba.fastjson.JSON.parseObject(apiResult,
                     Map<String, Object> res = com.alibaba.fastjson.JSON.parseObject(apiResult,
-                            new com.alibaba.fastjson.TypeReference<>() {});
+                            new com.alibaba.fastjson.TypeReference<>() {
+                            });
                     Integer code = (Integer) res.get("code");
                     Integer code = (Integer) res.get("code");
                     if (code != null && code == 200) {
                     if (code != null && code == 200) {
                         JSONArray dataList = (JSONArray) res.get("data");
                         JSONArray dataList = (JSONArray) res.get("data");
@@ -241,9 +242,6 @@ public class DeviceSearchService {
         );
         );
     }
     }
 
 
-    /**
-     * 按天统计
-     */
     private Map<String, Object> aggregateByDay(List<String> dates, Map<String, JSONObject> dbDataMap) {
     private Map<String, Object> aggregateByDay(List<String> dates, Map<String, JSONObject> dbDataMap) {
         List<Map<String, Object>> dailyStats = new ArrayList<>();
         List<Map<String, Object>> dailyStats = new ArrayList<>();
         long totalOffDur = 0, totalRedDur = 0, totalYellowDur = 0, totalGreenDur = 0, totalBlueDur = 0;
         long totalOffDur = 0, totalRedDur = 0, totalYellowDur = 0, totalGreenDur = 0, totalBlueDur = 0;
@@ -252,19 +250,25 @@ public class DeviceSearchService {
         for (String d : dates) {
         for (String d : dates) {
             long[] counts = countLampData(dbDataMap.get(d));
             long[] counts = countLampData(dbDataMap.get(d));
 
 
-            totalOffDur += counts[0]; totalRedDur += counts[2]; totalYellowDur += counts[4];
-            totalGreenDur += counts[6]; totalBlueDur += counts[8];
-            totalOffCnt += (int)counts[1]; totalRedCnt += (int)counts[3]; totalYellowCnt += (int)counts[5];
-            totalGreenCnt += (int)counts[7]; totalBlueCnt += (int)counts[9];
+            totalOffDur += counts[0];
+            totalRedDur += counts[2];
+            totalYellowDur += counts[4];
+            totalGreenDur += counts[6];
+            totalBlueDur += counts[8];
+            totalOffCnt += (int) counts[1];
+            totalRedCnt += (int) counts[3];
+            totalYellowCnt += (int) counts[5];
+            totalGreenCnt += (int) counts[7];
+            totalBlueCnt += (int) counts[9];
 
 
             Map<String, Object> dayStat = new LinkedHashMap<>();
             Map<String, Object> dayStat = new LinkedHashMap<>();
             dayStat.put("label", d);
             dayStat.put("label", d);
             dayStat.put("date", d);
             dayStat.put("date", d);
-            dayStat.put("off", Map.of("duration", formatDuration(counts[0]), "seconds", counts[0], "count", (int)counts[1]));
-            dayStat.put("red", Map.of("duration", formatDuration(counts[2]), "seconds", counts[2], "count", (int)counts[3]));
-            dayStat.put("yellow", Map.of("duration", formatDuration(counts[4]), "seconds", counts[4], "count", (int)counts[5]));
-            dayStat.put("green", Map.of("duration", formatDuration(counts[6]), "seconds", counts[6], "count", (int)counts[7]));
-            dayStat.put("blue", Map.of("duration", formatDuration(counts[8]), "seconds", counts[8], "count", (int)counts[9]));
+            dayStat.put("off", Map.of("duration", formatDuration(counts[0]), "seconds", counts[0], "count", (int) counts[1]));
+            dayStat.put("red", Map.of("duration", formatDuration(counts[2]), "seconds", counts[2], "count", (int) counts[3]));
+            dayStat.put("yellow", Map.of("duration", formatDuration(counts[4]), "seconds", counts[4], "count", (int) counts[5]));
+            dayStat.put("green", Map.of("duration", formatDuration(counts[6]), "seconds", counts[6], "count", (int) counts[7]));
+            dayStat.put("blue", Map.of("duration", formatDuration(counts[8]), "seconds", counts[8], "count", (int) counts[9]));
             dailyStats.add(dayStat);
             dailyStats.add(dayStat);
         }
         }
 
 
@@ -274,22 +278,16 @@ public class DeviceSearchService {
         return Map.of("list", dailyStats, "summary", summary);
         return Map.of("list", dailyStats, "summary", summary);
     }
     }
 
 
-    /**
-     * 按周统计
-     */
     private Map<String, Object> aggregateByWeek(List<String> dates, Map<String, JSONObject> dbDataMap) {
     private Map<String, Object> aggregateByWeek(List<String> dates, Map<String, JSONObject> dbDataMap) {
-        // 按自然周（周一~周日）分组，第一周从1月1日开始（可能不足7天）
         List<List<String>> weekBuckets = new ArrayList<>();
         List<List<String>> weekBuckets = new ArrayList<>();
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 
 
-        // 确定年份和该年第一个周一的日期
         String yearStr = dates.get(0).substring(0, 4);
         String yearStr = dates.get(0).substring(0, 4);
         int year = Integer.parseInt(yearStr);
         int year = Integer.parseInt(yearStr);
         Calendar jan1 = Calendar.getInstance();
         Calendar jan1 = Calendar.getInstance();
         jan1.set(year, Calendar.JANUARY, 1);
         jan1.set(year, Calendar.JANUARY, 1);
         int jan1Dow = jan1.get(Calendar.DAY_OF_WEEK);
         int jan1Dow = jan1.get(Calendar.DAY_OF_WEEK);
 
 
-        // 找到第一个周一：如果1月1日就是周一，则firstMonday=1月1日；否则往后推到周一
         Calendar firstMonday = Calendar.getInstance();
         Calendar firstMonday = Calendar.getInstance();
         firstMonday.setTime(jan1.getTime());
         firstMonday.setTime(jan1.getTime());
         int daysToAdd = jan1Dow == Calendar.MONDAY ? 0 : (Calendar.MONDAY - jan1Dow + 7) % 7;
         int daysToAdd = jan1Dow == Calendar.MONDAY ? 0 : (Calendar.MONDAY - jan1Dow + 7) % 7;
@@ -307,13 +305,11 @@ public class DeviceSearchService {
 
 
                 int bucketIndex;
                 int bucketIndex;
                 if (!cal.after(firstMonday)) {
                 if (!cal.after(firstMonday)) {
-                    // 在第一个周一之前（含当天），属于第1周（从1月1日开始）
                     bucketIndex = 0;
                     bucketIndex = 0;
                 } else {
                 } else {
-                    // 第一个周一之后，按完整自然周计算
                     long diffMs = cal.getTimeInMillis() - firstMonday.getTimeInMillis();
                     long diffMs = cal.getTimeInMillis() - firstMonday.getTimeInMillis();
                     long diffDays = diffMs / (1000 * 60 * 60 * 24);
                     long diffDays = diffMs / (1000 * 60 * 60 * 24);
-                    bucketIndex = 1 + (int)(diffDays / 7); // 第2周、第3周...
+                    bucketIndex = 1 + (int) (diffDays / 7);
                 }
                 }
 
 
                 while (weekBuckets.size() <= bucketIndex) {
                 while (weekBuckets.size() <= bucketIndex) {
@@ -326,23 +322,39 @@ public class DeviceSearchService {
         }
         }
 
 
         List<Map<String, Object>> weeklyStats = new ArrayList<>();
         List<Map<String, Object>> weeklyStats = new ArrayList<>();
-        long tOffD=0, tRedD=0, tYelD=0, tGrnD=0, tBluD=0;
-        int tOffC=0, tRedC=0, tYelC=0, tGrnC=0, tBluC=0;
+        long tOffD = 0, tRedD = 0, tYelD = 0, tGrnD = 0, tBluD = 0;
+        int tOffC = 0, tRedC = 0, tYelC = 0, tGrnC = 0, tBluC = 0;
 
 
         for (int i = 0; i < weekBuckets.size(); i++) {
         for (int i = 0; i < weekBuckets.size(); i++) {
             List<String> daysInWeek = weekBuckets.get(i);
             List<String> daysInWeek = weekBuckets.get(i);
             if (daysInWeek.isEmpty()) continue;
             if (daysInWeek.isEmpty()) continue;
-            long wOffD=0, wRedD=0, wYelD=0, wGrnD=0, wBluD=0;
-            int wOffC=0, wRedC=0, wYelC=0, wGrnC=0, wBluC=0;
+            long wOffD = 0, wRedD = 0, wYelD = 0, wGrnD = 0, wBluD = 0;
+            int wOffC = 0, wRedC = 0, wYelC = 0, wGrnC = 0, wBluC = 0;
 
 
             for (String d : daysInWeek) {
             for (String d : daysInWeek) {
                 long[] cnt = countLampData(dbDataMap.get(d));
                 long[] cnt = countLampData(dbDataMap.get(d));
-                wOffD += cnt[0]; wRedD += cnt[2]; wYelD += cnt[4]; wGrnD += cnt[6]; wBluD += cnt[8];
-                wOffC += (int)cnt[1]; wRedC += (int)cnt[3]; wYelC += (int)cnt[5]; wGrnC += (int)cnt[7]; wBluC += (int)cnt[9];
+                wOffD += cnt[0];
+                wRedD += cnt[2];
+                wYelD += cnt[4];
+                wGrnD += cnt[6];
+                wBluD += cnt[8];
+                wOffC += (int) cnt[1];
+                wRedC += (int) cnt[3];
+                wYelC += (int) cnt[5];
+                wGrnC += (int) cnt[7];
+                wBluC += (int) cnt[9];
             }
             }
 
 
-            tOffD+=wOffD; tRedD+=wRedD; tYelD+=wYelD; tGrnD+=wGrnD; tBluD+=wBluD;
-            tOffC+=wOffC; tRedC+=wRedC; tYelC+=wYelC; tGrnC+=wGrnC; tBluC+=wBluC;
+            tOffD += wOffD;
+            tRedD += wRedD;
+            tYelD += wYelD;
+            tGrnD += wGrnD;
+            tBluD += wBluD;
+            tOffC += wOffC;
+            tRedC += wRedC;
+            tYelC += wYelC;
+            tGrnC += wGrnC;
+            tBluC += wBluC;
 
 
             Collections.sort(daysInWeek);
             Collections.sort(daysInWeek);
             Map<String, Object> ws = new LinkedHashMap<>();
             Map<String, Object> ws = new LinkedHashMap<>();
@@ -363,39 +375,51 @@ public class DeviceSearchService {
         return Map.of("list", weeklyStats, "summary", summary);
         return Map.of("list", weeklyStats, "summary", summary);
     }
     }
 
 
-    /**
-     * 按月统计
-     */
     private Map<String, Object> aggregateByMonth(List<String> dates, Map<String, JSONObject> dbDataMap) {
     private Map<String, Object> aggregateByMonth(List<String> dates, Map<String, JSONObject> dbDataMap) {
-        // 按 年-月 分组
         Map<String, List<String>> monthGroups = new LinkedHashMap<>();
         Map<String, List<String>> monthGroups = new LinkedHashMap<>();
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 
 
         for (String d : dates) {
         for (String d : dates) {
-            String monthKey = d.substring(0, 7); // yyyy-MM
+            String monthKey = d.substring(0, 7);
             monthGroups.computeIfAbsent(monthKey, k -> new ArrayList<>()).add(d);
             monthGroups.computeIfAbsent(monthKey, k -> new ArrayList<>()).add(d);
         }
         }
 
 
         List<Map<String, Object>> monthlyStats = new ArrayList<>();
         List<Map<String, Object>> monthlyStats = new ArrayList<>();
-        long tOffD=0, tRedD=0, tYelD=0, tGrnD=0, tBluD=0;
-        int tOffC=0, tRedC=0, tYelC=0, tGrnC=0, tBluC=0;
+        long tOffD = 0, tRedD = 0, tYelD = 0, tGrnD = 0, tBluD = 0;
+        int tOffC = 0, tRedC = 0, tYelC = 0, tGrnC = 0, tBluC = 0;
 
 
         for (Map.Entry<String, List<String>> entry : monthGroups.entrySet()) {
         for (Map.Entry<String, List<String>> entry : monthGroups.entrySet()) {
             String monthKey = entry.getKey();
             String monthKey = entry.getKey();
             List<String> daysInMonth = entry.getValue();
             List<String> daysInMonth = entry.getValue();
-            long mOffD=0, mRedD=0, mYelD=0, mGrnD=0, mBluD=0;
-            int mOffC=0, mRedC=0, mYelC=0, mGrnC=0, mBluC=0;
+            long mOffD = 0, mRedD = 0, mYelD = 0, mGrnD = 0, mBluD = 0;
+            int mOffC = 0, mRedC = 0, mYelC = 0, mGrnC = 0, mBluC = 0;
 
 
             for (String d : daysInMonth) {
             for (String d : daysInMonth) {
                 long[] cnt = countLampData(dbDataMap.get(d));
                 long[] cnt = countLampData(dbDataMap.get(d));
-                mOffD += cnt[0]; mRedD += cnt[2]; mYelD += cnt[4]; mGrnD += cnt[6]; mBluD += cnt[8];
-                mOffC += (int)cnt[1]; mRedC += (int)cnt[3]; mYelC += (int)cnt[5]; mGrnC += (int)cnt[7]; mBluC += (int)cnt[9];
+                mOffD += cnt[0];
+                mRedD += cnt[2];
+                mYelD += cnt[4];
+                mGrnD += cnt[6];
+                mBluD += cnt[8];
+                mOffC += (int) cnt[1];
+                mRedC += (int) cnt[3];
+                mYelC += (int) cnt[5];
+                mGrnC += (int) cnt[7];
+                mBluC += (int) cnt[9];
             }
             }
 
 
-            tOffD+=mOffD; tRedD+=mRedD; tYelD+=mYelD; tGrnD+=mGrnD; tBluD+=mBluD;
-            tOffC+=mOffC; tRedC+=mRedC; tYelC+=mYelC; tGrnC+=mGrnC; tBluC+=mBluC;
-
-            String monthNum = monthKey.substring(5); // "01", "02" ...
+            tOffD += mOffD;
+            tRedD += mRedD;
+            tYelD += mYelD;
+            tGrnD += mGrnD;
+            tBluD += mBluD;
+            tOffC += mOffC;
+            tRedC += mRedC;
+            tYelC += mYelC;
+            tGrnC += mGrnC;
+            tBluC += mBluC;
+
+            String monthNum = monthKey.substring(5);
             Map<String, Object> ms = new LinkedHashMap<>();
             Map<String, Object> ms = new LinkedHashMap<>();
             ms.put("label", Integer.parseInt(monthNum) + "月");
             ms.put("label", Integer.parseInt(monthNum) + "月");
             ms.put("month", monthKey);
             ms.put("month", monthKey);
@@ -412,10 +436,6 @@ public class DeviceSearchService {
         return Map.of("list", monthlyStats, "summary", summary);
         return Map.of("list", monthlyStats, "summary", summary);
     }
     }
 
 
-    /**
-     * 统计单日 lampData 各状态时长和次数
-     * 返回 [offDur, offCnt, redDur, redCnt, yelDur, yelCnt, grnDur, grnCnt, bluDur, bluCnt]
-     */
     private long[] countLampData(JSONObject dayData) {
     private long[] countLampData(JSONObject dayData) {
         long[] result = new long[10];
         long[] result = new long[10];
         if (dayData != null) {
         if (dayData != null) {
@@ -423,14 +443,30 @@ public class DeviceSearchService {
             if (lampArr != null) {
             if (lampArr != null) {
                 for (int i = 0; i < lampArr.size(); i++) {
                 for (int i = 0; i < lampArr.size(); i++) {
                     JSONObject item = lampArr.getJSONObject(i);
                     JSONObject item = lampArr.getJSONObject(i);
+                    if (item == null) continue;
                     int state = item.getIntValue("lampState");
                     int state = item.getIntValue("lampState");
                     long dur = item.getLongValue("duration");
                     long dur = item.getLongValue("duration");
                     switch (state) {
                     switch (state) {
-                        case 0 -> { result[0] += dur; result[1]++; }
-                        case 1 -> { result[2] += dur; result[3]++; }
-                        case 2 -> { result[4] += dur; result[5]++; }
-                        case 3 -> { result[6] += dur; result[7]++; }
-                        case 4 -> { result[8] += dur; result[9]++; }
+                        case 0 -> {
+                            result[0] += dur;
+                            result[1]++;
+                        }
+                        case 1 -> {
+                            result[2] += dur;
+                            result[3]++;
+                        }
+                        case 2 -> {
+                            result[4] += dur;
+                            result[5]++;
+                        }
+                        case 3 -> {
+                            result[6] += dur;
+                            result[7]++;
+                        }
+                        case 4 -> {
+                            result[8] += dur;
+                            result[9]++;
+                        }
                     }
                     }
                 }
                 }
             }
             }
@@ -438,11 +474,8 @@ public class DeviceSearchService {
         return result;
         return result;
     }
     }
 
 
-    /**
-     * 构建 summary 汇总对象
-     */
     private Map<String, Object> buildSummary(long offD, long redD, long yelD, long grnD, long bluD,
     private Map<String, Object> buildSummary(long offD, long redD, long yelD, long grnD, long bluD,
-                                              int offC, int redC, int yelC, int grnC, int bluC) {
+                                             int offC, int redC, int yelC, int grnC, int bluC) {
         Map<String, Object> summary = new LinkedHashMap<>();
         Map<String, Object> summary = new LinkedHashMap<>();
         summary.put("off", Map.of("duration", formatDuration(offD), "seconds", offD, "count", offC));
         summary.put("off", Map.of("duration", formatDuration(offD), "seconds", offD, "count", offC));
         summary.put("red", Map.of("duration", formatDuration(redD), "seconds", redD, "count", redC));
         summary.put("red", Map.of("duration", formatDuration(redD), "seconds", redD, "count", redC));
@@ -452,16 +485,12 @@ public class DeviceSearchService {
         return summary;
         return summary;
     }
     }
 
 
-    /**
-     * 根据查询类型构建日期列表
-     */
     private List<String> buildDateRange(String type, String startDate, String endDate) {
     private List<String> buildDateRange(String type, String startDate, String endDate) {
         List<String> result = new ArrayList<>();
         List<String> result = new ArrayList<>();
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
 
 
         switch (type) {
         switch (type) {
             case "day": {
             case "day": {
-                // 指定日期范围
                 if (StringUtils.hasText(startDate) && StringUtils.hasText(endDate)) {
                 if (StringUtils.hasText(startDate) && StringUtils.hasText(endDate)) {
                     try {
                     try {
                         Date start = sdf.parse(startDate);
                         Date start = sdf.parse(startDate);
@@ -479,19 +508,14 @@ public class DeviceSearchService {
                 break;
                 break;
             }
             }
             case "week": {
             case "week": {
-                // 今年1月1日 ~ 今天所在周的周日（自然周，不跨年）
                 Calendar now = Calendar.getInstance();
                 Calendar now = Calendar.getInstance();
                 int currentYear = now.get(Calendar.YEAR);
                 int currentYear = now.get(Calendar.YEAR);
-
                 Calendar startCal = Calendar.getInstance();
                 Calendar startCal = Calendar.getInstance();
                 startCal.set(currentYear, Calendar.JANUARY, 1);
                 startCal.set(currentYear, Calendar.JANUARY, 1);
-
-                // 本周结束（周日）
                 Calendar endCal = (Calendar) now.clone();
                 Calendar endCal = (Calendar) now.clone();
                 int todayDow = endCal.get(Calendar.DAY_OF_WEEK);
                 int todayDow = endCal.get(Calendar.DAY_OF_WEEK);
                 int toSunday = todayDow == Calendar.SUNDAY ? 0 : (7 - todayDow);
                 int toSunday = todayDow == Calendar.SUNDAY ? 0 : (7 - todayDow);
                 endCal.add(Calendar.DATE, toSunday);
                 endCal.add(Calendar.DATE, toSunday);
-
                 Calendar cur = Calendar.getInstance();
                 Calendar cur = Calendar.getInstance();
                 cur.setTime(startCal.getTime());
                 cur.setTime(startCal.getTime());
                 while (!cur.after(endCal)) {
                 while (!cur.after(endCal)) {
@@ -501,11 +525,9 @@ public class DeviceSearchService {
                 break;
                 break;
             }
             }
             case "month": {
             case "month": {
-                // 今年1月 ~ 本月最后一天
                 Calendar now = Calendar.getInstance();
                 Calendar now = Calendar.getInstance();
                 int year = now.get(Calendar.YEAR);
                 int year = now.get(Calendar.YEAR);
-                int thisMonth = now.get(Calendar.MONTH); // 0-indexed
-
+                int thisMonth = now.get(Calendar.MONTH);
                 for (int m = 0; m <= thisMonth; m++) {
                 for (int m = 0; m <= thisMonth; m++) {
                     Calendar cal = Calendar.getInstance();
                     Calendar cal = Calendar.getInstance();
                     cal.set(year, m, 1);
                     cal.set(year, m, 1);
@@ -521,16 +543,16 @@ public class DeviceSearchService {
         return result;
         return result;
     }
     }
 
 
-    /**
-     * 从 oee 表查询指定日期范围的数据
-     */
-    private List<Map<String, Object>> queryOeeFromDb(String dtuSn, List<String> dates, String excludeToday) {
+    private List<Map<String, Object>> queryOeeFromDb(String corpCode, String dtuSn, List<String> dates, String excludeToday) {
         if (dates.isEmpty()) return Collections.emptyList();
         if (dates.isEmpty()) return Collections.emptyList();
 
 
+        String oeeTableName = corpConfigService.getOeeTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
+
         StringBuilder sql = new StringBuilder(
         StringBuilder sql = new StringBuilder(
                 "SELECT oee_date, triColorLamp1, triColorLamp2 FROM " + oeeTableName + " WHERE corp_code = ?");
                 "SELECT oee_date, triColorLamp1, triColorLamp2 FROM " + oeeTableName + " WHERE corp_code = ?");
         List<Object> params = new ArrayList<>();
         List<Object> params = new ArrayList<>();
-        params.add(deviceCorpCode);
+        params.add(corpCode);
 
 
         if (StringUtils.hasText(dtuSn)) {
         if (StringUtils.hasText(dtuSn)) {
             sql.append(" AND dtuSn = ?");
             sql.append(" AND dtuSn = ?");
@@ -540,35 +562,24 @@ public class DeviceSearchService {
         sql.append(" AND oee_date IN (");
         sql.append(" AND oee_date IN (");
         List<Object> dateParams = new ArrayList<>();
         List<Object> dateParams = new ArrayList<>();
         for (String d : dates) {
         for (String d : dates) {
-            if (d.equals(excludeToday)) continue; // 排除今天，今天走接口
+            if (d.equals(excludeToday)) continue;
             sql.append("?,");
             sql.append("?,");
             dateParams.add(d);
             dateParams.add(d);
         }
         }
-        if (dateParams.isEmpty()) {
-            return Collections.emptyList(); // 所有日期都是今天
-        }
+        if (dateParams.isEmpty()) return Collections.emptyList();
         sql.deleteCharAt(sql.length() - 1).append(")");
         sql.deleteCharAt(sql.length() - 1).append(")");
         params.addAll(dateParams);
         params.addAll(dateParams);
         sql.append(" ORDER BY oee_date ASC");
         sql.append(" ORDER BY oee_date ASC");
 
 
-        return jdbcTemplate.queryForList(sql.toString(), params.toArray());
+        return jt.queryForList(sql.toString(), params.toArray());
     }
     }
 
 
     // ==================== OEE 时序图分页查询（含稼动率计算） ====================
     // ==================== OEE 时序图分页查询（含稼动率计算） ====================
 
 
-    /**
-     * 按设备分页查询所有设备的OEE时序数据，并计算稼动率
-     *
-     * @param startDate 开始日期 yyyy-MM-dd
-     * @param endDate   结束日期 yyyy-MM-dd
-     * @param pageNo    页码，从1开始
-     * @param pageSize  每页设备数，最大20
-     */
-    public Map<String, Object> queryOeeTimeline(String startDate, String endDate, Integer pageNo, Integer pageSize) {
-        log.info("========== [OEE时序图查询-按设备分页] startDate={}, endDate={}, pageNo={}, pageSize={} ==========",
-                startDate, endDate, pageNo, pageSize);
+    public Map<String, Object> queryOeeTimeline(String corpCode, String startDate, String endDate, Integer pageNo, Integer pageSize) {
+        log.info("========== [OEE时序图查询-按设备分页] corpCode={}, startDate={}, endDate={}, pageNo={}, pageSize={} ==========",
+                corpCode, startDate, endDate, pageNo, pageSize);
 
 
-        // 参数校验与默认值
         if (!StringUtils.hasText(startDate) || !StringUtils.hasText(endDate)) {
         if (!StringUtils.hasText(startDate) || !StringUtils.hasText(endDate)) {
             return Map.of("total", 0, "pageNo", pageNo, "pageSize", pageSize, "list", List.of());
             return Map.of("total", 0, "pageNo", pageNo, "pageSize", pageSize, "list", List.of());
         }
         }
@@ -581,7 +592,7 @@ public class DeviceSearchService {
         log.info("包含今日({}): {}", todayStr, includeToday);
         log.info("包含今日({}): {}", todayStr, includeToday);
 
 
         // 1. 从设备表查询所有 dtuSn 及设备名称
         // 1. 从设备表查询所有 dtuSn 及设备名称
-        Map<String, String> deviceNameMap = queryAllDtuSnWithName();
+        Map<String, String> deviceNameMap = queryAllDtuSnWithName(corpCode);
         List<String> allDtuSns = new ArrayList<>(deviceNameMap.keySet());
         List<String> allDtuSns = new ArrayList<>(deviceNameMap.keySet());
         int deviceTotal = allDtuSns.size();
         int deviceTotal = allDtuSns.size();
         log.info("设备总数: {}", deviceTotal);
         log.info("设备总数: {}", deviceTotal);
@@ -590,31 +601,25 @@ public class DeviceSearchService {
             return buildPageResult(0, pn, ps, List.of());
             return buildPageResult(0, pn, ps, List.of());
         }
         }
 
 
-        // 2. 构建日期范围列表
         List<String> dateList = buildDayList(startDate, endDate);
         List<String> dateList = buildDayList(startDate, endDate);
         log.info("日期范围共 {} 天: {} ~ {}", dateList.size(), dateList.get(0), dateList.get(dateList.size() - 1));
         log.info("日期范围共 {} 天: {} ~ {}", dateList.size(), dateList.get(0), dateList.get(dateList.size() - 1));
 
 
-        // 3. 批量从数据库查询全部设备的 OEE 数据
-        List<OeeRecord> allRecords = queryOeeBatch(allDtuSns, dateList, includeToday ? todayStr : null);
+        List<OeeRecord> allRecords = queryOeeBatch(corpCode, allDtuSns, dateList, includeToday ? todayStr : null);
 
 
-        // 4. 如果包含今天，补充调用接口获取今天的实时数据
         if (includeToday) {
         if (includeToday) {
-            supplementTodayData(allDtuSns, todayStr, allRecords);
+            supplementTodayData(corpCode, allDtuSns, todayStr, allRecords);
         }
         }
 
 
-        // 5. 按 dtuSn 分组，每个设备包含该日期范围内所有天的数据
         Map<String, List<OeeRecord>> deviceMap = new LinkedHashMap<>();
         Map<String, List<OeeRecord>> deviceMap = new LinkedHashMap<>();
         for (OeeRecord r : allRecords) {
         for (OeeRecord r : allRecords) {
             deviceMap.computeIfAbsent(r.dtuSn, k -> new ArrayList<>()).add(r);
             deviceMap.computeIfAbsent(r.dtuSn, k -> new ArrayList<>()).add(r);
         }
         }
-        // 确保没有数据的设备也有空列表（保持顺序一致）
         for (String sn : allDtuSns) {
         for (String sn : allDtuSns) {
             if (!deviceMap.containsKey(sn)) {
             if (!deviceMap.containsKey(sn)) {
                 deviceMap.put(sn, new ArrayList<>());
                 deviceMap.put(sn, new ArrayList<>());
             }
             }
         }
         }
 
 
-        // 6. 设备维度分页
         List<Map<String, Object>> pageList;
         List<Map<String, Object>> pageList;
         int offset = (pn - 1) * ps;
         int offset = (pn - 1) * ps;
         List<String> pagedDevices = new ArrayList<>(deviceMap.keySet()).subList(
         List<String> pagedDevices = new ArrayList<>(deviceMap.keySet()).subList(
@@ -624,10 +629,11 @@ public class DeviceSearchService {
         return buildPageResult(deviceTotal, pn, ps, pageList);
         return buildPageResult(deviceTotal, pn, ps, pageList);
     }
     }
 
 
-    /** 查询设备表所有dtuSn及对应设备名称 */
-    private Map<String, String> queryAllDtuSnWithName() {
-        String sql = "SELECT dtuSn, deviceName FROM " + deviceTableName + " WHERE corp_code = ? ORDER BY dtuSn";
-        List<Map<String, Object>> rows = jdbcTemplate.queryForList(sql, deviceCorpCode);
+    private Map<String, String> queryAllDtuSnWithName(String corpCode) {
+        String tableName = corpConfigService.getDeviceTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
+        String sql = "SELECT dtuSn, deviceName FROM " + tableName + " WHERE corp_code = ? ORDER BY dtuSn";
+        List<Map<String, Object>> rows = jt.queryForList(sql, corpCode);
         Map<String, String> result = new LinkedHashMap<>(rows.size());
         Map<String, String> result = new LinkedHashMap<>(rows.size());
         for (Map<String, Object> row : rows) {
         for (Map<String, Object> row : rows) {
             result.put((String) row.get("dtuSn"), (String) row.get("deviceName"));
             result.put((String) row.get("dtuSn"), (String) row.get("deviceName"));
@@ -635,7 +641,6 @@ public class DeviceSearchService {
         return result;
         return result;
     }
     }
 
 
-    /** 判断某日期是否在范围内 */
     private boolean isDateInRange(String dateStr, String start, String end) {
     private boolean isDateInRange(String dateStr, String start, String end) {
         try {
         try {
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
@@ -648,7 +653,6 @@ public class DeviceSearchService {
         }
         }
     }
     }
 
 
-    /** 构建连续日期列表 */
     private List<String> buildDayList(String startDate, String endDate) {
     private List<String> buildDayList(String startDate, String endDate) {
         List<String> result = new ArrayList<>();
         List<String> result = new ArrayList<>();
         try {
         try {
@@ -667,12 +671,11 @@ public class DeviceSearchService {
         return result;
         return result;
     }
     }
 
 
-    /** OEE内部记录结构 */
-    private static class OeeRecord {
+    static class OeeRecord {
         String dtuSn;
         String dtuSn;
         String oeeDate;
         String oeeDate;
-        JSONArray lampData;       // 该日lampData数组
-        double availabilityRate;  // 稼动率 (%)
+        JSONArray lampData;
+        double availabilityRate;
 
 
         OeeRecord(String dtuSn, String oeeDate) {
         OeeRecord(String dtuSn, String oeeDate) {
             this.dtuSn = dtuSn;
             this.dtuSn = dtuSn;
@@ -681,34 +684,37 @@ public class DeviceSearchService {
         }
         }
     }
     }
 
 
-    /** 批量从数据库查询OEE数据 */
-    private List<OeeRecord> queryOeeBatch(List<String> dtuSns, List<String> dateList, String excludeToday) {
+    private List<OeeRecord> queryOeeBatch(String corpCode, List<String> dtuSns, List<String> dateList, String excludeToday) {
         List<OeeRecord> records = new ArrayList<>();
         List<OeeRecord> records = new ArrayList<>();
-
         if (dateList.isEmpty()) return records;
         if (dateList.isEmpty()) return records;
 
 
+        String oeeTableName = corpConfigService.getOeeTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
+
         StringBuilder sql = new StringBuilder(
         StringBuilder sql = new StringBuilder(
                 "SELECT dtuSn, oee_date, triColorLamp1, triColorLamp2 FROM " + oeeTableName +
                 "SELECT dtuSn, oee_date, triColorLamp1, triColorLamp2 FROM " + oeeTableName +
                         " WHERE corp_code = ? AND dtuSn IN (");
                         " WHERE corp_code = ? AND dtuSn IN (");
         List<Object> params = new ArrayList<>();
         List<Object> params = new ArrayList<>();
-        params.add(deviceCorpCode);
+        params.add(corpCode);
 
 
-        // dtuSn IN 条件
-        for (String sn : dtuSns) { sql.append("?,"); params.add(sn); }
+        for (String sn : dtuSns) {
+            sql.append("?,");
+            params.add(sn);
+        }
         sql.deleteCharAt(sql.length() - 1).append(")");
         sql.deleteCharAt(sql.length() - 1).append(")");
 
 
-        // 日期条件（排除今天）
         sql.append(" AND oee_date IN (");
         sql.append(" AND oee_date IN (");
         List<Object> dateParams = new ArrayList<>();
         List<Object> dateParams = new ArrayList<>();
         for (String d : dateList) {
         for (String d : dateList) {
             if (d.equals(excludeToday)) continue;
             if (d.equals(excludeToday)) continue;
-            sql.append("?,"); dateParams.add(d);
+            sql.append("?,");
+            dateParams.add(d);
         }
         }
-        if (dateParams.isEmpty()) return records; // 全是今天
+        if (dateParams.isEmpty()) return records;
         sql.deleteCharAt(sql.length() - 1).append(")");
         sql.deleteCharAt(sql.length() - 1).append(")");
         params.addAll(dateParams);
         params.addAll(dateParams);
 
 
-        List<Map<String, Object>> rows = jdbcTemplate.queryForList(sql.toString(), params.toArray());
+        List<Map<String, Object>> rows = jt.queryForList(sql.toString(), params.toArray());
         log.info("DB批量查询返回 {} 行OEE数据", rows.size());
         log.info("DB批量查询返回 {} 行OEE数据", rows.size());
 
 
         for (Map<String, Object> row : rows) {
         for (Map<String, Object> row : rows) {
@@ -734,59 +740,45 @@ public class DeviceSearchService {
             record.availabilityRate = calcAvailabilityRate(record.lampData);
             record.availabilityRate = calcAvailabilityRate(record.lampData);
             records.add(record);
             records.add(record);
         }
         }
-
         return records;
         return records;
     }
     }
 
 
-    /** 补充今天的实时接口数据 */
-    private void supplementTodayData(List<String> dtuSns, String todayStr, List<OeeRecord> records) {
+    private void supplementTodayData(String corpCode, List<String> dtuSns, String todayStr, List<OeeRecord> records) {
         log.info("开始补充今日({})实时OEE数据...", todayStr);
         log.info("开始补充今日({})实时OEE数据...", todayStr);
-        int apiCount = 0;
         for (String dtuSn : dtuSns) {
         for (String dtuSn : dtuSns) {
-            // 先检查是否已有该设备今天的数据
             boolean exists = false;
             boolean exists = false;
             for (OeeRecord r : records) {
             for (OeeRecord r : records) {
                 if (r.dtuSn.equals(dtuSn) && r.oeeDate.equals(todayStr)) {
                 if (r.dtuSn.equals(dtuSn) && r.oeeDate.equals(todayStr)) {
-                    exists = true; break;
+                    exists = true;
+                    break;
                 }
                 }
             }
             }
             if (exists) continue;
             if (exists) continue;
-
             try {
             try {
-                String apiResult = devicePullService.getLampData(dtuSn, todayStr);
+                String apiResult = devicePullService.getLampData(corpCode, dtuSn, todayStr);
                 if (!StringUtils.hasText(apiResult)) continue;
                 if (!StringUtils.hasText(apiResult)) continue;
-
-                Map<String, Object> res = JSON.parseObject(apiResult, new com.alibaba.fastjson.TypeReference<>() {});
+                Map<String, Object> res = JSON.parseObject(apiResult, new com.alibaba.fastjson.TypeReference<>() {
+                });
                 Integer code = (Integer) res.get("code");
                 Integer code = (Integer) res.get("code");
                 if (code == null || code != 200) continue;
                 if (code == null || code != 200) continue;
-
                 JSONArray dataList = (JSONArray) res.get("data");
                 JSONArray dataList = (JSONArray) res.get("data");
                 if (dataList == null || dataList.isEmpty()) continue;
                 if (dataList == null || dataList.isEmpty()) continue;
-
                 JSONObject dataObj = (JSONObject) dataList.get(0);
                 JSONObject dataObj = (JSONObject) dataList.get(0);
                 OeeRecord record = new OeeRecord(dtuSn, todayStr);
                 OeeRecord record = new OeeRecord(dtuSn, todayStr);
                 record.lampData = dataObj.getJSONArray("lampData");
                 record.lampData = dataObj.getJSONArray("lampData");
                 if (record.lampData == null) record.lampData = new JSONArray();
                 if (record.lampData == null) record.lampData = new JSONArray();
                 record.availabilityRate = calcAvailabilityRate(record.lampData);
                 record.availabilityRate = calcAvailabilityRate(record.lampData);
                 records.add(record);
                 records.add(record);
-                apiCount++;
             } catch (Exception e) {
             } catch (Exception e) {
                 log.error("获取今日OEE数据异常 - dtuSn:{}", dtuSn, e);
                 log.error("获取今日OEE数据异常 - dtuSn:{}", dtuSn, e);
             }
             }
         }
         }
-        log.info("今日实时数据补充完成, 新增 {} 条", apiCount);
     }
     }
 
 
-    /**
-     * 计算稼动率
-     * 稼动率 = 绿灯(state=3)时长 / 总时长 * 100%
-     */
     private double calcAvailabilityRate(JSONArray lampData) {
     private double calcAvailabilityRate(JSONArray lampData) {
         if (lampData == null || lampData.isEmpty()) return 0.0;
         if (lampData == null || lampData.isEmpty()) return 0.0;
-
         long totalDuration = 0;
         long totalDuration = 0;
         long greenDuration = 0;
         long greenDuration = 0;
-
         for (int i = 0; i < lampData.size(); i++) {
         for (int i = 0; i < lampData.size(); i++) {
             JSONObject item = lampData.getJSONObject(i);
             JSONObject item = lampData.getJSONObject(i);
             if (item == null) continue;
             if (item == null) continue;
@@ -795,36 +787,30 @@ public class DeviceSearchService {
             totalDuration += dur;
             totalDuration += dur;
             if (state == 3) greenDuration += dur;
             if (state == 3) greenDuration += dur;
         }
         }
-
         if (totalDuration == 0) return 0.0;
         if (totalDuration == 0) return 0.0;
-        return Math.round(greenDuration * 10000.0 / totalDuration) / 100.0; // 保留2位小数
+        return Math.round(greenDuration * 10000.0 / totalDuration) / 100.0;
     }
     }
 
 
-    /** 按设备分组转换为响应格式：每个设备一条记录，包含lampData和设备名称 */
     private List<Map<String, Object>> convertDeviceGroupToResponse(List<String> pagedDevices,
     private List<Map<String, Object>> convertDeviceGroupToResponse(List<String> pagedDevices,
-                                                                     Map<String, List<OeeRecord>> deviceMap,
-                                                                     List<String> dateList,
-                                                                     Map<String, String> deviceNameMap) {
+                                                                   Map<String, List<OeeRecord>> deviceMap,
+                                                                   List<String> dateList,
+                                                                   Map<String, String> deviceNameMap) {
         List<Map<String, Object>> list = new ArrayList<>(pagedDevices.size());
         List<Map<String, Object>> list = new ArrayList<>(pagedDevices.size());
-
         for (String dtuSn : pagedDevices) {
         for (String dtuSn : pagedDevices) {
             Map<String, Object> item = new LinkedHashMap<>();
             Map<String, Object> item = new LinkedHashMap<>();
             item.put("dtuSn", dtuSn);
             item.put("dtuSn", dtuSn);
             item.put("deviceName", deviceNameMap.getOrDefault(dtuSn, ""));
             item.put("deviceName", deviceNameMap.getOrDefault(dtuSn, ""));
 
 
             List<OeeRecord> dayRecords = deviceMap.getOrDefault(dtuSn, Collections.emptyList());
             List<OeeRecord> dayRecords = deviceMap.getOrDefault(dtuSn, Collections.emptyList());
-            // 构建日期→record的快速查找map
             Map<String, OeeRecord> recordByDate = new LinkedHashMap<>();
             Map<String, OeeRecord> recordByDate = new LinkedHashMap<>();
             for (OeeRecord r : dayRecords) {
             for (OeeRecord r : dayRecords) {
                 recordByDate.put(r.oeeDate, r);
                 recordByDate.put(r.oeeDate, r);
             }
             }
 
 
-            // 汇总计算综合稼动率
             long totalDur = 0, greenDur = 0;
             long totalDur = 0, greenDur = 0;
             long offD = 0, redD = 0, yellowD = 0, greenD = 0, blueD = 0;
             long offD = 0, redD = 0, yellowD = 0, greenD = 0, blueD = 0;
             int offC = 0, redC = 0, yellowC = 0, greenC = 0, blueC = 0;
             int offC = 0, redC = 0, yellowC = 0, greenC = 0, blueC = 0;
 
 
-            // 拼接所有天的 lampData 为一个数组（按日期排序）
             JSONArray allLampData = new JSONArray();
             JSONArray allLampData = new JSONArray();
             List<Map<String, Object>> dailyDetails = new ArrayList<>();
             List<Map<String, Object>> dailyDetails = new ArrayList<>();
 
 
@@ -837,11 +823,26 @@ public class DeviceSearchService {
                         int state = lamp.getIntValue("lampState");
                         int state = lamp.getIntValue("lampState");
                         long dur = lamp.getLongValue("duration");
                         long dur = lamp.getLongValue("duration");
                         switch (state) {
                         switch (state) {
-                            case 0 -> { offD += dur; offC++; }
-                            case 1 -> { redD += dur; redC++; }
-                            case 2 -> { yellowD += dur; yellowC++; }
-                            case 3 -> { greenD += dur; greenC++; }
-                            case 4 -> { blueD += dur; blueC++; }
+                            case 0 -> {
+                                offD += dur;
+                                offC++;
+                            }
+                            case 1 -> {
+                                redD += dur;
+                                redC++;
+                            }
+                            case 2 -> {
+                                yellowD += dur;
+                                yellowC++;
+                            }
+                            case 3 -> {
+                                greenD += dur;
+                                greenC++;
+                            }
+                            case 4 -> {
+                                blueD += dur;
+                                blueC++;
+                            }
                         }
                         }
                         totalDur += dur;
                         totalDur += dur;
                         if (state == 3) greenDur += dur;
                         if (state == 3) greenDur += dur;
@@ -849,16 +850,11 @@ public class DeviceSearchService {
                     allLampData.addAll(rec.lampData);
                     allLampData.addAll(rec.lampData);
                 }
                 }
                 double dayRate = (rec != null) ? rec.availabilityRate : 0.0;
                 double dayRate = (rec != null) ? rec.availabilityRate : 0.0;
-                dailyDetails.add(Map.of(
-                        "oeeDate", d,
-                        "availabilityRate", dayRate,
-                        "hasData", rec != null
-                ));
+                dailyDetails.add(Map.of("oeeDate", d, "availabilityRate", dayRate, "hasData", rec != null));
             }
             }
 
 
             double overallRate = (totalDur > 0) ? Math.round(greenDur * 10000.0 / totalDur) / 100.0 : 0.0;
             double overallRate = (totalDur > 0) ? Math.round(greenDur * 10000.0 / totalDur) / 100.0 : 0.0;
 
 
-            // 扁平化字段，对齐截图格式
             item.put("availabilityRatio", String.format("%.2f%%", overallRate));
             item.put("availabilityRatio", String.format("%.2f%%", overallRate));
             item.put("offDuration", formatDuration(offD));
             item.put("offDuration", formatDuration(offD));
             item.put("redDuration", formatDuration(redD));
             item.put("redDuration", formatDuration(redD));
@@ -869,28 +865,21 @@ public class DeviceSearchService {
             item.put("totalDays", dateList.size());
             item.put("totalDays", dateList.size());
             item.put("lampData", allLampData);
             item.put("lampData", allLampData);
             item.put("dailyDetails", dailyDetails);
             item.put("dailyDetails", dailyDetails);
-
             list.add(item);
             list.add(item);
         }
         }
-
         return list;
         return list;
     }
     }
 
 
-    /** 转换为响应格式 */
     private List<Map<String, Object>> convertToResponse(List<OeeRecord> records) {
     private List<Map<String, Object>> convertToResponse(List<OeeRecord> records) {
         List<Map<String, Object>> list = new ArrayList<>(records.size());
         List<Map<String, Object>> list = new ArrayList<>(records.size());
-
         for (OeeRecord r : records) {
         for (OeeRecord r : records) {
             Map<String, Object> item = new LinkedHashMap<>();
             Map<String, Object> item = new LinkedHashMap<>();
             item.put("dtuSn", r.dtuSn);
             item.put("dtuSn", r.dtuSn);
             item.put("oeeDate", r.oeeDate);
             item.put("oeeDate", r.oeeDate);
-            item.put("availabilityRate", r.availabilityRate); // 稼动率
+            item.put("availabilityRate", r.availabilityRate);
             item.put("availabilityRateStr", r.availabilityRate + "%");
             item.put("availabilityRateStr", r.availabilityRate + "%");
-
-            // 各状态时长统计
             long offDur = 0, redDur = 0, yellowDur = 0, greenDur = 0, blueDur = 0;
             long offDur = 0, redDur = 0, yellowDur = 0, greenDur = 0, blueDur = 0;
             int offCnt = 0, redCnt = 0, yellowCnt = 0, greenCnt = 0, blueCnt = 0;
             int offCnt = 0, redCnt = 0, yellowCnt = 0, greenCnt = 0, blueCnt = 0;
-
             if (r.lampData != null) {
             if (r.lampData != null) {
                 for (int i = 0; i < r.lampData.size(); i++) {
                 for (int i = 0; i < r.lampData.size(); i++) {
                     JSONObject lamp = r.lampData.getJSONObject(i);
                     JSONObject lamp = r.lampData.getJSONObject(i);
@@ -898,52 +887,49 @@ public class DeviceSearchService {
                     int state = lamp.getIntValue("lampState");
                     int state = lamp.getIntValue("lampState");
                     long dur = lamp.getLongValue("duration");
                     long dur = lamp.getLongValue("duration");
                     switch (state) {
                     switch (state) {
-                        case 0 -> { offDur += dur; offCnt++; }
-                        case 1 -> { redDur += dur; redCnt++; }
-                        case 2 -> { yellowDur += dur; yellowCnt++; }
-                        case 3 -> { greenDur += dur; greenCnt++; }
-                        case 4 -> { blueDur += dur; blueCnt++; }
+                        case 0 -> {
+                            offDur += dur;
+                            offCnt++;
+                        }
+                        case 1 -> {
+                            redDur += dur;
+                            redCnt++;
+                        }
+                        case 2 -> {
+                            yellowDur += dur;
+                            yellowCnt++;
+                        }
+                        case 3 -> {
+                            greenDur += dur;
+                            greenCnt++;
+                        }
+                        case 4 -> {
+                            blueDur += dur;
+                            blueCnt++;
+                        }
                     }
                     }
                 }
                 }
             }
             }
-
             item.put("off", Map.of("duration", formatDuration(offDur), "seconds", offDur, "count", offCnt));
             item.put("off", Map.of("duration", formatDuration(offDur), "seconds", offDur, "count", offCnt));
             item.put("red", Map.of("duration", formatDuration(redDur), "seconds", redDur, "count", redCnt));
             item.put("red", Map.of("duration", formatDuration(redDur), "seconds", redDur, "count", redCnt));
             item.put("yellow", Map.of("duration", formatDuration(yellowDur), "seconds", yellowDur, "count", yellowCnt));
             item.put("yellow", Map.of("duration", formatDuration(yellowDur), "seconds", yellowDur, "count", yellowCnt));
             item.put("green", Map.of("duration", formatDuration(greenDur), "seconds", greenDur, "count", greenCnt));
             item.put("green", Map.of("duration", formatDuration(greenDur), "seconds", greenDur, "count", greenCnt));
             item.put("blue", Map.of("duration", formatDuration(blueDur), "seconds", blueDur, "count", blueCnt));
             item.put("blue", Map.of("duration", formatDuration(blueDur), "seconds", blueDur, "count", blueCnt));
             item.put("lampData", r.lampData != null ? r.lampData : new JSONArray());
             item.put("lampData", r.lampData != null ? r.lampData : new JSONArray());
-
             list.add(item);
             list.add(item);
         }
         }
         return list;
         return list;
     }
     }
 
 
-    /** 构建分页结果（标准分页格式） */
     private Map<String, Object> buildPageResult(long total, int pageNo, int pageSize, List<Map<String, Object>> list) {
     private Map<String, Object> buildPageResult(long total, int pageNo, int pageSize, List<Map<String, Object>> list) {
-        return Map.of(
-                "data", Map.of(
-                        "total", total,
-                        "size", pageSize,
-                        "current", pageNo,
-                        "records", list
-                )
-        );
+        return Map.of("data", Map.of("total", total, "size", pageSize, "current", pageNo, "records", list));
     }
     }
 
 
     // ==================== 智能灯统计稼动率查询（仪表盘） ====================
     // ==================== 智能灯统计稼动率查询（仪表盘） ====================
 
 
-    /**
-     * 智能灯统计稼动率综合查询（仪表盘数据）
-     * 返回：总时长、稼动率、当前机台运行状态、异常排行榜、每设备状态时长
-     *
-     * @param startDate 开始日期 yyyy-MM-dd
-     * @param endDate   结束日期 yyyy-MM-dd
-     */
-    public Map<String, Object> queryLampStatistics(String startDate, String endDate) {
-        log.info("========== [智能灯统计查询] startDate={}, endDate={} ==========", startDate, endDate);
+    public Map<String, Object> queryLampStatistics(String corpCode, String startDate, String endDate) {
+        log.info("========== [智能灯统计查询] corpCode={}, startDate={}, endDate={} ==========", corpCode, startDate, endDate);
 
 
-        // 1. 根据前端传入的起止日期构建日期范围
         List<String> dateList = buildDayList(startDate, endDate);
         List<String> dateList = buildDayList(startDate, endDate);
         if (dateList.isEmpty()) {
         if (dateList.isEmpty()) {
             return buildEmptyLampStats();
             return buildEmptyLampStats();
@@ -953,22 +939,17 @@ public class DeviceSearchService {
         boolean includeToday = dateList.contains(todayStr);
         boolean includeToday = dateList.contains(todayStr);
         log.info("日期范围共 {} 天, 包含今日({}): {}", dateList.size(), todayStr, includeToday);
         log.info("日期范围共 {} 天, 包含今日({}): {}", dateList.size(), todayStr, includeToday);
 
 
-        // 2. 获取所有设备及名称
-        Map<String, String> deviceNameMap = queryAllDtuSnWithName();
+        Map<String, String> deviceNameMap = queryAllDtuSnWithName(corpCode);
         List<String> allDtuSns = new ArrayList<>(deviceNameMap.keySet());
         List<String> allDtuSns = new ArrayList<>(deviceNameMap.keySet());
         if (allDtuSns.isEmpty()) {
         if (allDtuSns.isEmpty()) {
             return buildEmptyLampStats();
             return buildEmptyLampStats();
         }
         }
 
 
-        // 3. 批量从OEE表查询数据
-        List<OeeRecord> allRecords = queryOeeBatch(allDtuSns, dateList, includeToday ? todayStr : null);
-
-        // 4. 补充今天的实时数据
+        List<OeeRecord> allRecords = queryOeeBatch(corpCode, allDtuSns, dateList, includeToday ? todayStr : null);
         if (includeToday) {
         if (includeToday) {
-            supplementTodayData(allDtuSns, todayStr, allRecords);
+            supplementTodayData(corpCode, allDtuSns, todayStr, allRecords);
         }
         }
 
 
-        // 5. 按 dtuSn 分组
         Map<String, List<OeeRecord>> deviceMap = new LinkedHashMap<>();
         Map<String, List<OeeRecord>> deviceMap = new LinkedHashMap<>();
         for (OeeRecord r : allRecords) {
         for (OeeRecord r : allRecords) {
             deviceMap.computeIfAbsent(r.dtuSn, k -> new ArrayList<>()).add(r);
             deviceMap.computeIfAbsent(r.dtuSn, k -> new ArrayList<>()).add(r);
@@ -979,43 +960,27 @@ public class DeviceSearchService {
             }
             }
         }
         }
 
 
-        // 6. 计算各项统计数据
-        return buildLampStatisticsResult(allDtuSns, deviceMap, deviceNameMap, dateList);
+        return buildLampStatisticsResult(allDtuSns, deviceMap, deviceNameMap, dateList, corpCode);
     }
     }
 
 
-    /** 构建空结果 */
     private Map<String, Object> buildEmptyLampStats() {
     private Map<String, Object> buildEmptyLampStats() {
-        return Map.of(
-                "totalDuration", Map.of(
-                        "off", Map.of("duration", "0时0分0秒", "seconds", 0),
-                        "red", Map.of("duration", "0时0分0秒", "seconds", 0),
-                        "yellow", Map.of("duration", "0时0分0秒", "seconds", 0),
-                        "green", Map.of("duration", "0时0分0秒", "seconds", 0),
-                        "blue", Map.of("duration", "0时0分0秒", "seconds", 0)
-                ),
-                "availabilityRate", "0.00%",
-                "currentStatus", Map.of(
-                        "off", 0, "red", 0, "yellow", 0, "green", 0, "blue", 0
-                ),
-                "abnormalRanking", List.of(),
-                "deviceList", List.of()
-        );
+        return Map.of("totalDuration", Map.of("off", Map.of("duration", "0时0分0秒", "seconds", 0),
+                        "red", Map.of("duration", "0时0分0秒", "seconds", 0), "yellow", Map.of("duration", "0时0分0秒", "seconds", 0),
+                        "green", Map.of("duration", "0时0分0秒", "seconds", 0), "blue", Map.of("duration", "0时0分0秒", "seconds", 0)),
+                "availabilityRate", "0.00%", "currentStatus", Map.of("off", 0, "red", 0, "yellow", 0, "green", 0, "blue", 0),
+                "abnormalRanking", List.of(), "deviceList", List.of());
     }
     }
 
 
-    /** 构建智能灯统计结果 */
     private Map<String, Object> buildLampStatisticsResult(List<String> allDtuSns,
     private Map<String, Object> buildLampStatisticsResult(List<String> allDtuSns,
-                                                           Map<String, List<OeeRecord>> deviceMap,
-                                                           Map<String, String> deviceNameMap,
-                                                           List<String> dateList) {
-        // ---- ① 总时长：汇总所有设备各状态时长 ----
+                                                          Map<String, List<OeeRecord>> deviceMap,
+                                                          Map<String, String> deviceNameMap,
+                                                          List<String> dateList,
+                                                          String corpCode) {
         long totalOff = 0, totalRed = 0, totalYellow = 0, totalGreen = 0, totalBlue = 0;
         long totalOff = 0, totalRed = 0, totalYellow = 0, totalGreen = 0, totalBlue = 0;
-
-        // ---- ② 设备维度统计：用于异常排名和每设备详情 ----
         List<Map<String, Object>> deviceStatList = new ArrayList<>();
         List<Map<String, Object>> deviceStatList = new ArrayList<>();
 
 
         for (String dtuSn : allDtuSns) {
         for (String dtuSn : allDtuSns) {
             List<OeeRecord> dayRecords = deviceMap.getOrDefault(dtuSn, Collections.emptyList());
             List<OeeRecord> dayRecords = deviceMap.getOrDefault(dtuSn, Collections.emptyList());
-
             long devOff = 0, devRed = 0, devYellow = 0, devGreen = 0, devBlue = 0;
             long devOff = 0, devRed = 0, devYellow = 0, devGreen = 0, devBlue = 0;
             long devTotalDur = 0, devGreenDur = 0;
             long devTotalDur = 0, devGreenDur = 0;
 
 
@@ -1030,18 +995,19 @@ public class DeviceSearchService {
                             case 0 -> devOff += dur;
                             case 0 -> devOff += dur;
                             case 1 -> devRed += dur;
                             case 1 -> devRed += dur;
                             case 2 -> devYellow += dur;
                             case 2 -> devYellow += dur;
-                            case 3 -> { devGreen += dur; devGreenDur += dur; }
+                            case 3 -> {
+                                devGreen += dur;
+                                devGreenDur += dur;
+                            }
                             case 4 -> devBlue += dur;
                             case 4 -> devBlue += dur;
                         }
                         }
                         devTotalDur += dur;
                         devTotalDur += dur;
                     }
                     }
                 }
                 }
             }
             }
-
-            // 稼动率 = 绿 / (红 + 黄 + 绿) * 100%
             long devRygDur = devRed + devYellow + devGreen;
             long devRygDur = devRed + devYellow + devGreen;
             double rate = (devRygDur > 0) ? Math.round(devGreenDur * 10000.0 / devRygDur) / 100.0 : 0.0;
             double rate = (devRygDur > 0) ? Math.round(devGreenDur * 10000.0 / devRygDur) / 100.0 : 0.0;
-            long abnormalDur = devRed + devYellow; // 异常时长 = 红+黄
+            long abnormalDur = devRed + devYellow;
 
 
             Map<String, Object> devStat = new LinkedHashMap<>();
             Map<String, Object> devStat = new LinkedHashMap<>();
             devStat.put("dtuSn", dtuSn);
             devStat.put("dtuSn", dtuSn);
@@ -1057,12 +1023,10 @@ public class DeviceSearchService {
             devStat.put("blueDuration", formatDuration(devBlue));
             devStat.put("blueDuration", formatDuration(devBlue));
             devStat.put("blueSeconds", devBlue);
             devStat.put("blueSeconds", devBlue);
             devStat.put("availabilityRatio", String.format("%.2f%%", rate));
             devStat.put("availabilityRatio", String.format("%.2f%%", rate));
-            devStat.put("rygTotalDuration", formatDuration(devRygDur)); // 红+黄+绿 总时长
-            devStat.put("abnormalDuration", abnormalDur); // 用于排序
-
+            devStat.put("rygTotalDuration", formatDuration(devRygDur));
+            devStat.put("abnormalDuration", abnormalDur);
             deviceStatList.add(devStat);
             deviceStatList.add(devStat);
 
 
-            // 累加到全局总计
             totalOff += devOff;
             totalOff += devOff;
             totalRed += devRed;
             totalRed += devRed;
             totalYellow += devYellow;
             totalYellow += devYellow;
@@ -1070,45 +1034,29 @@ public class DeviceSearchService {
             totalBlue += devBlue;
             totalBlue += devBlue;
         }
         }
 
 
-        // ---- ③ 稼动率 = 绿 / (红 + 黄 + 绿) ----
         long totalRygDur = totalRed + totalYellow + totalGreen;
         long totalRygDur = totalRed + totalYellow + totalGreen;
         double overallRate = (totalRygDur > 0) ? Math.round(totalGreen * 10000.0 / totalRygDur) / 100.0 : 0.0;
         double overallRate = (totalRygDur > 0) ? Math.round(totalGreen * 10000.0 / totalRygDur) / 100.0 : 0.0;
+        Map<String, Integer> currentStatus = queryCurrentDeviceStatus(corpCode);
 
 
-        // ---- ④ 当前机台运行状态（从设备表实时查） ----
-        Map<String, Integer> currentStatus = queryCurrentDeviceStatus();
-
-        // ---- ⑤ 异常排行榜（按红+黄时长降序） ----
-        deviceStatList.sort((a, b) -> Long.compare(
-                ((Number) b.get("abnormalDuration")).longValue(),
-                ((Number) a.get("abnormalDuration")).longValue()
-        ));
-        // 排序后移除辅助字段
+        deviceStatList.sort((a, b) -> Long.compare(((Number) b.get("abnormalDuration")).longValue(), ((Number) a.get("abnormalDuration")).longValue()));
         for (Map<String, Object> d : deviceStatList) {
         for (Map<String, Object> d : deviceStatList) {
             d.remove("abnormalDuration");
             d.remove("abnormalDuration");
         }
         }
 
 
-        return Map.of(
-                "totalDuration", Map.of(
-                        "off", Map.of("duration", formatDuration(totalOff), "seconds", totalOff),
+        return Map.of("totalDuration", Map.of("off", Map.of("duration", formatDuration(totalOff), "seconds", totalOff),
                         "red", Map.of("duration", formatDuration(totalRed), "seconds", totalRed),
                         "red", Map.of("duration", formatDuration(totalRed), "seconds", totalRed),
                         "yellow", Map.of("duration", formatDuration(totalYellow), "seconds", totalYellow),
                         "yellow", Map.of("duration", formatDuration(totalYellow), "seconds", totalYellow),
                         "green", Map.of("duration", formatDuration(totalGreen), "seconds", totalGreen),
                         "green", Map.of("duration", formatDuration(totalGreen), "seconds", totalGreen),
-                        "blue", Map.of("duration", formatDuration(totalBlue), "seconds", totalBlue)
-                ),
-                "availabilityRate", String.format("%.2f%%", overallRate),
-                "rygTotalDuration", formatDuration(totalRygDur), // 红黄绿总时长
-                "currentStatus", currentStatus,
-                "abnormalRanking", deviceStatList,
-                "deviceList", deviceStatList
-        );
+                        "blue", Map.of("duration", formatDuration(totalBlue), "seconds", totalBlue)),
+                "availabilityRate", String.format("%.2f%%", overallRate), "rygTotalDuration", formatDuration(totalRygDur),
+                "currentStatus", currentStatus, "abnormalRanking", deviceStatList, "deviceList", deviceStatList);
     }
     }
 
 
-    /** 查询当前设备的运行状态分布（从设备表） */
-    private Map<String, Integer> queryCurrentDeviceStatus() {
-        String sql = "SELECT lampState, COUNT(*) as cnt FROM " + deviceTableName +
-                " WHERE corp_code = ? GROUP BY lampState";
-        List<Map<String, Object>> rows = jdbcTemplate.queryForList(sql, deviceCorpCode);
-
+    private Map<String, Integer> queryCurrentDeviceStatus(String corpCode) {
+        String tableName = corpConfigService.getDeviceTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
+        String sql = "SELECT lampState, COUNT(*) as cnt FROM " + tableName + " WHERE corp_code = ? GROUP BY lampState";
+        List<Map<String, Object>> rows = jt.queryForList(sql, corpCode);
         int off = 0, red = 0, yellow = 0, green = 0, blue = 0;
         int off = 0, red = 0, yellow = 0, green = 0, blue = 0;
         for (Map<String, Object> row : rows) {
         for (Map<String, Object> row : rows) {
             String state = String.valueOf(row.get("lampState"));
             String state = String.valueOf(row.get("lampState"));
@@ -1126,50 +1074,36 @@ public class DeviceSearchService {
 
 
     // ==================== 开机率查询 ====================
     // ==================== 开机率查询 ====================
 
 
-    /**
-     * 查询每台设备的开机率（基于 dev_util 表）
-     * 规则：灭灯(state=0)=未开机，其他灯(state=1/2/3/4)=开机
-     * 开机率 = 非灭灯时长 / 总时长 * 100%
-     *
-     * @param startDate 开始日期 yyyy-MM-dd
-     * @param endDate   结束日期 yyyy-MM-dd
-     */
-    public Map<String, Object> queryBootRate(String startDate, String endDate) {
-        log.info("========== [开机率查询] startDate={}, endDate={} ==========", startDate, endDate);
-
+    public Map<String, Object> queryBootRate(String corpCode, String startDate, String endDate) {
+        log.info("========== [开机率查询] corpCode={}, startDate={}, endDate={} ==========", corpCode, startDate, endDate);
         if (!StringUtils.hasText(startDate) || !StringUtils.hasText(endDate)) {
         if (!StringUtils.hasText(startDate) || !StringUtils.hasText(endDate)) {
             return Map.of("list", List.of(), "startDate", startDate, "endDate", endDate);
             return Map.of("list", List.of(), "startDate", startDate, "endDate", endDate);
         }
         }
-
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         String todayStr = sdf.format(new Date());
         String todayStr = sdf.format(new Date());
         boolean includeToday = isDateInRange(todayStr, startDate, endDate);
         boolean includeToday = isDateInRange(todayStr, startDate, endDate);
-        log.info("设备总数: {}, 包含今日({}): {}", includeToday);
 
 
-        // 1. 获取所有设备列表
-        Map<String, String> deviceNameMap = queryAllDtuSnWithName();
+        Map<String, String> deviceNameMap = queryAllDtuSnWithName(corpCode);
         List<String> allDtuSns = new ArrayList<>(deviceNameMap.keySet());
         List<String> allDtuSns = new ArrayList<>(deviceNameMap.keySet());
         if (allDtuSns.isEmpty()) {
         if (allDtuSns.isEmpty()) {
             return Map.of("list", List.of(), "startDate", startDate, "endDate", endDate);
             return Map.of("list", List.of(), "startDate", startDate, "endDate", endDate);
         }
         }
         log.info("设备总数: {}", allDtuSns.size());
         log.info("设备总数: {}", allDtuSns.size());
 
 
-        // 2. 从 dev_util 表按 dtuSn 和日期范围汇总各状态时长（排除今天）
-        String dbStartDate = includeToday && startDate.equals(todayStr) ? getNextDay(todayStr) : startDate;
+        String devUtilTableName = corpConfigService.getDevUtilTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
+
         List<Map<String, Object>> rows;
         List<Map<String, Object>> rows;
         if (includeToday) {
         if (includeToday) {
-            // 排除今天，今天走接口
-            rows = queryDevUtilBatch(deviceCorpCode, allDtuSns, startDate, endDate, todayStr);
+            rows = queryDevUtilBatch(jt, devUtilTableName, corpCode, allDtuSns, startDate, endDate, todayStr);
         } else {
         } else {
             String sql = "SELECT dtuSn, SUM(`0`) as s0, SUM(`1`) as s1, SUM(`2`) as s2, SUM(`3`) as s3, SUM(`4`) as s4, COUNT(*) as days " +
             String sql = "SELECT dtuSn, SUM(`0`) as s0, SUM(`1`) as s1, SUM(`2`) as s2, SUM(`3`) as s3, SUM(`4`) as s4, COUNT(*) as days " +
-                    "FROM " + devUtilTableName +
-                    " WHERE corp_code = ? AND date_util BETWEEN ? AND ? GROUP BY dtuSn";
-            rows = jdbcTemplate.queryForList(sql, deviceCorpCode, startDate, endDate);
+                    "FROM " + devUtilTableName + " WHERE corp_code = ? AND date_util BETWEEN ? AND ? GROUP BY dtuSn";
+            rows = jt.queryForList(sql, corpCode, startDate, endDate);
         }
         }
         log.info("dev_util 查询返回 {} 条记录", rows.size());
         log.info("dev_util 查询返回 {} 条记录", rows.size());
 
 
-        // 3. 按 dtuSn 构建查询结果 map
-        Map<String, double[]> rawMap = new LinkedHashMap<>();  // [s0, s1, s2, s3, s4, dataDays]
+        Map<String, double[]> rawMap = new LinkedHashMap<>();
         for (Map<String, Object> row : rows) {
         for (Map<String, Object> row : rows) {
             String sn = (String) row.get("dtuSn");
             String sn = (String) row.get("dtuSn");
             double s0 = ((Number) row.get("s0")).doubleValue();
             double s0 = ((Number) row.get("s0")).doubleValue();
@@ -1181,20 +1115,17 @@ public class DeviceSearchService {
             rawMap.put(sn, new double[]{s0, s1, s2, s3, s4, dataDays});
             rawMap.put(sn, new double[]{s0, s1, s2, s3, s4, dataDays});
         }
         }
 
 
-        // 4. 如果包含今天，补充调用稼动率接口获取今天的实时数据
         if (includeToday) {
         if (includeToday) {
-            supplementTodayDevUtil(allDtuSns, todayStr, rawMap);
+            supplementTodayDevUtil(corpCode, allDtuSns, todayStr, rawMap);
         }
         }
 
 
-        // 5. 构建最终结果
         Map<String, Map<String, Object>> rateMap = new LinkedHashMap<>();
         Map<String, Map<String, Object>> rateMap = new LinkedHashMap<>();
         for (Map.Entry<String, double[]> entry : rawMap.entrySet()) {
         for (Map.Entry<String, double[]> entry : rawMap.entrySet()) {
             String sn = entry.getKey();
             String sn = entry.getKey();
             double[] vals = entry.getValue();
             double[] vals = entry.getValue();
             double totalDur = vals[0] + vals[1] + vals[2] + vals[3] + vals[4];
             double totalDur = vals[0] + vals[1] + vals[2] + vals[3] + vals[4];
-            double onDur = vals[1] + vals[2] + vals[3] + vals[4]; // 非灭灯时长 = 开机时长
+            double onDur = vals[1] + vals[2] + vals[3] + vals[4];
             double bootRate = totalDur > 0 ? Math.round(onDur * 10000.0 / totalDur) / 100.0 : 0.0;
             double bootRate = totalDur > 0 ? Math.round(onDur * 10000.0 / totalDur) / 100.0 : 0.0;
-
             Map<String, Object> item = new LinkedHashMap<>();
             Map<String, Object> item = new LinkedHashMap<>();
             item.put("dtuSn", sn);
             item.put("dtuSn", sn);
             item.put("deviceName", deviceNameMap.getOrDefault(sn, ""));
             item.put("deviceName", deviceNameMap.getOrDefault(sn, ""));
@@ -1207,11 +1138,9 @@ public class DeviceSearchService {
             item.put("bootRate", String.format("%.2f%%", bootRate));
             item.put("bootRate", String.format("%.2f%%", bootRate));
             item.put("bootRateValue", bootRate);
             item.put("bootRateValue", bootRate);
             item.put("dataDays", (int) vals[5]);
             item.put("dataDays", (int) vals[5]);
-
             rateMap.put(sn, item);
             rateMap.put(sn, item);
         }
         }
 
 
-        // 6. 确保所有设备都在返回列表中（没有数据的设备开机率为0）
         List<Map<String, Object>> resultList = new ArrayList<>(allDtuSns.size());
         List<Map<String, Object>> resultList = new ArrayList<>(allDtuSns.size());
         for (String sn : allDtuSns) {
         for (String sn : allDtuSns) {
             if (rateMap.containsKey(sn)) {
             if (rateMap.containsKey(sn)) {
@@ -1233,7 +1162,6 @@ public class DeviceSearchService {
             }
             }
         }
         }
 
 
-        // 计算整体汇总
         double sumTotal = 0, sumOn = 0, sumOff = 0;
         double sumTotal = 0, sumOn = 0, sumOff = 0;
         for (Map<String, Object> r : rateMap.values()) {
         for (Map<String, Object> r : rateMap.values()) {
             sumTotal += ((Number) r.get("totalSeconds")).doubleValue();
             sumTotal += ((Number) r.get("totalSeconds")).doubleValue();
@@ -1242,105 +1170,82 @@ public class DeviceSearchService {
         }
         }
         double overallBootRate = sumTotal > 0 ? Math.round(sumOn * 10000.0 / sumTotal) / 100.0 : 0.0;
         double overallBootRate = sumTotal > 0 ? Math.round(sumOn * 10000.0 / sumTotal) / 100.0 : 0.0;
 
 
-        return Map.of(
-                "summary", Map.of(
-                        "totalDevices", allDtuSns.size(),
-                        "totalDuration", formatDuration((long) sumTotal),
-                        "totalSeconds", Math.round(sumTotal),
-                        "onDuration", formatDuration((long) sumOn),
-                        "onSeconds", Math.round(sumOn),
-                        "offDuration", formatDuration((long) sumOff),
-                        "offSeconds", Math.round(sumOff),
-                        "overallBootRate", String.format("%.2f%%", overallBootRate),
-                        "overallBootRateValue", overallBootRate
-                ),
-                "list", resultList,
-                "startDate", startDate,
-                "endDate", endDate
-        );
+        return Map.of("summary", Map.of("totalDevices", allDtuSns.size(),
+                        "totalDuration", formatDuration((long) sumTotal), "totalSeconds", Math.round(sumTotal),
+                        "onDuration", formatDuration((long) sumOn), "onSeconds", Math.round(sumOn),
+                        "offDuration", formatDuration((long) sumOff), "offSeconds", Math.round(sumOff),
+                        "overallBootRate", String.format("%.2f%%", overallBootRate), "overallBootRateValue", overallBootRate),
+                "list", resultList, "startDate", startDate, "endDate", endDate);
     }
     }
 
 
-    /** 批量从 dev_util 表查询（排除指定日期） */
-    private List<Map<String, Object>> queryDevUtilBatch(String corpCode, List<String> dtuSns,
-                                                         String startDate, String endDate, String excludeToday) {
-        StringBuilder sql = new StringBuilder(
-                "SELECT dtuSn, SUM(`0`) as s0, SUM(`1`) as s1, SUM(`2`) as s2, SUM(`3`) as s3, SUM(`4`) as s4, COUNT(*) as days " +
-                        "FROM " + devUtilTableName +
-                        " WHERE corp_code = ? AND dtuSn IN (");
+    private List<Map<String, Object>> queryDevUtilBatch(JdbcTemplate jt, String devUtilTableName, String corpCode,
+                                                        List<String> dtuSns, String startDate, String endDate, String excludeToday) {
+        StringBuilder sql = new StringBuilder("SELECT dtuSn, SUM(`0`) as s0, SUM(`1`) as s1, SUM(`2`) as s2, SUM(`3`) as s3, SUM(`4`) as s4, COUNT(*) as days " +
+                "FROM " + devUtilTableName + " WHERE corp_code = ? AND dtuSn IN (");
         List<Object> params = new ArrayList<>();
         List<Object> params = new ArrayList<>();
         params.add(corpCode);
         params.add(corpCode);
-
-        for (String sn : dtuSns) { sql.append("?,"); params.add(sn); }
+        for (String sn : dtuSns) {
+            sql.append("?,");
+            params.add(sn);
+        }
         sql.deleteCharAt(sql.length() - 1).append(")");
         sql.deleteCharAt(sql.length() - 1).append(")");
-
-        // 日期范围：如果开始日期=excludeToday，则从明天开始查
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         String actualStart = startDate.equals(excludeToday) ? getNextDay(excludeToday) : startDate;
         String actualStart = startDate.equals(excludeToday) ? getNextDay(excludeToday) : startDate;
-
         try {
         try {
             Date startD = sdf.parse(actualStart);
             Date startD = sdf.parse(actualStart);
             Date endD = sdf.parse(endDate);
             Date endD = sdf.parse(endDate);
             Date excD = sdf.parse(excludeToday);
             Date excD = sdf.parse(excludeToday);
-            if (!startD.before(excD) || endD.before(startD)) {
-                return Collections.emptyList(); // 只有今天一天或无效范围
-            }
+            if (!startD.before(excD) || endD.before(startD)) return Collections.emptyList();
         } catch (Exception e) {
         } catch (Exception e) {
             log.error("日期解析失败: {} ~ {}, 排除: {}", actualStart, endDate, excludeToday, e);
             log.error("日期解析失败: {} ~ {}, 排除: {}", actualStart, endDate, excludeToday, e);
             return Collections.emptyList();
             return Collections.emptyList();
         }
         }
-
         sql.append(" AND date_util BETWEEN ? AND ?");
         sql.append(" AND date_util BETWEEN ? AND ?");
         params.add(actualStart);
         params.add(actualStart);
         params.add(endDate);
         params.add(endDate);
         sql.append(" GROUP BY dtuSn");
         sql.append(" GROUP BY dtuSn");
-
-        return jdbcTemplate.queryForList(sql.toString(), params.toArray());
+        return jt.queryForList(sql.toString(), params.toArray());
     }
     }
 
 
-    /** 补充今天的稼动率接口实时数据 */
-    private void supplementTodayDevUtil(List<String> dtuSns, String todayStr, Map<String, double[]> rawMap) {
+    private void supplementTodayDevUtil(String corpCode, List<String> dtuSns, String todayStr, Map<String, double[]> rawMap) {
         log.info("开机率查询 - 开始补充今日({})实时dev_util数据...", todayStr);
         log.info("开机率查询 - 开始补充今日({})实时dev_util数据...", todayStr);
-        int apiCount = 0;
         for (String dtuSn : dtuSns) {
         for (String dtuSn : dtuSns) {
             try {
             try {
-                String rateResult = devicePullService.getDtuSnRateOfAction(dtuSn, todayStr, todayStr);
+                String rateResult = devicePullService.getDtuSnRateOfAction(corpCode, dtuSn, todayStr, todayStr);
                 if (StringUtils.hasText(rateResult)) {
                 if (StringUtils.hasText(rateResult)) {
-                    Map<String, Object> res = JSON.parseObject(rateResult, new com.alibaba.fastjson.TypeReference<>() {});
+                    Map<String, Object> res = JSON.parseObject(rateResult, new com.alibaba.fastjson.TypeReference<>() {
+                    });
                     Integer code = (Integer) res.get("code");
                     Integer code = (Integer) res.get("code");
                     if (code == null || code != 200) continue;
                     if (code == null || code != 200) continue;
-
                     JSONArray dataList = (JSONArray) res.get("data");
                     JSONArray dataList = (JSONArray) res.get("data");
                     if (dataList == null || dataList.isEmpty()) continue;
                     if (dataList == null || dataList.isEmpty()) continue;
-
                     JSONObject dayData = (JSONObject) dataList.get(0);
                     JSONObject dayData = (JSONObject) dataList.get(0);
                     JSONArray realRateList = dayData.getJSONArray("realRate");
                     JSONArray realRateList = dayData.getJSONArray("realRate");
                     if (realRateList == null || realRateList.isEmpty()) continue;
                     if (realRateList == null || realRateList.isEmpty()) continue;
-
                     JSONObject rateObj = (JSONObject) realRateList.get(0);
                     JSONObject rateObj = (JSONObject) realRateList.get(0);
                     double s0 = rateObj.getDoubleValue("0");
                     double s0 = rateObj.getDoubleValue("0");
                     double s1 = rateObj.getDoubleValue("1");
                     double s1 = rateObj.getDoubleValue("1");
                     double s2 = rateObj.getDoubleValue("2");
                     double s2 = rateObj.getDoubleValue("2");
                     double s3 = rateObj.getDoubleValue("3");
                     double s3 = rateObj.getDoubleValue("3");
                     double s4 = rateObj.getDoubleValue("4");
                     double s4 = rateObj.getDoubleValue("4");
-
-                    // 累加到已有数据上（DB已有历史数据 + 今天实时数据）
                     double[] existing = rawMap.get(dtuSn);
                     double[] existing = rawMap.get(dtuSn);
                     if (existing != null) {
                     if (existing != null) {
-                        existing[0] += s0; existing[1] += s1; existing[2] += s2;
-                        existing[3] += s3; existing[4] += s4; existing[5] += 1;
+                        existing[0] += s0;
+                        existing[1] += s1;
+                        existing[2] += s2;
+                        existing[3] += s3;
+                        existing[4] += s4;
+                        existing[5] += 1;
                     } else {
                     } else {
                         rawMap.put(dtuSn, new double[]{s0, s1, s2, s3, s4, 1});
                         rawMap.put(dtuSn, new double[]{s0, s1, s2, s3, s4, 1});
                     }
                     }
-                    apiCount++;
                 }
                 }
             } catch (Exception e) {
             } catch (Exception e) {
                 log.error("获取今日稼动率数据异常 - dtuSn:{}", dtuSn, e);
                 log.error("获取今日稼动率数据异常 - dtuSn:{}", dtuSn, e);
             }
             }
         }
         }
-        log.info("开机率查询 - 今日实时数据补充完成, 新增 {} 条", apiCount);
     }
     }
 
 
-    /** 获取下一天的日期字符串 */
     private static String getNextDay(String dateStr) {
     private static String getNextDay(String dateStr) {
         try {
         try {
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

@@ -40,22 +40,10 @@ public class EnergyPullService {
 
 
     @Value("${energy.token.url}")
     @Value("${energy.token.url}")
     private String energyTokenUrl;
     private String energyTokenUrl;
-    @Value("${energy.token.userName}")
-    private String energyUserName;
-    @Value("${energy.token.password}")
-    private String energyPassword;
     @Value("${energy.deviceList.url}")
     @Value("${energy.deviceList.url}")
     private String energyDeviceListUrl;
     private String energyDeviceListUrl;
     @Value("${energy.detail.url}")
     @Value("${energy.detail.url}")
     private String energyDetailUrl;
     private String energyDetailUrl;
-    @Value("${energy.db.corpCode}")
-    private String energyCorpCode;
-    @Value("${energy.db.tableName}")
-    private String energyTableName;
-    @Value("${energy.db.eqKwhTableName}")
-    private String eqKwhTableName;
-    @Value("${energy.db.eRunDtlTableName}")
-    private String eRunDtlTableName;
     @Value("${energy.runStatus.url}")
     @Value("${energy.runStatus.url}")
     private String energyRunStatusUrl;
     private String energyRunStatusUrl;
 
 
@@ -63,21 +51,39 @@ public class EnergyPullService {
     private RedisTemplate<String, String> redisTemplate;
     private RedisTemplate<String, String> redisTemplate;
     @Resource
     @Resource
     private JdbcTemplate jdbcTemplate;
     private JdbcTemplate jdbcTemplate;
+    @Resource
+    private CorpConfigService corpConfigService;
 
 
     /**
     /**
-     * 定时任务：同步能耗设备数据
+     * 定时任务：同步能耗设备数据（遍历所有已配置公司）
      */
      */
     @Scheduled(cron = "${scheduler.energy.cron:0 0/5 * * ?}")
     @Scheduled(cron = "${scheduler.energy.cron:0 0/5 * * ?}")
     public void pullEnergyDeviceAndSave() {
     public void pullEnergyDeviceAndSave() {
-        log.info("【能耗数据同步】开始同步能耗设备数据");
+        List<String> corpCodes = corpConfigService.getAllCorpCodes();
+        if (corpCodes.isEmpty()) {
+            log.warn("[Scheduled] energy: no corp config found, skip");
+            return;
+        }
+        for (String corpCode : corpCodes) {
+            pullEnergyDeviceAndSave(corpCode);
+        }
+    }
+
+    public void pullEnergyDeviceAndSave(String corpCode) {
+        if (!corpConfigService.hasValidIotCredentials(corpCode)) {
+            log.warn("【能耗数据同步】IoT凭证为空, 跳过同步, corpCode={}", corpCode);
+            return;
+        }
+        log.info("【能耗数据同步】开始同步能耗设备数据, corpCode={}", corpCode);
         try {
         try {
-            String energyResult = getEnergyDeviceList();
+            String energyResult = getEnergyDeviceList(corpCode);
             if (StringUtils.isBlank(energyResult)) {
             if (StringUtils.isBlank(energyResult)) {
                 log.error("【能耗数据同步】获取能耗设备列表失败");
                 log.error("【能耗数据同步】获取能耗设备列表失败");
                 return;
                 return;
             }
             }
 
 
-            Map<String, Object> energyInfos = JSON.parseObject(energyResult, new TypeReference<>() {});
+            Map<String, Object> energyInfos = JSON.parseObject(energyResult, new TypeReference<>() {
+            });
             Integer code = (Integer) energyInfos.get("code");
             Integer code = (Integer) energyInfos.get("code");
             if (code == null || code != 200) {
             if (code == null || code != 200) {
                 log.error("【能耗数据同步】获取能耗设备列表返回code不为200, code:{}, response:{}", code, energyResult);
                 log.error("【能耗数据同步】获取能耗设备列表返回code不为200, code:{}, response:{}", code, energyResult);
@@ -93,97 +99,72 @@ public class EnergyPullService {
             int successCount = 0;
             int successCount = 0;
             for (Object o : dataList) {
             for (Object o : dataList) {
                 JSONObject deviceJson = (JSONObject) o;
                 JSONObject deviceJson = (JSONObject) o;
-
                 String projectState = deviceJson.getString("projectState");
                 String projectState = deviceJson.getString("projectState");
                 String projectType = deviceJson.getString("projectType");
                 String projectType = deviceJson.getString("projectType");
                 String deviceName = deviceJson.getString("deviceName");
                 String deviceName = deviceJson.getString("deviceName");
                 String dtuId = deviceJson.getString("dtuId");
                 String dtuId = deviceJson.getString("dtuId");
                 String deviceId = deviceJson.getString("deviceId");
                 String deviceId = deviceJson.getString("deviceId");
                 String dtuSn = deviceJson.getString("dtuSn");
                 String dtuSn = deviceJson.getString("dtuSn");
+                log.info("【能耗数据处理】corpCode:{}, deviceName:{}, dtuSn:{}, projectState:{}, projectType:{}",
+                        corpCode, deviceName, dtuSn, projectState, projectType);
 
 
-                log.info("【能耗数据处理】deviceName:{}, dtuSn:{}, projectState:{}, projectType:{}",
-                        deviceName, dtuSn, projectState, projectType);
-
-                // 获取今日用电量
-                String todayEvalue = getTodayEnergyValue(dtuSn);
-
-                // 获取能耗OEE历史数据（最后一条的duration和runStatus）
-                Map<String, String> runStatusMap = getEnergyRunStatus(dtuSn);
+                String todayEvalue = getTodayEnergyValue(corpCode, dtuSn);
+                Map<String, String> runStatusMap = getEnergyRunStatus(corpCode, dtuSn);
                 String duration = runStatusMap.get("duration");
                 String duration = runStatusMap.get("duration");
                 String runStatus = runStatusMap.get("runStatus");
                 String runStatus = runStatusMap.get("runStatus");
 
 
-                saveOrUpdateEnergyDevice(projectState, projectType, deviceName, dtuId, deviceId, dtuSn,
+                saveOrUpdateEnergyDevice(corpCode, projectState, projectType, deviceName, dtuId, deviceId, dtuSn,
                         todayEvalue, duration, runStatus);
                         todayEvalue, duration, runStatus);
                 successCount++;
                 successCount++;
             }
             }
-
             log.info("【能耗数据同步】同步完成，共处理 {} 条设备数据", successCount);
             log.info("【能耗数据同步】同步完成，共处理 {} 条设备数据", successCount);
         } catch (Exception e) {
         } catch (Exception e) {
             log.error("【能耗数据同步】同步过程发生异常", e);
             log.error("【能耗数据同步】同步过程发生异常", e);
         }
         }
     }
     }
 
 
-    /**
-     * 获取能耗设备列表
-     */
-    public String getEnergyDeviceList() {
-        String accessToken = getEnergyAccessToken();
+    public String getEnergyDeviceList(String corpCode) {
+        String accessToken = getEnergyAccessToken(corpCode);
         Map<String, String> headerMap = new HashMap<>(1);
         Map<String, String> headerMap = new HashMap<>(1);
         headerMap.put("Authorization", "Bearer " + accessToken);
         headerMap.put("Authorization", "Bearer " + accessToken);
-
         Map<String, String> paramsMap = new HashMap<>();
         Map<String, String> paramsMap = new HashMap<>();
-        paramsMap.put("groupName", "SHC");
-
-        // 第一次请求
+        paramsMap.put("groupName", corpConfigService.getIotOrg(corpCode));
         String result = sendRequestGet(energyDeviceListUrl, paramsMap, headerMap);
         String result = sendRequestGet(energyDeviceListUrl, paramsMap, headerMap);
-        if (StringUtils.isBlank(result)) {
-            return null;
-        }
+        if (StringUtils.isBlank(result)) return null;
 
 
-        Map<String, Object> resultMap = JSON.parseObject(result, new TypeReference<>() {});
+        Map<String, Object> resultMap = JSON.parseObject(result, new TypeReference<>() {
+        });
         Integer resultCode = (Integer) resultMap.get("code");
         Integer resultCode = (Integer) resultMap.get("code");
 
 
-        // Token失效，重试一次
         if (resultCode == null || resultCode != 200) {
         if (resultCode == null || resultCode != 200) {
             log.warn("【能耗设备列表】第一次请求失败，重新获取Token重试");
             log.warn("【能耗设备列表】第一次请求失败，重新获取Token重试");
-            accessToken = getEnergyAccessToken();
-            if (StringUtils.isEmpty(accessToken)) {
-                return null;
-            }
+            accessToken = getEnergyAccessToken(corpCode);
+            if (StringUtils.isEmpty(accessToken)) return null;
             headerMap.put("Authorization", "Bearer " + accessToken);
             headerMap.put("Authorization", "Bearer " + accessToken);
-
             result = sendRequestGet(energyDeviceListUrl, paramsMap, headerMap);
             result = sendRequestGet(energyDeviceListUrl, paramsMap, headerMap);
-            if (StringUtils.isBlank(result)) {
-                return null;
-            }
-
-            resultMap = JSON.parseObject(result, new TypeReference<>() {});
+            if (StringUtils.isBlank(result)) return null;
+            resultMap = JSON.parseObject(result, new TypeReference<>() {
+            });
             resultCode = (Integer) resultMap.get("code");
             resultCode = (Integer) resultMap.get("code");
             if (resultCode == null || resultCode != 200) {
             if (resultCode == null || resultCode != 200) {
                 log.error("【能耗设备列表】重试后仍然失败, code:{}", resultCode);
                 log.error("【能耗设备列表】重试后仍然失败, code:{}", resultCode);
                 return null;
                 return null;
             }
             }
         }
         }
-
         return result;
         return result;
     }
     }
 
 
-    /**
-     * 获取能耗Token
-     */
-    private String getEnergyAccessToken() {
-        String redisKey = "hnyssl_energy_token";
-        
-        // 检查Redis中是否有有效Token
+    private String getEnergyAccessToken(String corpCode) {
+        String redisKey = "hnyssl_energy_token_" + corpCode;
         String cachedToken = redisTemplate.opsForValue().get(redisKey);
         String cachedToken = redisTemplate.opsForValue().get(redisKey);
-        if (StringUtils.isNotBlank(cachedToken) && redisTemplate.getExpire(redisKey) > 0) {
-            return cachedToken;
-        }
+        if (StringUtils.isNotBlank(cachedToken) && redisTemplate.getExpire(redisKey) > 0) return cachedToken;
 
 
-        // 请求新Token
+        // 使用公司配置中的用户名密码
+        String userName = corpConfigService.getIotUsername(corpCode);
+        String password = corpConfigService.getIotPassword(corpCode);
         Map<String, String> param = new HashMap<>(2);
         Map<String, String> param = new HashMap<>(2);
-        param.put("username", energyUserName);
-        param.put("password", energyPassword);
+        param.put("username", userName);
+        param.put("password", password);
 
 
         HttpPost httpPost = new HttpPost(energyTokenUrl);
         HttpPost httpPost = new HttpPost(energyTokenUrl);
         String result = sendPost(httpPost, JSON.toJSONString(param));
         String result = sendPost(httpPost, JSON.toJSONString(param));
@@ -192,7 +173,8 @@ public class EnergyPullService {
             return "";
             return "";
         }
         }
 
 
-        Map<String, Object> res = JSON.parseObject(result, new TypeReference<>() {});
+        Map<String, Object> res = JSON.parseObject(result, new TypeReference<>() {
+        });
         Integer code = (Integer) res.get("code");
         Integer code = (Integer) res.get("code");
         if (code == null || code != 200) {
         if (code == null || code != 200) {
             log.error("【能耗Token】请求Token返回异常, code:{}", code);
             log.error("【能耗Token】请求Token返回异常, code:{}", code);
@@ -206,118 +188,85 @@ public class EnergyPullService {
             return "";
             return "";
         }
         }
 
 
-        // 缓存Token，有效期1小时（Token实际有效期2小时）
         redisTemplate.opsForValue().set(redisKey, token, 3600, TimeUnit.SECONDS);
         redisTemplate.opsForValue().set(redisKey, token, 3600, TimeUnit.SECONDS);
-        log.info("【能耗Token】获取Token成功并缓存");
-
+        log.info("【能耗Token】获取Token成功并缓存, corpCode={}", corpCode);
         return token;
         return token;
     }
     }
 
 
-    /**
-     * 保存或更新能耗设备数据（含用电量evalue、duration、runStatus）
-     */
-    private void saveOrUpdateEnergyDevice(String projectState, String projectType, String deviceName,
+    private void saveOrUpdateEnergyDevice(String corpCode, String projectState, String projectType, String deviceName,
                                           String dtuId, String deviceId, String dtuSn,
                                           String dtuId, String deviceId, String dtuSn,
                                           String evalue, String duration, String runStatus) {
                                           String evalue, String duration, String runStatus) {
-        // 查询是否已存在（按公司+dtuSn判断）
-        List<Map<String, Object>> existList = jdbcTemplate.queryForList(
-                "SELECT id FROM " + energyTableName + " WHERE corp_code = ? AND dtuSn = ?", energyCorpCode, dtuSn);
+        String energyTableName = corpConfigService.getEnergyTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
 
 
+        List<Map<String, Object>> existList = jt.queryForList(
+                "SELECT id FROM " + energyTableName + " WHERE corp_code = ? AND dtuSn = ?", corpCode, dtuSn);
         Date now = new Date();
         Date now = new Date();
         if (!existList.isEmpty()) {
         if (!existList.isEmpty()) {
-            // 更新
-            jdbcTemplate.update(
-                    "UPDATE " + energyTableName +
-                    " SET projectState = ?, projectType = ?, deviceName = ?, dtuId = ?, deviceId = ?, evalue = ?, duration = ?, runStatus = ?, updated_at = ?" +
-                    " WHERE corp_code = ? AND dtuSn = ?",
-                    projectState, projectType, deviceName, dtuId, deviceId, evalue, duration, runStatus, now, energyCorpCode, dtuSn);
-            log.debug("【能耗数据】更新成功 - dtuSn:{}, evalue:{}, runStatus:{}", dtuSn, evalue, runStatus);
+            jt.update("UPDATE " + energyTableName +
+                            " SET projectState = ?, projectType = ?, deviceName = ?, dtuId = ?, deviceId = ?, evalue = ?, duration = ?, runStatus = ?, updated_at = ?" +
+                            " WHERE corp_code = ? AND dtuSn = ?",
+                    projectState, projectType, deviceName, dtuId, deviceId, evalue, duration, runStatus, now, corpCode, dtuSn);
         } else {
         } else {
-            // 新增
             String id = UUID.randomUUID().toString().replace("-", "");
             String id = UUID.randomUUID().toString().replace("-", "");
-            jdbcTemplate.update(
-                    "INSERT INTO " + energyTableName +
-                    " (id, corp_code, created_at, created_by, updated_at, updated_by, deviceName, projectType, projectState, dtuSn, dtuId, deviceId, evalue, duration, runStatus)" +
-                    " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
-                    id, energyCorpCode, now, "system", now, "system",
+            jt.update("INSERT INTO " + energyTableName +
+                            " (id, corp_code, created_at, created_by, updated_at, updated_by, deviceName, projectType, projectState, dtuSn, dtuId, deviceId, evalue, duration, runStatus)" +
+                            " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                    id, corpCode, now, "system", now, "system",
                     deviceName, projectType, projectState, dtuSn, dtuId, deviceId, evalue, duration, runStatus);
                     deviceName, projectType, projectState, dtuSn, dtuId, deviceId, evalue, duration, runStatus);
-            log.debug("【能耗数据】新增成功 - dtuSn:{}, evalue:{}", dtuSn, evalue);
         }
         }
     }
     }
 
 
-    /**
-     * 获取能耗OEE历史数据
-     * 调用 /api/energy/runStatus?dtuSn=xxx&date=today
-     * @return Map包含 lastDuration（最后一条的duration）和 lastRunStatus（最后一条的runStatus），失败返回空Map
-     */
-    private Map<String, String> getEnergyRunStatus(String dtuSn) {
+    private Map<String, String> getEnergyRunStatus(String corpCode, String dtuSn) {
         Map<String, String> result = new HashMap<>();
         Map<String, String> result = new HashMap<>();
         result.put("duration", null);
         result.put("duration", null);
         result.put("runStatus", null);
         result.put("runStatus", null);
         try {
         try {
-            String accessToken = getEnergyAccessToken();
+            String accessToken = getEnergyAccessToken(corpCode);
             Map<String, String> headerMap = new HashMap<>(1);
             Map<String, String> headerMap = new HashMap<>(1);
             headerMap.put("Authorization", "Bearer " + accessToken);
             headerMap.put("Authorization", "Bearer " + accessToken);
-
             Map<String, String> paramsMap = new HashMap<>();
             Map<String, String> paramsMap = new HashMap<>();
             paramsMap.put("dtuSn", dtuSn);
             paramsMap.put("dtuSn", dtuSn);
             paramsMap.put("date", new SimpleDateFormat("yyyy-MM-dd").format(new Date()));
             paramsMap.put("date", new SimpleDateFormat("yyyy-MM-dd").format(new Date()));
-
             String response = sendRequestGet(energyRunStatusUrl, paramsMap, headerMap);
             String response = sendRequestGet(energyRunStatusUrl, paramsMap, headerMap);
-            if (StringUtils.isBlank(response)) {
-                return result;
-            }
-
-            Map<String, Object> resultMap = JSON.parseObject(response, new TypeReference<>() {});
+            if (StringUtils.isBlank(response)) return result;
+            Map<String, Object> resultMap = JSON.parseObject(response, new TypeReference<>() {
+            });
             Integer resultCode = (Integer) resultMap.get("code");
             Integer resultCode = (Integer) resultMap.get("code");
             if (resultCode == null || resultCode != 200) {
             if (resultCode == null || resultCode != 200) {
-                // Token失效重试
-                accessToken = getEnergyAccessToken();
-                if (StringUtils.isEmpty(accessToken)) {
-                    return result;
-                }
+                accessToken = getEnergyAccessToken(corpCode);
+                if (StringUtils.isEmpty(accessToken)) return result;
                 headerMap.put("Authorization", "Bearer " + accessToken);
                 headerMap.put("Authorization", "Bearer " + accessToken);
                 response = sendRequestGet(energyRunStatusUrl, paramsMap, headerMap);
                 response = sendRequestGet(energyRunStatusUrl, paramsMap, headerMap);
-                if (StringUtils.isBlank(response)) {
-                    return result;
-                }
-                resultMap = JSON.parseObject(response, new TypeReference<>() {});
+                if (StringUtils.isBlank(response)) return result;
+                resultMap = JSON.parseObject(response, new TypeReference<>() {
+                });
                 resultCode = (Integer) resultMap.get("code");
                 resultCode = (Integer) resultMap.get("code");
-                if (resultCode == null || resultCode != 200) {
-                    return result;
-                }
+                if (resultCode == null || resultCode != 200) return result;
             }
             }
-
             JSONArray dataList = (JSONArray) resultMap.get("data");
             JSONArray dataList = (JSONArray) resultMap.get("data");
-            // 完整data保存到 t_auto_ymk_iot_e_run_dtl 表
             String description = dataList != null ? dataList.toJSONString() : "[]";
             String description = dataList != null ? dataList.toJSONString() : "[]";
-            saveOrUpdateERunDtl(dtuSn, description, new SimpleDateFormat("yyyy-MM-dd 00:00:00").format(new Date()));
+            saveOrUpdateERunDtl(corpCode, dtuSn, description, new SimpleDateFormat("yyyy-MM-dd 00:00:00").format(new Date()));
 
 
-            // 取最后一条数据的 duration 和 runStatus
             if (!CollectionUtils.isEmpty(dataList)) {
             if (!CollectionUtils.isEmpty(dataList)) {
                 JSONObject lastItem = (JSONObject) dataList.get(dataList.size() - 1);
                 JSONObject lastItem = (JSONObject) dataList.get(dataList.size() - 1);
                 Long durVal = lastItem.getLong("duration");
                 Long durVal = lastItem.getLong("duration");
                 Integer statusVal = lastItem.getInteger("runStatus");
                 Integer statusVal = lastItem.getInteger("runStatus");
                 result.put("duration", durVal != null ? String.valueOf(durVal) : null);
                 result.put("duration", durVal != null ? String.valueOf(durVal) : null);
                 result.put("runStatus", statusVal != null ? String.valueOf(statusVal) : null);
                 result.put("runStatus", statusVal != null ? String.valueOf(statusVal) : null);
-                log.info("【能耗OEE】dtuSn:{}, 最后一条 - duration:{}, runStatus:{}",
-                        dtuSn, result.get("duration"), result.get("runStatus"));
             }
             }
         } catch (Exception e) {
         } catch (Exception e) {
-            log.error("【能耗OEE】获取异常 - dtuSn:{}", dtuSn, e);
+            log.error("【能耗OEE】获取异常 - corpCode:{}, dtuSn:{}", corpCode, dtuSn, e);
         }
         }
         return result;
         return result;
     }
     }
 
 
-    /**
-     * 保存或更新能耗OEE运行状态明细到 t_auto_ymk_iot_e_run_dtl 表
-     * 超过60000字符拆分存入runStatus2
-     */
-    private void saveOrUpdateERunDtl(String dtuSn, String description, String useDate) {
+    private void saveOrUpdateERunDtl(String corpCode, String dtuSn, String description, String useDate) {
+        String eRunDtlTableName = corpConfigService.getERunDtlTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
         int maxLen = 60000;
         int maxLen = 60000;
         String rs1 = "";
         String rs1 = "";
         String rs2 = "";
         String rs2 = "";
-
         if (description.length() > maxLen) {
         if (description.length() > maxLen) {
             rs1 = description.substring(0, maxLen);
             rs1 = description.substring(0, maxLen);
             rs2 = description.substring(maxLen);
             rs2 = description.substring(maxLen);
@@ -325,67 +274,44 @@ public class EnergyPullService {
             rs1 = description;
             rs1 = description;
         }
         }
 
 
-        List<Map<String, Object>> existList = jdbcTemplate.queryForList(
-                "SELECT id FROM " + eRunDtlTableName + " WHERE corp_code = ? AND dtuSn = ? AND use_date = ?",
-                energyCorpCode, dtuSn, useDate);
-
+        List<Map<String, Object>> existList = jt.queryForList(
+                "SELECT id FROM " + eRunDtlTableName + " WHERE corp_code = ? AND dtuSn = ? AND use_date = ?", corpCode, dtuSn, useDate);
         Date now = new Date();
         Date now = new Date();
         if (!existList.isEmpty()) {
         if (!existList.isEmpty()) {
-            jdbcTemplate.update(
-                    "UPDATE " + eRunDtlTableName + " SET runStatus1=?, runStatus2=?, updated_at=? WHERE corp_code=? AND dtuSn=? AND use_date=?",
-                    rs1, rs2, now, energyCorpCode, dtuSn, useDate);
+            jt.update("UPDATE " + eRunDtlTableName + " SET runStatus1=?, runStatus2=?, updated_at=? WHERE corp_code=? AND dtuSn=? AND use_date=?", rs1, rs2, now, corpCode, dtuSn, useDate);
         } else {
         } else {
             String id = UUID.randomUUID().toString().replace("-", "");
             String id = UUID.randomUUID().toString().replace("-", "");
-            jdbcTemplate.update(
-                    "INSERT INTO " + eRunDtlTableName +
-                    " (id,corp_code,created_at,created_by,updated_at,updated_by,dtuSn,use_date,runStatus1,runStatus2)" +
-                    " VALUES (?,?,?,?,?,?,?,?,?,?)",
-                    id, energyCorpCode, now, "system", now, "system", dtuSn, useDate, rs1, rs2);
+            jt.update("INSERT INTO " + eRunDtlTableName + " (id,corp_code,created_at,created_by,updated_at,updated_by,dtuSn,use_date,runStatus1,runStatus2)" +
+                    " VALUES (?,?,?,?,?,?,?,?,?,?)", id, corpCode, now, "system", now, "system", dtuSn, useDate, rs1, rs2);
         }
         }
     }
     }
 
 
     // ==================== 能耗历史数据全量/增量同步 ====================
     // ==================== 能耗历史数据全量/增量同步 ====================
 
 
-    /**
-     * 首次全量同步：本年1月1日 ~ 昨天（手动触发一次）
-     */
-    public void pullEnergyHistoryAndSave() {
+    public void pullEnergyHistoryAndSave(String corpCode) {
+        if (!corpConfigService.hasValidIotCredentials(corpCode)) {
+            log.warn("【能耗历史-全量】IoT凭证为空, 跳过同步, corpCode={}", corpCode);
+            return;
+        }
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         Calendar cal = Calendar.getInstance();
         Calendar cal = Calendar.getInstance();
-        cal.add(Calendar.DAY_OF_MONTH, -1); // 昨天
+        cal.add(Calendar.DAY_OF_MONTH, -1);
         String endDate = sdf.format(cal.getTime());
         String endDate = sdf.format(cal.getTime());
         cal.set(cal.get(Calendar.YEAR), Calendar.JANUARY, 1);
         cal.set(cal.get(Calendar.YEAR), Calendar.JANUARY, 1);
         String startDate = sdf.format(cal.getTime());
         String startDate = sdf.format(cal.getTime());
-
-        log.info("【能耗历史-全量】开始同步，日期范围: {} ~ {}", startDate, endDate);
-        doSyncEnergyHistory(startDate, endDate);
+        log.info("【能耗历史-全量】开始同步, corpCode:{}, 日期范围: {} ~ {}", corpCode, startDate, endDate);
+        doSyncEnergyHistory(corpCode, startDate, endDate);
     }
     }
-//
-//    /**
-//     * 每日增量同步：仅同步昨天的数据（定时任务自动触发）
-//     */
-//    @Scheduled(cron = "${scheduler.energyHistory.cron:0 40 2 * * ?}")
-//    public void pullEnergyHistoryDaily() {
-//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
-//        Calendar cal = Calendar.getInstance();
-//        cal.add(Calendar.DAY_OF_MONTH, -1);
-//        String yesterday = sdf.format(cal.getTime());
-//
-//        log.info("【能耗历史-每日增量】同步，日期: {}", yesterday);
-//        doSyncEnergyHistory(yesterday, yesterday);
-//    }
 
 
-    /**
-     * 核心同步逻辑：获取能耗设备列表 → 每个设备每天调用用电量+OEE接口 → 写入 eq_kwh / e_run_dtl 表
-     */
-    private void doSyncEnergyHistory(String startDate, String endDate) {
-        String energyResult = getEnergyDeviceList();
+    private void doSyncEnergyHistory(String corpCode, String startDate, String endDate) {
+        String energyResult = getEnergyDeviceList(corpCode);
         if (StringUtils.isBlank(energyResult)) {
         if (StringUtils.isBlank(energyResult)) {
             log.error("【能耗历史】获取设备列表失败");
             log.error("【能耗历史】获取设备列表失败");
             return;
             return;
         }
         }
 
 
-        Map<String, Object> energyInfos = JSON.parseObject(energyResult, new TypeReference<>() {});
+        Map<String, Object> energyInfos = JSON.parseObject(energyResult, new TypeReference<>() {
+        });
         Integer code = (Integer) energyInfos.get("code");
         Integer code = (Integer) energyInfos.get("code");
         if (code == null || code != 200) {
         if (code == null || code != 200) {
             log.error("【能耗历史】获取设备列表返回code异常, code:{}", code);
             log.error("【能耗历史】获取设备列表返回code异常, code:{}", code);
@@ -414,161 +340,109 @@ public class EnergyPullService {
             return;
             return;
         }
         }
 
 
-        log.info("【能耗历史】开始同步，设备数:{}, 天数:{}, 总计 {} 条记录待处理",
-                deviceList.size(), dateList.size(), deviceList.size() * dateList.size());
-
+        log.info("【能耗历史】开始同步, corpCode:{}, 设备数:{}, 天数:{}, 总计{}条记录待处理", corpCode, deviceList.size(), dateList.size(), deviceList.size() * dateList.size());
         int totalSaved = 0;
         int totalSaved = 0;
         for (Object o : deviceList) {
         for (Object o : deviceList) {
             JSONObject deviceJson = (JSONObject) o;
             JSONObject deviceJson = (JSONObject) o;
             String dtuSn = deviceJson.getString("dtuSn");
             String dtuSn = deviceJson.getString("dtuSn");
-
             for (String dateStr : dateList) {
             for (String dateStr : dateList) {
                 try {
                 try {
-                    // 1. 同步当日用电量数据到 t_auto_ymk_iot_eq_kwh
-                    syncEnergyValueForDate(dtuSn, dateStr);
-
-                    // 2. 同步当日OEE时序数据到 t_auto_ymk_iot_e_run_dtl
-                    syncRunStatusForDate(dtuSn, dateStr);
-
+                    syncEnergyValueForDate(corpCode, dtuSn, dateStr);
+                    syncRunStatusForDate(corpCode, dtuSn, dateStr);
                     totalSaved++;
                     totalSaved++;
                 } catch (Exception e) {
                 } catch (Exception e) {
-                    log.error("【能耗历史】处理异常 - dtuSn:{}, date:{}", dtuSn, dateStr, e);
+                    log.error("【能耗历史】处理异常 - corpCode:{}, dtuSn:{}, date:{}", corpCode, dtuSn, dateStr, e);
                 }
                 }
             }
             }
         }
         }
-
         log.info("【能耗历史】同步完成，共保存 {} 条记录", totalSaved);
         log.info("【能耗历史】同步完成，共保存 {} 条记录", totalSaved);
     }
     }
 
 
-    /**
-     * 同步指定日期的设备用电量数据到 t_auto_ymk_iot_eq_kwh 表
-     */
-    private void syncEnergyValueForDate(String dtuSn, String dateStr) {
-        String accessToken = getEnergyAccessToken();
+    private void syncEnergyValueForDate(String corpCode, String dtuSn, String dateStr) {
+        String accessToken = getEnergyAccessToken(corpCode);
         Map<String, String> headerMap = new HashMap<>(1);
         Map<String, String> headerMap = new HashMap<>(1);
         headerMap.put("Authorization", "Bearer " + accessToken);
         headerMap.put("Authorization", "Bearer " + accessToken);
-
         Map<String, String> paramsMap = new HashMap<>();
         Map<String, String> paramsMap = new HashMap<>();
         paramsMap.put("dtuSn", dtuSn);
         paramsMap.put("dtuSn", dtuSn);
         paramsMap.put("startDate", dateStr);
         paramsMap.put("startDate", dateStr);
         paramsMap.put("type", "0");
         paramsMap.put("type", "0");
-
         String result = sendRequestGet(energyDetailUrl, paramsMap, headerMap);
         String result = sendRequestGet(energyDetailUrl, paramsMap, headerMap);
-        if (StringUtils.isBlank(result)) {
-            return;
-        }
-
-        Map<String, Object> resultMap = JSON.parseObject(result, new TypeReference<>() {});
+        if (StringUtils.isBlank(result)) return;
+        Map<String, Object> resultMap = JSON.parseObject(result, new TypeReference<>() {
+        });
         Integer resultCode = (Integer) resultMap.get("code");
         Integer resultCode = (Integer) resultMap.get("code");
         if (resultCode == null || resultCode != 200) {
         if (resultCode == null || resultCode != 200) {
-            accessToken = getEnergyAccessToken();
-            if (StringUtils.isEmpty(accessToken)) {
-                return;
-            }
+            accessToken = getEnergyAccessToken(corpCode);
+            if (StringUtils.isEmpty(accessToken)) return;
             headerMap.put("Authorization", "Bearer " + accessToken);
             headerMap.put("Authorization", "Bearer " + accessToken);
             result = sendRequestGet(energyDetailUrl, paramsMap, headerMap);
             result = sendRequestGet(energyDetailUrl, paramsMap, headerMap);
-            if (StringUtils.isBlank(result)) {
-                return;
-            }
-            resultMap = JSON.parseObject(result, new TypeReference<>() {});
+            if (StringUtils.isBlank(result)) return;
+            resultMap = JSON.parseObject(result, new TypeReference<>() {
+            });
             resultCode = (Integer) resultMap.get("code");
             resultCode = (Integer) resultMap.get("code");
-            if (resultCode == null || resultCode != 200) {
-                return;
-            }
+            if (resultCode == null || resultCode != 200) return;
         }
         }
-
         JSONArray dataList = (JSONArray) resultMap.get("data");
         JSONArray dataList = (JSONArray) resultMap.get("data");
         String description = dataList != null ? dataList.toJSONString() : "[]";
         String description = dataList != null ? dataList.toJSONString() : "[]";
-        saveOrUpdateEqKwh(dtuSn, description, dateStr + " 00:00:00");
+        saveOrUpdateEqKwh(corpCode, dtuSn, description, dateStr + " 00:00:00");
     }
     }
 
 
-    /**
-     * 同步指定日期的设备OEE时序数据到 t_auto_ymk_iot_e_run_dtl 表
-     */
-    private void syncRunStatusForDate(String dtuSn, String dateStr) {
-        String accessToken = getEnergyAccessToken();
+    private void syncRunStatusForDate(String corpCode, String dtuSn, String dateStr) {
+        String accessToken = getEnergyAccessToken(corpCode);
         Map<String, String> headerMap = new HashMap<>(1);
         Map<String, String> headerMap = new HashMap<>(1);
         headerMap.put("Authorization", "Bearer " + accessToken);
         headerMap.put("Authorization", "Bearer " + accessToken);
-
         Map<String, String> paramsMap = new HashMap<>();
         Map<String, String> paramsMap = new HashMap<>();
         paramsMap.put("dtuSn", dtuSn);
         paramsMap.put("dtuSn", dtuSn);
         paramsMap.put("date", dateStr);
         paramsMap.put("date", dateStr);
-
         String response = sendRequestGet(energyRunStatusUrl, paramsMap, headerMap);
         String response = sendRequestGet(energyRunStatusUrl, paramsMap, headerMap);
-        if (StringUtils.isBlank(response)) {
-            return;
-        }
-
-        Map<String, Object> resultMap = JSON.parseObject(response, new TypeReference<>() {});
+        if (StringUtils.isBlank(response)) return;
+        Map<String, Object> resultMap = JSON.parseObject(response, new TypeReference<>() {
+        });
         Integer resultCode = (Integer) resultMap.get("code");
         Integer resultCode = (Integer) resultMap.get("code");
         if (resultCode == null || resultCode != 200) {
         if (resultCode == null || resultCode != 200) {
-            accessToken = getEnergyAccessToken();
-            if (StringUtils.isEmpty(accessToken)) {
-                return;
-            }
+            accessToken = getEnergyAccessToken(corpCode);
+            if (StringUtils.isEmpty(accessToken)) return;
             headerMap.put("Authorization", "Bearer " + accessToken);
             headerMap.put("Authorization", "Bearer " + accessToken);
             response = sendRequestGet(energyRunStatusUrl, paramsMap, headerMap);
             response = sendRequestGet(energyRunStatusUrl, paramsMap, headerMap);
-            if (StringUtils.isBlank(response)) {
-                return;
-            }
-            resultMap = JSON.parseObject(response, new TypeReference<>() {});
+            if (StringUtils.isBlank(response)) return;
+            resultMap = JSON.parseObject(response, new TypeReference<>() {
+            });
             resultCode = (Integer) resultMap.get("code");
             resultCode = (Integer) resultMap.get("code");
-            if (resultCode == null || resultCode != 200) {
-                return;
-            }
+            if (resultCode == null || resultCode != 200) return;
         }
         }
-
         JSONArray dataList = (JSONArray) resultMap.get("data");
         JSONArray dataList = (JSONArray) resultMap.get("data");
         String description = dataList != null ? dataList.toJSONString() : "[]";
         String description = dataList != null ? dataList.toJSONString() : "[]";
-        saveOrUpdateERunDtl(dtuSn, description, dateStr + " 00:00:00");
+        saveOrUpdateERunDtl(corpCode, dtuSn, description, dateStr + " 00:00:00");
     }
     }
 
 
-    /**
-     * 获取今日设备用电量 (type=0 按小时查询)
-     * 同时将完整响应data保存到 t_auto_ymk_iot_eq_kwh 表
-     * @return 今日用电量value，失败返回null
-     */
-    private String getTodayEnergyValue(String dtuSn) {
+    private String getTodayEnergyValue(String corpCode, String dtuSn) {
         try {
         try {
-            String accessToken = getEnergyAccessToken();
+            String accessToken = getEnergyAccessToken(corpCode);
             Map<String, String> headerMap = new HashMap<>(1);
             Map<String, String> headerMap = new HashMap<>(1);
             headerMap.put("Authorization", "Bearer " + accessToken);
             headerMap.put("Authorization", "Bearer " + accessToken);
-
             Map<String, String> paramsMap = new HashMap<>();
             Map<String, String> paramsMap = new HashMap<>();
             paramsMap.put("dtuSn", dtuSn);
             paramsMap.put("dtuSn", dtuSn);
             paramsMap.put("startDate", new SimpleDateFormat("yyyy-MM-dd").format(new Date()));
             paramsMap.put("startDate", new SimpleDateFormat("yyyy-MM-dd").format(new Date()));
             paramsMap.put("type", "0");
             paramsMap.put("type", "0");
-
             String result = sendRequestGet(energyDetailUrl, paramsMap, headerMap);
             String result = sendRequestGet(energyDetailUrl, paramsMap, headerMap);
-            if (StringUtils.isBlank(result)) {
-                return null;
-            }
-
-            Map<String, Object> resultMap = JSON.parseObject(result, new TypeReference<>() {});
+            if (StringUtils.isBlank(result)) return null;
+            Map<String, Object> resultMap = JSON.parseObject(result, new TypeReference<>() {
+            });
             Integer resultCode = (Integer) resultMap.get("code");
             Integer resultCode = (Integer) resultMap.get("code");
             if (resultCode == null || resultCode != 200) {
             if (resultCode == null || resultCode != 200) {
-                accessToken = getEnergyAccessToken();
-                if (StringUtils.isEmpty(accessToken)) {
-                    return null;
-                }
+                accessToken = getEnergyAccessToken(corpCode);
+                if (StringUtils.isEmpty(accessToken)) return null;
                 headerMap.put("Authorization", "Bearer " + accessToken);
                 headerMap.put("Authorization", "Bearer " + accessToken);
                 result = sendRequestGet(energyDetailUrl, paramsMap, headerMap);
                 result = sendRequestGet(energyDetailUrl, paramsMap, headerMap);
-                if (StringUtils.isBlank(result)) {
-                    return null;
-                }
-                resultMap = JSON.parseObject(result, new TypeReference<>() {});
+                if (StringUtils.isBlank(result)) return null;
+                resultMap = JSON.parseObject(result, new TypeReference<>() {
+                });
                 resultCode = (Integer) resultMap.get("code");
                 resultCode = (Integer) resultMap.get("code");
-                if (resultCode == null || resultCode != 200) {
-                    return null;
-                }
+                if (resultCode == null || resultCode != 200) return null;
             }
             }
-
             JSONArray dataList = (JSONArray) resultMap.get("data");
             JSONArray dataList = (JSONArray) resultMap.get("data");
-            // 将完整data保存到eq_kwh表
             String description = dataList != null ? dataList.toJSONString() : "[]";
             String description = dataList != null ? dataList.toJSONString() : "[]";
-            saveOrUpdateEqKwh(dtuSn, description, new SimpleDateFormat("yyyy-MM-dd 00:00:00").format(new Date()));
-
-            // 累加所有小时的value作为今日总用电量
+            saveOrUpdateEqKwh(corpCode, dtuSn, description, new SimpleDateFormat("yyyy-MM-dd 00:00:00").format(new Date()));
             double totalValue = 0;
             double totalValue = 0;
             if (!CollectionUtils.isEmpty(dataList)) {
             if (!CollectionUtils.isEmpty(dataList)) {
                 for (Object o : dataList) {
                 for (Object o : dataList) {
@@ -576,82 +450,58 @@ public class EnergyPullService {
                     totalValue += item.getDoubleValue("value");
                     totalValue += item.getDoubleValue("value");
                 }
                 }
             }
             }
-
             String evalueStr = String.valueOf(totalValue);
             String evalueStr = String.valueOf(totalValue);
-            log.info("【能耗用电量】dtuSn:{}, 今日用电量:{}", dtuSn, evalueStr);
+            log.info("【能耗用电量】corpCode:{}, dtuSn:{}, 今日用电量:{}", corpCode, dtuSn, evalueStr);
             return evalueStr;
             return evalueStr;
-
         } catch (Exception e) {
         } catch (Exception e) {
-            log.error("【能耗用电量】获取异常 - dtuSn:{}", dtuSn, e);
+            log.error("【能耗用电量】获取异常 - corpCode:{}, dtuSn:{}", corpCode, dtuSn, e);
             return null;
             return null;
         }
         }
     }
     }
 
 
-    /**
-     * 保存或更新用电量数据到 t_auto_ymk_iot_eq_kwh 表
-     */
-    private void saveOrUpdateEqKwh(String dtuSn, String description, String useDate) {
-        List<Map<String, Object>> existList = jdbcTemplate.queryForList(
-                "SELECT id FROM " + eqKwhTableName + " WHERE corp_code = ? AND dtuSn = ? AND use_date = ?",
-                energyCorpCode, dtuSn, useDate);
-
+    private void saveOrUpdateEqKwh(String corpCode, String dtuSn, String description, String useDate) {
+        String eqKwhTableName = corpConfigService.getEqKwhTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
+        List<Map<String, Object>> existList = jt.queryForList(
+                "SELECT id FROM " + eqKwhTableName + " WHERE corp_code = ? AND dtuSn = ? AND use_date = ?", corpCode, dtuSn, useDate);
         Date now = new Date();
         Date now = new Date();
         if (!existList.isEmpty()) {
         if (!existList.isEmpty()) {
-            jdbcTemplate.update(
-                    "UPDATE " + eqKwhTableName + " SET description = ?, updated_at = ? WHERE corp_code = ? AND dtuSn = ? AND use_date = ?",
-                    description, now, energyCorpCode, dtuSn, useDate);
+            jt.update("UPDATE " + eqKwhTableName + " SET description = ?, updated_at = ? WHERE corp_code = ? AND dtuSn = ? AND use_date = ?", description, now, corpCode, dtuSn, useDate);
         } else {
         } else {
             String id = UUID.randomUUID().toString().replace("-", "");
             String id = UUID.randomUUID().toString().replace("-", "");
-            jdbcTemplate.update(
-                    "INSERT INTO " + eqKwhTableName +
-                    " (id, corp_code, created_at, created_by, updated_at, updated_by, dtuSn, use_date, description)" +
-                    " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
-                    id, energyCorpCode, now, "system", now, "system", dtuSn, useDate, description);
+            jt.update("INSERT INTO " + eqKwhTableName + " (id, corp_code, created_at, created_by, updated_at, updated_by, dtuSn, use_date, description)" +
+                    " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)", id, corpCode, now, "system", now, "system", dtuSn, useDate, description);
         }
         }
     }
     }
 
 
-    /**
-     * 发送GET请求
-     */
     public static String sendRequestGet(String url, Map<String, String> params, Map<String, String> header) {
     public static String sendRequestGet(String url, Map<String, String> params, Map<String, String> header) {
         CloseableHttpClient httpclient = HttpClients.createDefault();
         CloseableHttpClient httpclient = HttpClients.createDefault();
         url = builderUrl(url, params);
         url = builderUrl(url, params);
         String content = "";
         String content = "";
         HttpGet httpget = new HttpGet(url);
         HttpGet httpget = new HttpGet(url);
         if (!CollectionUtils.isEmpty(header)) {
         if (!CollectionUtils.isEmpty(header)) {
-            for (Map.Entry<String, String> entry : header.entrySet()) {
+            for (Map.Entry<String, String> entry : header.entrySet())
                 httpget.setHeader(entry.getKey(), entry.getValue());
                 httpget.setHeader(entry.getKey(), entry.getValue());
-            }
         }
         }
-
         try (CloseableHttpResponse response = httpclient.execute(httpget)) {
         try (CloseableHttpResponse response = httpclient.execute(httpget)) {
-            if (response.getStatusLine().getStatusCode() == 200) {
+            if (response.getStatusLine().getStatusCode() == 200)
                 content = EntityUtils.toString(response.getEntity(), "UTF-8");
                 content = EntityUtils.toString(response.getEntity(), "UTF-8");
-            }
         } catch (IOException e) {
         } catch (IOException e) {
             log.error("sendRequest---GET Error!", e);
             log.error("sendRequest---GET Error!", e);
         }
         }
         return content;
         return content;
     }
     }
 
 
-    /**
-     * 构建带参数的URL
-     */
     private static String builderUrl(String url, Map<String, String> params) {
     private static String builderUrl(String url, Map<String, String> params) {
         UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromHttpUrl(url);
         UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromHttpUrl(url);
         if (!CollectionUtils.isEmpty(params)) {
         if (!CollectionUtils.isEmpty(params)) {
             MultiValueMap<String, String> paramsValue = new LinkedMultiValueMap<>();
             MultiValueMap<String, String> paramsValue = new LinkedMultiValueMap<>();
-            for (Map.Entry<String, String> entry : params.entrySet()) {
-                paramsValue.add(entry.getKey(), entry.getValue());
-            }
+            for (Map.Entry<String, String> entry : params.entrySet()) paramsValue.add(entry.getKey(), entry.getValue());
             uriBuilder = uriBuilder.queryParams(paramsValue);
             uriBuilder = uriBuilder.queryParams(paramsValue);
         }
         }
         return uriBuilder.toUriString();
         return uriBuilder.toUriString();
     }
     }
 
 
-    /**
-     * 发送POST请求
-     */
     private String sendPost(HttpPost httpPost, String jsonData) {
     private String sendPost(HttpPost httpPost, String jsonData) {
         CloseableHttpClient httpClient = HttpClients.createDefault();
         CloseableHttpClient httpClient = HttpClients.createDefault();
         StringEntity entity = new StringEntity(jsonData, ContentType.create("application/json", Consts.UTF_8));
         StringEntity entity = new StringEntity(jsonData, ContentType.create("application/json", Consts.UTF_8));
@@ -664,9 +514,7 @@ public class EnergyPullService {
             int len;
             int len;
             byte[] buf = new byte[128];
             byte[] buf = new byte[128];
             ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
             ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
-            while ((len = is.read(buf)) != -1) {
-                byteArrayOutputStream.write(buf, 0, len);
-            }
+            while ((len = is.read(buf)) != -1) byteArrayOutputStream.write(buf, 0, len);
             result = byteArrayOutputStream.toString();
             result = byteArrayOutputStream.toString();
         } catch (IOException e) {
         } catch (IOException e) {
             log.error("sendPost error!", e);
             log.error("sendPost error!", e);

@@ -4,7 +4,6 @@ import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.alibaba.fastjson.JSONObject;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 import org.springframework.util.StringUtils;
 import org.springframework.util.StringUtils;
@@ -20,59 +19,45 @@ import java.util.*;
 @Service
 @Service
 public class EnergySearchService {
 public class EnergySearchService {
 
 
-    @Value("${energy.db.corpCode}")
-    private String energyCorpCode;
-    @Value("${energy.db.tableName}")
-    private String energyTableName;
-    @Value("${energy.db.eqKwhTableName}")
-    private String eqKwhTableName;
-    @Value("${energy.db.eRunDtlTableName}")
-    private String eRunDtlTableName;
-
     @Resource
     @Resource
     private JdbcTemplate jdbcTemplate;
     private JdbcTemplate jdbcTemplate;
+    @Resource
+    private CorpConfigService corpConfigService;
 
 
     /**
     /**
      * 分页查询能耗设备信息
      * 分页查询能耗设备信息
-     * 查询表 t_auto_ymk_iot_energy，按设备名称排序
-     *
-     * @param deviceName 设备名称（模糊匹配）
-     * @param runStatus  状态（0：离线，1：停机，2：待机，3：运行）
-     * @param pageNo     页码，默认1
-     * @param pageSize   每页条数，默认10
      */
      */
-    public Map<String, Object> queryEnergyList(String deviceName, String runStatus,
+    public Map<String, Object> queryEnergyList(String corpCode, String deviceName, String runStatus,
                                                Integer pageNo, Integer pageSize) {
                                                Integer pageNo, Integer pageSize) {
+        String energyTableName = corpConfigService.getEnergyTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
+
         StringBuilder countSql = new StringBuilder("SELECT COUNT(*) FROM " + energyTableName + " WHERE corp_code = ?");
         StringBuilder countSql = new StringBuilder("SELECT COUNT(*) FROM " + energyTableName + " WHERE corp_code = ?");
         StringBuilder querySql = new StringBuilder(
         StringBuilder querySql = new StringBuilder(
                 "SELECT id, deviceName, projectType, projectState, dtuSn, dtuId, deviceId, " +
                 "SELECT id, deviceName, projectType, projectState, dtuSn, dtuId, deviceId, " +
                         "evalue, duration, runStatus, created_at, updated_at " +
                         "evalue, duration, runStatus, created_at, updated_at " +
                         "FROM " + energyTableName + " WHERE corp_code = ?");
                         "FROM " + energyTableName + " WHERE corp_code = ?");
         List<Object> params = new ArrayList<>();
         List<Object> params = new ArrayList<>();
-        params.add(energyCorpCode);
+        params.add(corpCode);
 
 
-        // 设备名称模糊查询
         if (StringUtils.hasText(deviceName)) {
         if (StringUtils.hasText(deviceName)) {
             countSql.append(" AND deviceName LIKE ?");
             countSql.append(" AND deviceName LIKE ?");
             querySql.append(" AND deviceName LIKE ?");
             querySql.append(" AND deviceName LIKE ?");
             params.add("%" + deviceName + "%");
             params.add("%" + deviceName + "%");
         }
         }
-
-        // 设备状态精确匹配
         if (StringUtils.hasText(runStatus)) {
         if (StringUtils.hasText(runStatus)) {
             countSql.append(" AND runStatus = ?");
             countSql.append(" AND runStatus = ?");
             querySql.append(" AND runStatus = ?");
             querySql.append(" AND runStatus = ?");
             params.add(runStatus);
             params.add(runStatus);
         }
         }
 
 
-        Long total = jdbcTemplate.queryForObject(countSql.toString(), Long.class, params.toArray());
+        Long total = jt.queryForObject(countSql.toString(), Long.class, params.toArray());
         int offset = (pageNo - 1) * pageSize;
         int offset = (pageNo - 1) * pageSize;
-
         querySql.append(" ORDER BY deviceName ASC LIMIT ?, ?");
         querySql.append(" ORDER BY deviceName ASC LIMIT ?, ?");
         params.add(offset);
         params.add(offset);
         params.add(pageSize);
         params.add(pageSize);
 
 
-        List<Map<String, Object>> list = jdbcTemplate.queryForList(querySql.toString(), params.toArray());
+        List<Map<String, Object>> list = jt.queryForList(querySql.toString(), params.toArray());
         list.forEach(row -> {
         list.forEach(row -> {
             if (row.get("duration") != null) {
             if (row.get("duration") != null) {
                 long seconds = Long.parseLong(String.valueOf(row.get("duration")));
                 long seconds = Long.parseLong(String.valueOf(row.get("duration")));
@@ -86,111 +71,75 @@ public class EnergySearchService {
                 row.put("duration", sb.toString());
                 row.put("duration", sb.toString());
             }
             }
         });
         });
-
-        return Map.of(
-                "code", 200,
-                "msg", "请求成功",
-                "total", total != null ? total : 0,
-                "pageNo", pageNo,
-                "pageSize", pageSize,
-                "list", list
-        );
+        return Map.of("code", 200, "msg", "请求成功", "total", total != null ? total : 0, "pageNo", pageNo,
+                "pageSize", pageSize, "list", list);
     }
     }
 
 
-    /**
-     * 统计能耗设备各runStatus数量及总数量
-     * runStatus: 0-离线, 1-停机, 2-待机, 3-运行
-     */
-    public Map<String, Object> queryEnergyStats() {
-        String sql = "SELECT runStatus, COUNT(*) AS cnt FROM " + energyTableName
-                + " WHERE corp_code = ? GROUP BY runStatus";
-        List<Map<String, Object>> rows = jdbcTemplate.queryForList(sql, energyCorpCode);
-
+    public Map<String, Object> queryEnergyStats(String corpCode) {
+        String energyTableName = corpConfigService.getEnergyTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
+        String sql = "SELECT runStatus, COUNT(*) AS cnt FROM " + energyTableName + " WHERE corp_code = ? GROUP BY runStatus";
+        List<Map<String, Object>> rows = jt.queryForList(sql, corpCode);
         int total = 0;
         int total = 0;
         Map<String, Integer> statusMap = new LinkedHashMap<>();
         Map<String, Integer> statusMap = new LinkedHashMap<>();
         statusMap.put("0", 0);
         statusMap.put("0", 0);
         statusMap.put("1", 0);
         statusMap.put("1", 0);
         statusMap.put("2", 0);
         statusMap.put("2", 0);
         statusMap.put("3", 0);
         statusMap.put("3", 0);
-
         for (Map<String, Object> row : rows) {
         for (Map<String, Object> row : rows) {
             String key = String.valueOf(row.get("runStatus"));
             String key = String.valueOf(row.get("runStatus"));
             int cnt = ((Number) row.get("cnt")).intValue();
             int cnt = ((Number) row.get("cnt")).intValue();
             total += cnt;
             total += cnt;
             statusMap.merge(key, cnt, Integer::sum);
             statusMap.merge(key, cnt, Integer::sum);
         }
         }
-
-        return Map.of(
-                "code", 200,
-                "msg", "请求成功",
-                "total", total,
-                "0", statusMap.get("0"),
-                "1", statusMap.get("1"),
-                "2", statusMap.get("2"),
-                "3", statusMap.get("3")
-        );
+        return Map.of("code", 200, "msg", "请求成功", "total", total, "0", statusMap.get("0"),
+                "1", statusMap.get("1"), "2", statusMap.get("2"), "3", statusMap.get("3"));
     }
     }
 
 
-    /**
-     * 根据dtuSn查询指定日期的设备时用电量和OEE时序
-     * 1. 时用电量：从t_auto_ymk_iot_eq_kwh表获取，并计算当日总用电量
-     * 2. OEE时序：从t_auto_ymk_iot_e_run_dtl表获取，统计总时长、各状态运行时长和占比
-     *
-     * @param dtuSn 设备序列号
-     * @param date  查询日期 yyyy-MM-dd
-     */
-    public Map<String, Object> queryEnergyDetailByDate(String dtuSn, String date) {
-        // 1. 查询时用电量数据 - 原始数据直接返回
+    public Map<String, Object> queryEnergyDetailByDate(String corpCode, String dtuSn, String date) {
+        String eqKwhTableName = corpConfigService.getEqKwhTableName(corpCode);
+        String eRunDtlTableName = corpConfigService.getERunDtlTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
+
         Object kwhRawData = Collections.emptyList();
         Object kwhRawData = Collections.emptyList();
         BigDecimal totalKwh = BigDecimal.ZERO;
         BigDecimal totalKwh = BigDecimal.ZERO;
         try {
         try {
-            String kwhSql = "SELECT description FROM " + eqKwhTableName
-                    + " WHERE corp_code = ? AND dtuSn = ? AND use_date = ?";
-            Map<String, Object> kwhRow = jdbcTemplate.queryForMap(kwhSql, energyCorpCode, dtuSn, date + " 00:00:00");
+            String kwhSql = "SELECT description FROM " + eqKwhTableName + " WHERE corp_code = ? AND dtuSn = ? AND use_date = ?";
+            Map<String, Object> kwhRow = jt.queryForMap(kwhSql, corpCode, dtuSn, date + " 00:00:00");
             if (kwhRow != null && kwhRow.get("description") != null) {
             if (kwhRow != null && kwhRow.get("description") != null) {
                 String description = String.valueOf(kwhRow.get("description"));
                 String description = String.valueOf(kwhRow.get("description"));
                 kwhRawData = JSON.parseArray(description);
                 kwhRawData = JSON.parseArray(description);
-                // 计算总用电量
                 JSONArray dataArray = JSON.parseArray(description);
                 JSONArray dataArray = JSON.parseArray(description);
                 for (int i = 0; i < dataArray.size(); i++) {
                 for (int i = 0; i < dataArray.size(); i++) {
                     JSONObject item = dataArray.getJSONObject(i);
                     JSONObject item = dataArray.getJSONObject(i);
                     Double value = item.getDouble("value");
                     Double value = item.getDouble("value");
-                    if (value != null) {
-                        totalKwh = totalKwh.add(BigDecimal.valueOf(value));
-                    }
+                    if (value != null) totalKwh = totalKwh.add(BigDecimal.valueOf(value));
                 }
                 }
             }
             }
         } catch (Exception e) {
         } catch (Exception e) {
-            log.warn("【能耗明细】查询时用电量数据为空或异常 - dtuSn:{}, date:{}", dtuSn, date);
+            log.warn("【能耗明细】查询时用电量数据为空或异常 - corpCode:{}, dtuSn:{}, date:{}", corpCode, dtuSn, date, e);
         }
         }
 
 
-        // 2. 查询OEE时序数据 - 原始数据直接返回
         Object oeeRawData = Collections.emptyList();
         Object oeeRawData = Collections.emptyList();
         long totalDuration = 0;
         long totalDuration = 0;
-        // runStatus状态: 0-离线, 1-停机, 2-待机, 3-运行
         Map<Integer, Long> statusDurationMap = new LinkedHashMap<>();
         Map<Integer, Long> statusDurationMap = new LinkedHashMap<>();
-        statusDurationMap.put(0, 0L); // 离线
-        statusDurationMap.put(1, 0L); // 停机
-        statusDurationMap.put(2, 0L); // 待机
-        statusDurationMap.put(3, 0L); // 运行
-
+        statusDurationMap.put(0, 0L);
+        statusDurationMap.put(1, 0L);
+        statusDurationMap.put(2, 0L);
+        statusDurationMap.put(3, 0L);
         try {
         try {
-            String oeeSql = "SELECT runStatus1, runStatus2 FROM " + eRunDtlTableName
-                    + " WHERE corp_code = ? AND dtuSn = ? AND use_date = ?";
-            Map<String, Object> oeeRow = jdbcTemplate.queryForMap(oeeSql, energyCorpCode, dtuSn, date + " 00:00:00");
+            String oeeSql = "SELECT runStatus1, runStatus2 FROM " + eRunDtlTableName + " WHERE corp_code = ? AND dtuSn = ? AND use_date = ?";
+            Map<String, Object> oeeRow = jt.queryForMap(oeeSql, corpCode, dtuSn, date + " 00:00:00");
             if (oeeRow != null) {
             if (oeeRow != null) {
                 String rs1 = oeeRow.get("runStatus1") != null ? String.valueOf(oeeRow.get("runStatus1")) : "";
                 String rs1 = oeeRow.get("runStatus1") != null ? String.valueOf(oeeRow.get("runStatus1")) : "";
                 String rs2 = oeeRow.get("runStatus2") != null ? String.valueOf(oeeRow.get("runStatus2")) : "";
                 String rs2 = oeeRow.get("runStatus2") != null ? String.valueOf(oeeRow.get("runStatus2")) : "";
                 String jsonStr = rs1 + rs2;
                 String jsonStr = rs1 + rs2;
                 oeeRawData = JSON.parseArray(jsonStr);
                 oeeRawData = JSON.parseArray(jsonStr);
-
-                // 统计各状态时长
                 JSONArray dataArray = JSON.parseArray(jsonStr);
                 JSONArray dataArray = JSON.parseArray(jsonStr);
                 for (int i = 0; i < dataArray.size(); i++) {
                 for (int i = 0; i < dataArray.size(); i++) {
                     JSONObject item = dataArray.getJSONObject(i);
                     JSONObject item = dataArray.getJSONObject(i);
                     Long duration = item.getLong("duration");
                     Long duration = item.getLong("duration");
                     Integer runStatus = item.getInteger("runStatus");
                     Integer runStatus = item.getInteger("runStatus");
-
                     if (duration != null && duration > 0) {
                     if (duration != null && duration > 0) {
                         totalDuration += duration;
                         totalDuration += duration;
                         int statusKey = runStatus != null ? runStatus : 0;
                         int statusKey = runStatus != null ? runStatus : 0;
@@ -199,16 +148,13 @@ public class EnergySearchService {
                 }
                 }
             }
             }
         } catch (Exception e) {
         } catch (Exception e) {
-            log.warn("【能耗明细】查询OEE时序数据为空或异常 - dtuSn:{}, date:{}", dtuSn, date);
+            log.warn("【能耗明细】查询OEE时序数据为空或异常 - corpCode:{}, dtuSn:{}, date:{}", corpCode, dtuSn, date, e);
         }
         }
 
 
-        // 3. 构建OEE统计结果（含格式化时长和占比）
         List<Map<String, Object>> statusStats = new ArrayList<>();
         List<Map<String, Object>> statusStats = new ArrayList<>();
         for (Map.Entry<Integer, Long> entry : statusDurationMap.entrySet()) {
         for (Map.Entry<Integer, Long> entry : statusDurationMap.entrySet()) {
             long dur = entry.getValue();
             long dur = entry.getValue();
-            double percent = totalDuration > 0 ? BigDecimal.valueOf(dur * 100.0 / totalDuration)
-                    .setScale(2, RoundingMode.HALF_UP).doubleValue() : 0.0;
-
+            double percent = totalDuration > 0 ? BigDecimal.valueOf(dur * 100.0 / totalDuration).setScale(2, RoundingMode.HALF_UP).doubleValue() : 0.0;
             Map<String, Object> stat = new LinkedHashMap<>();
             Map<String, Object> stat = new LinkedHashMap<>();
             stat.put("status", entry.getKey());
             stat.put("status", entry.getKey());
             stat.put("durationSeconds", dur);
             stat.put("durationSeconds", dur);
@@ -216,43 +162,13 @@ public class EnergySearchService {
             stat.put("percent", percent);
             stat.put("percent", percent);
             statusStats.add(stat);
             statusStats.add(stat);
         }
         }
-
-        return Map.of(
-                "code", 200,
-                "msg", "请求成功",
-                "dtuSn", dtuSn,
-                "date", date,
-                "kwhData", Map.of(
-                        "list", kwhRawData,
-                        "totalKwh", totalKwh.setScale(2, RoundingMode.HALF_UP)
-                ),
-                "oeeData", Map.of(
-                        "list", oeeRawData,
-                        "totalDurationFormatted", formatDuration(totalDuration),
-                        "totalDurationSeconds", totalDuration,
-                        "statusStats", statusStats
-                )
-        );
+        return Map.of("code", 200, "msg", "请求成功", "dtuSn", dtuSn, "date", date, "kwhData", Map.of("list", kwhRawData, "totalKwh", totalKwh.setScale(2, RoundingMode.HALF_UP)),
+                "oeeData", Map.of("list", oeeRawData, "totalDurationFormatted", formatDuration(totalDuration), "totalDurationSeconds", totalDuration, "statusStats", statusStats));
     }
     }
 
 
-    /**
-     * 根据dtuSn查询指定设备的运行时长明细
-     * 核心数据为设备时用电量(eq_kwh)，其中包含每个状态的运行时长，需要统计
-     * type=1(时): 传startDate，获取指定日期的时用电量明细+各状态时长统计
-     * type=2(天): 传startDate和endDate，按日统计
-     * type=3(月): 查本年年初到现在，按月统计
-     *
-     * @param dtuSn     设备序列号
-     * @param type      类型：1-时，2-天，3-月
-     * @param startDate 开始日期 yyyy-MM-dd (type=1,2必填)
-     * @param endDate   结束日期 yyyy-MM-dd (type=2必填)
-     */
-    public Map<String, Object> queryEnergyRuntimeDetail(String dtuSn, String type,
-                                                        String startDate, String endDate) {
+    public Map<String, Object> queryEnergyRuntimeDetail(String corpCode, String dtuSn, String type, String startDate, String endDate) {
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         List<String> dateList = new ArrayList<>();
         List<String> dateList = new ArrayList<>();
-
-        // 根据type构建日期列表
         if ("1".equals(type)) {
         if ("1".equals(type)) {
             dateList.add(startDate);
             dateList.add(startDate);
         } else if ("2".equals(type)) {
         } else if ("2".equals(type)) {
@@ -278,41 +194,32 @@ public class EnergySearchService {
                 startCal.add(Calendar.DAY_OF_MONTH, 1);
                 startCal.add(Calendar.DAY_OF_MONTH, 1);
             }
             }
         }
         }
+        String eqKwhTableName = corpConfigService.getEqKwhTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
 
 
-        // 统计汇总数据
         long totalDurationAll = 0;
         long totalDurationAll = 0;
         BigDecimal totalKwhAll = BigDecimal.ZERO;
         BigDecimal totalKwhAll = BigDecimal.ZERO;
         Map<Integer, Long> statusDurationAllMap = initStatusMap();
         Map<Integer, Long> statusDurationAllMap = initStatusMap();
-
-        // type=1: 直接返回每日明细; type=2/3: 按日期聚合后返回
         List<Map<String, Object>> detailList = new ArrayList<>();
         List<Map<String, Object>> detailList = new ArrayList<>();
-        // type=3 按月聚合用
         Map<String, Map<String, Object>> monthAggMap = "3".equals(type) ? new LinkedHashMap<>() : null;
         Map<String, Map<String, Object>> monthAggMap = "3".equals(type) ? new LinkedHashMap<>() : null;
 
 
         for (String dateStr : dateList) {
         for (String dateStr : dateList) {
-            // 从eq_kwh表查询时用电量数据
             Object kwhRawData = Collections.emptyList();
             Object kwhRawData = Collections.emptyList();
             BigDecimal dayKwh = BigDecimal.ZERO;
             BigDecimal dayKwh = BigDecimal.ZERO;
             long dayTotalDuration = 0;
             long dayTotalDuration = 0;
             Map<Integer, Long> dayStatusDuration = initStatusMap();
             Map<Integer, Long> dayStatusDuration = initStatusMap();
-
             try {
             try {
-                String kwhSql = "SELECT description FROM " + eqKwhTableName
-                        + " WHERE corp_code = ? AND dtuSn = ? AND use_date = ?";
-                Map<String, Object> kwhRow = jdbcTemplate.queryForMap(kwhSql, energyCorpCode, dtuSn, dateStr + " 00:00:00");
+                String kwhSql = "SELECT description FROM " + eqKwhTableName + " WHERE corp_code = ? AND dtuSn = ? AND use_date = ?";
+                Map<String, Object> kwhRow = jt.queryForMap(kwhSql, corpCode, dtuSn, dateStr + " 00:00:00");
                 if (kwhRow != null && kwhRow.get("description") != null) {
                 if (kwhRow != null && kwhRow.get("description") != null) {
                     String desc = String.valueOf(kwhRow.get("description"));
                     String desc = String.valueOf(kwhRow.get("description"));
                     JSONArray dataArray = JSON.parseArray(desc);
                     JSONArray dataArray = JSON.parseArray(desc);
-
                     for (int i = 0; i < dataArray.size(); i++) {
                     for (int i = 0; i < dataArray.size(); i++) {
                         JSONObject item = dataArray.getJSONObject(i);
                         JSONObject item = dataArray.getJSONObject(i);
                         Double value = item.getDouble("value");
                         Double value = item.getDouble("value");
                         if (value != null) dayKwh = dayKwh.add(BigDecimal.valueOf(value));
                         if (value != null) dayKwh = dayKwh.add(BigDecimal.valueOf(value));
-
-                        // 从字段 0/1/2/3 统计各状态运行时长 + 格式化新字段
                         for (int statusKey = 0; statusKey <= 3; statusKey++) {
                         for (int statusKey = 0; statusKey <= 3; statusKey++) {
                             Long dur = item.getLong(String.valueOf(statusKey));
                             Long dur = item.getLong(String.valueOf(statusKey));
-                            item.put(statusKey + "Formatted", formatDuration(dur != null ? dur : 0L));
                             if (dur != null && dur > 0) {
                             if (dur != null && dur > 0) {
                                 dayTotalDuration += dur;
                                 dayTotalDuration += dur;
                                 totalDurationAll += dur;
                                 totalDurationAll += dur;
@@ -326,11 +233,9 @@ public class EnergySearchService {
             } catch (Exception ignored) {
             } catch (Exception ignored) {
             }
             }
             totalKwhAll = totalKwhAll.add(dayKwh);
             totalKwhAll = totalKwhAll.add(dayKwh);
-
             String periodKey = "3".equals(type) ? dateStr.substring(0, 7) : dateStr;
             String periodKey = "3".equals(type) ? dateStr.substring(0, 7) : dateStr;
 
 
             if ("1".equals(type)) {
             if ("1".equals(type)) {
-                // type=1(时): 返回原始kwhList + 当日统计
                 Map<String, Object> entry = new LinkedHashMap<>();
                 Map<String, Object> entry = new LinkedHashMap<>();
                 entry.put("date", periodKey);
                 entry.put("date", periodKey);
                 entry.put("kwhList", kwhRawData);
                 entry.put("kwhList", kwhRawData);
@@ -340,7 +245,6 @@ public class EnergySearchService {
                 entry.put("statusStats", buildStatusStats(dayStatusDuration, dayTotalDuration));
                 entry.put("statusStats", buildStatusStats(dayStatusDuration, dayTotalDuration));
                 detailList.add(entry);
                 detailList.add(entry);
             } else if ("2".equals(type)) {
             } else if ("2".equals(type)) {
-                // type=2(天): 返回每日汇总统计，不含kwhList
                 Map<String, Object> entry = new LinkedHashMap<>();
                 Map<String, Object> entry = new LinkedHashMap<>();
                 entry.put("date", periodKey);
                 entry.put("date", periodKey);
                 entry.put("totalKwh", dayKwh.setScale(2, RoundingMode.HALF_UP));
                 entry.put("totalKwh", dayKwh.setScale(2, RoundingMode.HALF_UP));
@@ -349,7 +253,6 @@ public class EnergySearchService {
                 entry.put("statusStats", buildStatusStats(dayStatusDuration, dayTotalDuration));
                 entry.put("statusStats", buildStatusStats(dayStatusDuration, dayTotalDuration));
                 detailList.add(entry);
                 detailList.add(entry);
             } else if ("3".equals(type)) {
             } else if ("3".equals(type)) {
-                // type=3(月): 按月聚合
                 monthAggMap.computeIfAbsent(periodKey, k -> {
                 monthAggMap.computeIfAbsent(periodKey, k -> {
                     Map<String, Object> m = new LinkedHashMap<>();
                     Map<String, Object> m = new LinkedHashMap<>();
                     m.put("date", k);
                     m.put("date", k);
@@ -361,24 +264,17 @@ public class EnergySearchService {
                 Map<String, Object> monthEntry = monthAggMap.get(periodKey);
                 Map<String, Object> monthEntry = monthAggMap.get(periodKey);
                 monthEntry.put("totalKwh", ((BigDecimal) monthEntry.get("totalKwh")).add(dayKwh));
                 monthEntry.put("totalKwh", ((BigDecimal) monthEntry.get("totalKwh")).add(dayKwh));
                 monthEntry.put("totalDurationSeconds", (Long) monthEntry.get("totalDurationSeconds") + dayTotalDuration);
                 monthEntry.put("totalDurationSeconds", (Long) monthEntry.get("totalDurationSeconds") + dayTotalDuration);
-                @SuppressWarnings("unchecked")
-                Map<Integer, Long> mStatusMap = (Map<Integer, Long>) monthEntry.get("statusDurationMap");
+                @SuppressWarnings("unchecked") Map<Integer, Long> mStatusMap = (Map<Integer, Long>) monthEntry.get("statusDurationMap");
                 for (int sk = 0; sk <= 3; sk++) {
                 for (int sk = 0; sk <= 3; sk++) {
-                    if (dayStatusDuration.get(sk) > 0) {
-                        mStatusMap.merge(sk, dayStatusDuration.get(sk), Long::sum);
-                    }
+                    if (dayStatusDuration.get(sk) > 0) mStatusMap.merge(sk, dayStatusDuration.get(sk), Long::sum);
                 }
                 }
             }
             }
         }
         }
-
-        // type=3 构建月度聚合结果
         if ("3".equals(type) && monthAggMap != null) {
         if ("3".equals(type) && monthAggMap != null) {
             for (Map.Entry<String, Map<String, Object>> me : monthAggMap.entrySet()) {
             for (Map.Entry<String, Map<String, Object>> me : monthAggMap.entrySet()) {
                 Map<String, Object> m = me.getValue();
                 Map<String, Object> m = me.getValue();
                 long mDur = (Long) m.get("totalDurationSeconds");
                 long mDur = (Long) m.get("totalDurationSeconds");
-                @SuppressWarnings("unchecked")
-                Map<Integer, Long> mStatusMap = (Map<Integer, Long>) m.get("statusDurationMap");
-
+                @SuppressWarnings("unchecked") Map<Integer, Long> mStatusMap = (Map<Integer, Long>) m.get("statusDurationMap");
                 Map<String, Object> entry = new LinkedHashMap<>();
                 Map<String, Object> entry = new LinkedHashMap<>();
                 entry.put("date", m.get("date"));
                 entry.put("date", m.get("date"));
                 entry.put("totalKwh", ((BigDecimal) m.get("totalKwh")).setScale(2, RoundingMode.HALF_UP));
                 entry.put("totalKwh", ((BigDecimal) m.get("totalKwh")).setScale(2, RoundingMode.HALF_UP));
@@ -388,58 +284,36 @@ public class EnergySearchService {
                 detailList.add(entry);
                 detailList.add(entry);
             }
             }
         }
         }
-
         List<Map<String, Object>> allStatusStats = buildStatusStats(statusDurationAllMap, totalDurationAll);
         List<Map<String, Object>> allStatusStats = buildStatusStats(statusDurationAllMap, totalDurationAll);
-
-        return Map.of(
-                "code", 200,
-                "msg", "请求成功",
-                "dtuSn", dtuSn,
-                "type", type,
-                "detailList", detailList,
-                "summary", Map.of(
-                        "totalDurationFormatted", formatDuration(totalDurationAll),
-                        "totalDurationSeconds", totalDurationAll,
-                        "totalKwh", totalKwhAll.setScale(2, RoundingMode.HALF_UP),
-                        "statusStats", allStatusStats
-                )
-        );
+        return Map.of("code", 200, "msg", "请求成功", "dtuSn", dtuSn, "type", type, "detailList", detailList,
+                "summary", Map.of("totalDurationFormatted", formatDuration(totalDurationAll), "totalDurationSeconds", totalDurationAll,
+                        "totalKwh", totalKwhAll.setScale(2, RoundingMode.HALF_UP), "statusStats", allStatusStats));
     }
     }
 
 
-    /**
-     * 查询能耗时序状态 - 分页查询
-     * 从e_run_dtl(OEE时序)表获取指定日期的设备时序数据，每页12条
-     * 同时计算每个设备的稼动率和总用电量(从eq_kwh表)
-     *
-     * @param date     查询日期 yyyy-MM-dd
-     * @param pageNo   页码，默认1
-     * @param pageSize 每页条数，默认12
-     */
-    public Map<String, Object> queryEnergyTimelineStatus(String date, Integer pageNo, Integer pageSize) {
-        // 先查OEE时序表获取有数据的设备列表
-        String countSql = "SELECT COUNT(DISTINCT r.dtuSn) FROM " + eRunDtlTableName + " r "
-                + " INNER JOIN " + energyTableName + " e ON e.dtuSn = r.dtuSn AND e.corp_code = r.corp_code "
-                + " WHERE r.corp_code = ? AND r.use_date = ?";
-        Long total = jdbcTemplate.queryForObject(countSql, Long.class, energyCorpCode, date + " 00:00:00");
+    public Map<String, Object> queryEnergyTimelineStatus(String corpCode, String date, Integer pageNo, Integer pageSize) {
+        String eRunDtlTableName = corpConfigService.getERunDtlTableName(corpCode);
+        String energyTableName = corpConfigService.getEnergyTableName(corpCode);
+        String eqKwhTableName = corpConfigService.getEqKwhTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
+
+        String countSql = "SELECT COUNT(DISTINCT r.dtuSn) FROM " + eRunDtlTableName + " r " +
+                "INNER JOIN " + energyTableName + " e ON e.dtuSn = r.dtuSn AND e.corp_code = r.corp_code WHERE r.corp_code = ? AND r.use_date = ?";
+        Long total = jt.queryForObject(countSql, Long.class, corpCode, date + " 00:00:00");
 
 
         int offset = (pageNo - 1) * pageSize;
         int offset = (pageNo - 1) * pageSize;
-        String querySql = "SELECT r.dtuSn, e.deviceName, r.runStatus1, r.runStatus2 FROM " + eRunDtlTableName + " r "
-                + " INNER JOIN " + energyTableName + " e ON e.dtuSn = r.dtuSn AND e.corp_code = r.corp_code "
-                + " WHERE r.corp_code = ? AND r.use_date = ? "
-                + " ORDER BY e.deviceName ASC LIMIT ?, ?";
-        List<Map<String, Object>> rows = jdbcTemplate.queryForList(querySql, energyCorpCode, date + " 00:00:00", offset, pageSize);
+        String querySql = "SELECT r.dtuSn, e.deviceName, r.runStatus1, r.runStatus2 FROM " + eRunDtlTableName + " r " +
+                "INNER JOIN " + energyTableName + " e ON e.dtuSn = r.dtuSn AND e.corp_code = r.corp_code WHERE r.corp_code = ? AND r.use_date = ? " +
+                "ORDER BY e.deviceName ASC LIMIT ?, ?";
+        List<Map<String, Object>> rows = jt.queryForList(querySql, corpCode, date + " 00:00:00", offset, pageSize);
 
 
         List<Map<String, Object>> list = new ArrayList<>();
         List<Map<String, Object>> list = new ArrayList<>();
         for (Map<String, Object> row : rows) {
         for (Map<String, Object> row : rows) {
             Map<String, Object> item = new LinkedHashMap<>();
             Map<String, Object> item = new LinkedHashMap<>();
             item.put("dtuSn", row.get("dtuSn"));
             item.put("dtuSn", row.get("dtuSn"));
             item.put("deviceName", row.get("deviceName"));
             item.put("deviceName", row.get("deviceName"));
-
-            // OEE时序数据（原始返回）
             Object oeeRawData = Collections.emptyList();
             Object oeeRawData = Collections.emptyList();
             long totalDuration = 0;
             long totalDuration = 0;
             long runDuration = 0;
             long runDuration = 0;
-
             String rs1 = row.get("runStatus1") != null ? String.valueOf(row.get("runStatus1")) : "";
             String rs1 = row.get("runStatus1") != null ? String.valueOf(row.get("runStatus1")) : "";
             String rs2 = row.get("runStatus2") != null ? String.valueOf(row.get("runStatus2")) : "";
             String rs2 = row.get("runStatus2") != null ? String.valueOf(row.get("runStatus2")) : "";
             if (StringUtils.hasText(rs1) || StringUtils.hasText(rs2)) {
             if (StringUtils.hasText(rs1) || StringUtils.hasText(rs2)) {
@@ -453,23 +327,20 @@ public class EnergySearchService {
                         Integer runStatus = jo.getInteger("runStatus");
                         Integer runStatus = jo.getInteger("runStatus");
                         if (duration != null && duration > 0 && runStatus != null) {
                         if (duration != null && duration > 0 && runStatus != null) {
                             totalDuration += duration;
                             totalDuration += duration;
-                            if (runStatus == 3) runDuration += duration; // 运行状态
+                            if (runStatus == 3) runDuration += duration;
                         }
                         }
                     }
                     }
                 } catch (Exception ignored) {
                 } catch (Exception ignored) {
                 }
                 }
             }
             }
-
             item.put("timelineList", oeeRawData);
             item.put("timelineList", oeeRawData);
             item.put("totalDurationFormatted", formatDuration(totalDuration));
             item.put("totalDurationFormatted", formatDuration(totalDuration));
             item.put("totalDurationSeconds", totalDuration);
             item.put("totalDurationSeconds", totalDuration);
 
 
-            // 从eq_kwh表获取用电量
             BigDecimal totalKwh = BigDecimal.ZERO;
             BigDecimal totalKwh = BigDecimal.ZERO;
             try {
             try {
-                String kwhSql = "SELECT description FROM " + eqKwhTableName
-                        + " WHERE corp_code = ? AND dtuSn = ? AND use_date = ?";
-                Map<String, Object> kwhRow = jdbcTemplate.queryForMap(kwhSql, energyCorpCode, row.get("dtuSn"), date + " 00:00:00");
+                String kwhSql = "SELECT description FROM " + eqKwhTableName + " WHERE corp_code = ? AND dtuSn = ? AND use_date = ?";
+                Map<String, Object> kwhRow = jt.queryForMap(kwhSql, corpCode, row.get("dtuSn"), date + " 00:00:00");
                 if (kwhRow != null && kwhRow.get("description") != null) {
                 if (kwhRow != null && kwhRow.get("description") != null) {
                     JSONArray dataArray = JSON.parseArray(String.valueOf(kwhRow.get("description")));
                     JSONArray dataArray = JSON.parseArray(String.valueOf(kwhRow.get("description")));
                     for (int i = 0; i < dataArray.size(); i++) {
                     for (int i = 0; i < dataArray.size(); i++) {
@@ -479,25 +350,12 @@ public class EnergySearchService {
                 }
                 }
             } catch (Exception ignored) {
             } catch (Exception ignored) {
             }
             }
-
             item.put("totalKwh", totalKwh.setScale(2, RoundingMode.HALF_UP));
             item.put("totalKwh", totalKwh.setScale(2, RoundingMode.HALF_UP));
-            // 稼动率 = 运行时长 / 总时长
-            double utilizationRate = totalDuration > 0
-                    ? BigDecimal.valueOf(runDuration * 100.0 / totalDuration).setScale(2, RoundingMode.HALF_UP).doubleValue()
-                    : 0.0;
+            double utilizationRate = totalDuration > 0 ? BigDecimal.valueOf(runDuration * 100.0 / totalDuration).setScale(2, RoundingMode.HALF_UP).doubleValue() : 0.0;
             item.put("utilizationRate", utilizationRate);
             item.put("utilizationRate", utilizationRate);
-
             list.add(item);
             list.add(item);
         }
         }
-
-        return Map.of(
-                "code", 200,
-                "msg", "请求成功",
-                "total", total != null ? total : 0,
-                "pageNo", pageNo,
-                "pageSize", pageSize,
-                "list", list
-        );
+        return Map.of("code", 200, "msg", "请求成功", "total", total != null ? total : 0, "pageNo", pageNo, "pageSize", pageSize, "list", list);
     }
     }
 
 
     private static Map<Integer, Long> initStatusMap() {
     private static Map<Integer, Long> initStatusMap() {
@@ -513,8 +371,7 @@ public class EnergySearchService {
         List<Map<String, Object>> list = new ArrayList<>();
         List<Map<String, Object>> list = new ArrayList<>();
         for (Map.Entry<Integer, Long> entry : statusMap.entrySet()) {
         for (Map.Entry<Integer, Long> entry : statusMap.entrySet()) {
             long dur = entry.getValue();
             long dur = entry.getValue();
-            double percent = totalDur > 0 ? BigDecimal.valueOf(dur * 100.0 / totalDur)
-                    .setScale(2, RoundingMode.HALF_UP).doubleValue() : 0.0;
+            double percent = totalDur > 0 ? BigDecimal.valueOf(dur * 100.0 / totalDur).setScale(2, RoundingMode.HALF_UP).doubleValue() : 0.0;
             Map<String, Object> stat = new LinkedHashMap<>();
             Map<String, Object> stat = new LinkedHashMap<>();
             stat.put("status", entry.getKey());
             stat.put("status", entry.getKey());
             stat.put("durationSeconds", dur);
             stat.put("durationSeconds", dur);
@@ -527,17 +384,10 @@ public class EnergySearchService {
 
 
     private static Object itemToMap(JSONArray dataArray) {
     private static Object itemToMap(JSONArray dataArray) {
         List<Object> list = new ArrayList<>();
         List<Object> list = new ArrayList<>();
-        for (int i = 0; i < dataArray.size(); i++) {
-            list.add(dataArray.getJSONObject(i));
-        }
+        for (int i = 0; i < dataArray.size(); i++) list.add(dataArray.getJSONObject(i));
         return list;
         return list;
     }
     }
 
 
-    /**
-     * 格式化时长为 xx时xx分xx秒 格式
-     * 时不为0则展示xx时xx分xx秒
-     * 时和分都为0则只展示xx秒
-     */
     private static String formatDuration(long totalSeconds) {
     private static String formatDuration(long totalSeconds) {
         long h = totalSeconds / 3600;
         long h = totalSeconds / 3600;
         long m = (totalSeconds % 3600) / 60;
         long m = (totalSeconds % 3600) / 60;
@@ -549,143 +399,79 @@ public class EnergySearchService {
         return sb.toString();
         return sb.toString();
     }
     }
 
 
-    /**
-     * 格式化时长为 xxx.xx 时
-     */
     private static String formatDurationToHours(long totalSeconds) {
     private static String formatDurationToHours(long totalSeconds) {
         double hours = totalSeconds / 3600.0;
         double hours = totalSeconds / 3600.0;
         return String.format("%.2f时", hours);
         return String.format("%.2f时", hours);
     }
     }
 
 
-    // ==================== eq_kwh 综合统计查询 ====================
+    // ==================== eq_kwh 综合统计 ====================
 
 
-    /**
-     * 查询 eq_kwh 表的综合统计数据
-     * 返回：
-     * 1. 所有设备的总的稼动率 + 每个状态的时间(xxx.xx时)
-     * 2. 当前设备的运行状态
-     * 3. 异常机台排名(待机+停机时间最长往下排, xx时xx分xx秒)
-     * 4. 每个设备统计时间内的总的0/1/2/3的时间(xx时xx分xx秒)
-     *
-     * @param startDate 开始日期 yyyy-MM-dd
-     * @param endDate   结束日期 yyyy-MM-dd
-     */
-    public Map<String, Object> queryEqKwhStatistics(String startDate, String endDate) {
-        log.info("========== [eq_kwh综合统计] startDate={}, endDate={} ==========", startDate, endDate);
-
-        if (!StringUtils.hasText(startDate) || !StringUtils.hasText(endDate)) {
-            return Map.of(
-                    "code", 400, "msg", "参数错误: startDate和endDate必填",
-                    "data", Map.of()
-            );
-        }
+    public Map<String, Object> queryEqKwhStatistics(String corpCode, String startDate, String endDate) {
+        log.info("========== [eq_kwh综合统计] corpCode={}, startDate={}, endDate={} ==========", corpCode, startDate, endDate);
+        if (!StringUtils.hasText(startDate) || !StringUtils.hasText(endDate))
+            return Map.of("code", 400, "msg", "参数错误: startDate和endDate必填", "data", Map.of());
 
 
-        // 1. 构建日期列表
         List<String> dateList = buildDateList(startDate, endDate);
         List<String> dateList = buildDateList(startDate, endDate);
-        if (dateList.isEmpty()) {
-            return buildEmptyEqKwhStats();
-        }
+        if (dateList.isEmpty()) return buildEmptyEqKwhStats();
         log.info("日期范围共 {} 天: {} ~ {}", dateList.size(), dateList.get(0), dateList.get(dateList.size() - 1));
         log.info("日期范围共 {} 天: {} ~ {}", dateList.size(), dateList.get(0), dateList.get(dateList.size() - 1));
 
 
-        // 2. 获取所有设备列表及名称
-        Map<String, String> deviceNameMap = queryAllEnergyDeviceNames();
-
-        // 3. 从 eq_kwh 表批量查询所有设备在指定日期范围内的数据
-        List<Map<String, Object>> allRawData = queryEqKwhBatch(dateList);
+        Map<String, String> deviceNameMap = queryAllEnergyDeviceNames(corpCode);
+        List<Map<String, Object>> allRawData = queryEqKwhBatch(corpCode, dateList);
         log.info("eq_kwh 批量查询返回 {} 条原始记录", allRawData.size());
         log.info("eq_kwh 批量查询返回 {} 条原始记录", allRawData.size());
 
 
-        // 4. 按 dtuSn 分组聚合数据，计算每个设备的各状态时长
         Map<String, DeviceStatResult> deviceStatMap = aggregateByDevice(allRawData, deviceNameMap);
         Map<String, DeviceStatResult> deviceStatMap = aggregateByDevice(allRawData, deviceNameMap);
-
-        // 确保所有设备都在结果中（无数据的设为0）
         for (String sn : deviceNameMap.keySet()) {
         for (String sn : deviceNameMap.keySet()) {
-            if (!deviceStatMap.containsKey(sn)) {
+            if (!deviceStatMap.containsKey(sn))
                 deviceStatMap.put(sn, new DeviceStatResult(sn, deviceNameMap.getOrDefault(sn, "")));
                 deviceStatMap.put(sn, new DeviceStatResult(sn, deviceNameMap.getOrDefault(sn, "")));
-            }
         }
         }
-
-        // 5. 计算全局汇总
-        return buildEqKwhStatisticsResult(deviceStatMap, deviceNameMap);
+        return buildEqKwhStatisticsResult(corpCode, deviceStatMap, deviceNameMap);
     }
     }
 
 
-    /**
-     * 设备统计内部结构
-     */
     static class DeviceStatResult {
     static class DeviceStatResult {
         String dtuSn;
         String dtuSn;
         String deviceName;
         String deviceName;
-        long status0; // 离线时长(秒)
-        long status1; // 停机时长(秒)
-        long status2; // 待机时长(秒)
-        long status3; // 运行时长(秒)
-        double totalKwh; // 总用电量
+        long status0, status1, status2, status3;
+        double totalKwh;
 
 
         DeviceStatResult(String dtuSn, String deviceName) {
         DeviceStatResult(String dtuSn, String deviceName) {
             this.dtuSn = dtuSn;
             this.dtuSn = dtuSn;
             this.deviceName = deviceName;
             this.deviceName = deviceName;
         }
         }
 
 
-        /**
-         * 总时长(秒)
-         */
         long totalDuration() {
         long totalDuration() {
             return status0 + status1 + status2 + status3;
             return status0 + status1 + status2 + status3;
         }
         }
 
 
-        /**
-         * 异常时长 = 停机 + 待机
-         */
         long abnormalDuration() {
         long abnormalDuration() {
             return status1 + status2;
             return status1 + status2;
         }
         }
 
 
-        /**
-         * 稼动分母 = 停机 + 待机 + 运行 (排除离线)
-         */
         long activeDuration() {
         long activeDuration() {
             return status1 + status2 + status3;
             return status1 + status2 + status3;
         }
         }
     }
     }
 
 
-    /**
-     * 构建空结果
-     */
     private Map<String, Object> buildEmptyEqKwhStats() {
     private Map<String, Object> buildEmptyEqKwhStats() {
-        return Map.of(
-                "code", 200, "msg", "请求成功", "data",
-                Map.of(
-                        "summary", Map.of(
-                                "availabilityRate", "0.00%",
-                                "totalStatusDuration", Map.of(
-                                        "status0", Map.of("durationFormatted", "0时0分0秒", "durationSeconds", 0L, "durationHours", "0.00时"),
-                                        "status1", Map.of("durationFormatted", "0时0分0秒", "durationSeconds", 0L, "durationHours", "0.00时"),
-                                        "status2", Map.of("durationFormatted", "0时0分0秒", "durationSeconds", 0L, "durationHours", "0.00时"),
-                                        "status3", Map.of("durationFormatted", "0时0分0秒", "durationSeconds", 0L, "durationHours", "0.00时")
-                                )
-                        ),
+        return Map.of("code", 200, "msg", "请求成功", "data", Map.of(
+                "summary", Map.of("availabilityRate", "0.00%", "totalStatusDuration",
+                        Map.of("status0", Map.of("durationFormatted", "0时0分0秒", "durationSeconds", 0L, "durationHours", "0.00时"),
+                                "status1", Map.of("durationFormatted", "0时0分0秒", "durationSeconds", 0L, "durationHours", "0.00时"),
+                                "status2", Map.of("durationFormatted", "0时0分0秒", "durationSeconds", 0L, "durationHours", "0.00时"),
+                                "status3", Map.of("durationFormatted", "0时0分0秒", "durationSeconds", 0L, "durationHours", "0.00时")),
                         "currentStatus", Map.of("0", 0, "1", 0, "2", 0, "3", 0),
                         "currentStatus", Map.of("0", 0, "1", 0, "2", 0, "3", 0),
-                        "abnormalRanking", List.of(),
-                        "deviceList", List.of()
-                )
-        );
+                        "abnormalRanking", List.of(), "deviceList", List.of())));
     }
     }
 
 
-    /**
-     * 获取能耗设备表所有dtuSn及名称
-     */
-    private Map<String, String> queryAllEnergyDeviceNames() {
+    private Map<String, String> queryAllEnergyDeviceNames(String corpCode) {
+        String energyTableName = corpConfigService.getEnergyTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
         String sql = "SELECT dtuSn, deviceName FROM " + energyTableName + " WHERE corp_code = ? ORDER BY dtuSn";
         String sql = "SELECT dtuSn, deviceName FROM " + energyTableName + " WHERE corp_code = ? ORDER BY dtuSn";
-        List<Map<String, Object>> rows = jdbcTemplate.queryForList(sql, energyCorpCode);
+        List<Map<String, Object>> rows = jt.queryForList(sql, corpCode);
         Map<String, String> result = new LinkedHashMap<>(rows.size());
         Map<String, String> result = new LinkedHashMap<>(rows.size());
-        for (Map<String, Object> row : rows) {
-            result.put((String) row.get("dtuSn"), (String) row.get("deviceName"));
-        }
+        for (Map<String, Object> row : rows) result.put((String) row.get("dtuSn"), (String) row.get("deviceName"));
         return result;
         return result;
     }
     }
 
 
-    /**
-     * 构建连续日期列表
-     */
     private List<String> buildDateList(String startDate, String endDate) {
     private List<String> buildDateList(String startDate, String endDate) {
         List<String> result = new ArrayList<>();
         List<String> result = new ArrayList<>();
         try {
         try {
@@ -704,66 +490,43 @@ public class EnergySearchService {
         return result;
         return result;
     }
     }
 
 
-    /**
-     * 从 eq_kwh 表批量查询指定日期范围的所有记录
-     */
-    private List<Map<String, Object>> queryEqKwhBatch(List<String> dateList) {
+    private List<Map<String, Object>> queryEqKwhBatch(String corpCode, List<String> dateList) {
         if (dateList.isEmpty()) return Collections.emptyList();
         if (dateList.isEmpty()) return Collections.emptyList();
-
-        StringBuilder sql = new StringBuilder(
-                "SELECT dtuSn, use_date, description FROM " + eqKwhTableName +
-                        " WHERE corp_code = ? AND use_date IN (");
+        String eqKwhTableName = corpConfigService.getEqKwhTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
+        StringBuilder sql = new StringBuilder("SELECT dtuSn, use_date, description FROM " + eqKwhTableName + " WHERE corp_code = ? AND use_date IN (");
         List<Object> params = new ArrayList<>();
         List<Object> params = new ArrayList<>();
-        params.add(energyCorpCode);
-
+        params.add(corpCode);
         for (String d : dateList) {
         for (String d : dateList) {
             sql.append("?,");
             sql.append("?,");
             params.add(d + "T00:00:00");
             params.add(d + "T00:00:00");
         }
         }
-        sql.deleteCharAt(sql.length() - 1).append(")");
-        sql.append(" ORDER BY dtuSn, use_date");
-
-        return jdbcTemplate.queryForList(sql.toString(), params.toArray());
+        sql.deleteCharAt(sql.length() - 1).append(")").append(" ORDER BY dtuSn, use_date");
+        return jt.queryForList(sql.toString(), params.toArray());
     }
     }
 
 
-    /**
-     * 按 dtuSn 分组聚合各状态时长
-     */
-    private Map<String, DeviceStatResult> aggregateByDevice(List<Map<String, Object>> rawData,
-                                                            Map<String, String> deviceNameMap) {
+    private Map<String, DeviceStatResult> aggregateByDevice(List<Map<String, Object>> rawData, Map<String, String> deviceNameMap) {
         Map<String, DeviceStatResult> resultMap = new LinkedHashMap<>();
         Map<String, DeviceStatResult> resultMap = new LinkedHashMap<>();
-
         for (Map<String, Object> row : rawData) {
         for (Map<String, Object> row : rawData) {
             String sn = (String) row.get("dtuSn");
             String sn = (String) row.get("dtuSn");
             String desc = row.get("description") != null ? String.valueOf(row.get("description")) : "";
             String desc = row.get("description") != null ? String.valueOf(row.get("description")) : "";
-
-            DeviceStatResult dsr = resultMap.computeIfAbsent(sn,
-                    k -> new DeviceStatResult(k, deviceNameMap.getOrDefault(k, "")));
-
+            DeviceStatResult dsr = resultMap.computeIfAbsent(sn, k -> new DeviceStatResult(k, deviceNameMap.getOrDefault(k, "")));
             if (!StringUtils.hasText(desc)) continue;
             if (!StringUtils.hasText(desc)) continue;
-
             try {
             try {
                 JSONArray dataArray = JSON.parseArray(desc);
                 JSONArray dataArray = JSON.parseArray(desc);
                 if (dataArray == null) continue;
                 if (dataArray == null) continue;
-
                 for (int i = 0; i < dataArray.size(); i++) {
                 for (int i = 0; i < dataArray.size(); i++) {
                     JSONObject item = dataArray.getJSONObject(i);
                     JSONObject item = dataArray.getJSONObject(i);
                     if (item == null) continue;
                     if (item == null) continue;
-
-                    // 用电量
                     Double value = item.getDouble("value");
                     Double value = item.getDouble("value");
                     if (value != null) dsr.totalKwh += value;
                     if (value != null) dsr.totalKwh += value;
-
-                    // 各状态时长: 0-离线, 1-停机, 2-待机, 3-运行
                     for (int sk = 0; sk <= 3; sk++) {
                     for (int sk = 0; sk <= 3; sk++) {
                         Long dur = item.getLong(String.valueOf(sk));
                         Long dur = item.getLong(String.valueOf(sk));
-                        if (dur != null && dur > 0) {
-                            switch (sk) {
-                                case 0 -> dsr.status0 += dur;
-                                case 1 -> dsr.status1 += dur;
-                                case 2 -> dsr.status2 += dur;
-                                case 3 -> dsr.status3 += dur;
-                            }
+                        if (dur != null && dur > 0) switch (sk) {
+                            case 0 -> dsr.status0 += dur;
+                            case 1 -> dsr.status1 += dur;
+                            case 2 -> dsr.status2 += dur;
+                            case 3 -> dsr.status3 += dur;
                         }
                         }
                     }
                     }
                 }
                 }
@@ -771,135 +534,57 @@ public class EnergySearchService {
                 log.warn("解析eq_kwh description异常 - dtuSn:{}", sn, e);
                 log.warn("解析eq_kwh description异常 - dtuSn:{}", sn, e);
             }
             }
         }
         }
-
         return resultMap;
         return resultMap;
     }
     }
 
 
-    /**
-     * 构建最终统计结果
-     */
-    private Map<String, Object> buildEqKwhStatisticsResult(Map<String, DeviceStatResult> deviceStatMap,
-                                                           Map<String, String> deviceNameMap) {
-        // ---- 全局汇总 ----
+    private Map<String, Object> buildEqKwhStatisticsResult(String corpCode, Map<String, DeviceStatResult> deviceStatMap, Map<String, String> deviceNameMap) {
         long totalS0 = 0, totalS1 = 0, totalS2 = 0, totalS3 = 0;
         long totalS0 = 0, totalS1 = 0, totalS2 = 0, totalS3 = 0;
         double totalKwhSum = 0;
         double totalKwhSum = 0;
-
-        // ---- 设备详情列表 ----
         List<Map<String, Object>> deviceList = new ArrayList<>(deviceStatMap.size());
         List<Map<String, Object>> deviceList = new ArrayList<>(deviceStatMap.size());
-
         for (Map.Entry<String, DeviceStatResult> entry : deviceStatMap.entrySet()) {
         for (Map.Entry<String, DeviceStatResult> entry : deviceStatMap.entrySet()) {
             DeviceStatResult dsr = entry.getValue();
             DeviceStatResult dsr = entry.getValue();
-
             totalS0 += dsr.status0;
             totalS0 += dsr.status0;
             totalS1 += dsr.status1;
             totalS1 += dsr.status1;
             totalS2 += dsr.status2;
             totalS2 += dsr.status2;
             totalS3 += dsr.status3;
             totalS3 += dsr.status3;
             totalKwhSum += dsr.totalKwh;
             totalKwhSum += dsr.totalKwh;
-
-            // 单设备稼动率 = 运行 / (停机+待机+运行)
             long active = dsr.activeDuration();
             long active = dsr.activeDuration();
             double devRate = active > 0 ? Math.round(dsr.status3 * 10000.0 / active) / 100.0 : 0.0;
             double devRate = active > 0 ? Math.round(dsr.status3 * 10000.0 / active) / 100.0 : 0.0;
-
             Map<String, Object> devItem = new LinkedHashMap<>();
             Map<String, Object> devItem = new LinkedHashMap<>();
             devItem.put("dtuSn", dsr.dtuSn);
             devItem.put("dtuSn", dsr.dtuSn);
             devItem.put("deviceName", dsr.deviceName);
             devItem.put("deviceName", dsr.deviceName);
-            // 各状态时长 - 格式化为 xx时xx分xx秒
-            devItem.put("status0", Map.of(
-                    "durationFormatted", formatDuration(dsr.status0),
-                    "durationSeconds", dsr.status0,
-                    "durationHours", formatDurationToHours(dsr.status0)
-            ));
-            devItem.put("status1", Map.of(
-                    "durationFormatted", formatDuration(dsr.status1),
-                    "durationSeconds", dsr.status1,
-                    "durationHours", formatDurationToHours(dsr.status1)
-            ));
-            devItem.put("status2", Map.of(
-                    "durationFormatted", formatDuration(dsr.status2),
-                    "durationSeconds", dsr.status2,
-                    "durationHours", formatDurationToHours(dsr.status2)
-            ));
-            devItem.put("status3", Map.of(
-                    "durationFormatted", formatDuration(dsr.status3),
-                    "durationSeconds", dsr.status3,
-                    "durationHours", formatDurationToHours(dsr.status3)
-            ));
+            devItem.put("status0", Map.of("durationFormatted", formatDuration(dsr.status0), "durationSeconds", dsr.status0, "durationHours", formatDurationToHours(dsr.status0)));
+            devItem.put("status1", Map.of("durationFormatted", formatDuration(dsr.status1), "durationSeconds", dsr.status1, "durationHours", formatDurationToHours(dsr.status1)));
+            devItem.put("status2", Map.of("durationFormatted", formatDuration(dsr.status2), "durationSeconds", dsr.status2, "durationHours", formatDurationToHours(dsr.status2)));
+            devItem.put("status3", Map.of("durationFormatted", formatDuration(dsr.status3), "durationSeconds", dsr.status3, "durationHours", formatDurationToHours(dsr.status3)));
             devItem.put("totalDurationFormatted", formatDuration(dsr.totalDuration()));
             devItem.put("totalDurationFormatted", formatDuration(dsr.totalDuration()));
             devItem.put("totalDurationSeconds", dsr.totalDuration());
             devItem.put("totalDurationSeconds", dsr.totalDuration());
             devItem.put("totalDurationHours", formatDurationToHours(dsr.totalDuration()));
             devItem.put("totalDurationHours", formatDurationToHours(dsr.totalDuration()));
             devItem.put("totalKwh", Math.round(dsr.totalKwh * 100.0) / 100.0);
             devItem.put("totalKwh", Math.round(dsr.totalKwh * 100.0) / 100.0);
             devItem.put("availabilityRate", String.format("%.2f%%", devRate));
             devItem.put("availabilityRate", String.format("%.2f%%", devRate));
-            devItem.put("availabilityRateValue", devRate);
-            // 异常时长用于排序(内部字段，后面移除)
             devItem.put("_abnormalDur", dsr.abnormalDuration());
             devItem.put("_abnormalDur", dsr.abnormalDuration());
-
             deviceList.add(devItem);
             deviceList.add(devItem);
         }
         }
-
-        // ---- ① 总稼动率 ----
         long totalActive = totalS1 + totalS2 + totalS3;
         long totalActive = totalS1 + totalS2 + totalS3;
-        double overallAvailabilityRate = totalActive > 0
-                ? Math.round(totalS3 * 10000.0 / totalActive) / 100.0 : 0.0;
-
-        // ---- ② 当前设备运行状态（从energy表查） ----
-        Map<String, Integer> currentStatus = queryCurrentRunStatus();
-
-        // ---- ③ 异常机台排名(按 停机+待机 降序) ----
-        deviceList.sort((a, b) -> Long.compare(
-                ((Number) b.get("_abnormalDur")).longValue(),
-                ((Number) a.get("_abnormalDur")).longValue()
-        ));
-        // 移除辅助字段
-        for (Map<String, Object> d : deviceList) {
-            d.remove("_abnormalDur");
-        }
-
-        return Map.of(
-                "code", 200, "msg", "请求成功", "data",
-                Map.of(
-                        "summary", Map.of(
-                                "availabilityRate", String.format("%.2f%%", overallAvailabilityRate),
-                                "availabilityRateValue", overallAvailabilityRate,
-                                "totalDevices", deviceNameMap.size(),
-                                "totalKwh", Math.round(totalKwhSum * 100.0) / 100.0,
-                                "totalStatusDuration", Map.of(
-                                        "status0", Map.of(
-                                                "durationFormatted", formatDuration(totalS0),
-                                                "durationSeconds", totalS0,
-                                                "durationHours", formatDurationToHours(totalS0)
-                                        ),
-                                        "status1", Map.of(
-                                                "durationFormatted", formatDuration(totalS1),
-                                                "durationSeconds", totalS1,
-                                                "durationHours", formatDurationToHours(totalS1)
-                                        ),
-                                        "status2", Map.of(
-                                                "durationFormatted", formatDuration(totalS2),
-                                                "durationSeconds", totalS2,
-                                                "durationHours", formatDurationToHours(totalS2)
-                                        ),
-                                        "status3", Map.of(
-                                                "durationFormatted", formatDuration(totalS3),
-                                                "durationSeconds", totalS3,
-                                                "durationHours", formatDurationToHours(totalS3)
-                                        )
-                                )
-                        ),
-                        "currentStatus", currentStatus,
-                        "abnormalRanking", deviceList,
-                        "deviceList", deviceList
-                )
-        );
+        double overallAvailabilityRate = totalActive > 0 ? Math.round(totalS3 * 10000.0 / totalActive) / 100.0 : 0.0;
+        Map<String, Integer> currentStatus = queryCurrentRunStatus(corpCode);
+        deviceList.sort((a, b) -> Long.compare(((Number) b.get("_abnormalDur")).longValue(), ((Number) a.get("_abnormalDur")).longValue()));
+        for (Map<String, Object> d : deviceList) d.remove("_abnormalDur");
+        return Map.of("code", 200, "msg", "请求成功", "data", Map.of(
+                "summary", Map.of("availabilityRate", String.format("%.2f%%", overallAvailabilityRate), "availabilityRateValue", overallAvailabilityRate,
+                        "totalDevices", deviceNameMap.size(), "totalKwh", Math.round(totalKwhSum * 100.0) / 100.0,
+                        "totalStatusDuration", Map.of("status0", Map.of("durationFormatted", formatDuration(totalS0), "durationSeconds", totalS0, "durationHours", formatDurationToHours(totalS0)),
+                                "status1", Map.of("durationFormatted", formatDuration(totalS1), "durationSeconds", totalS1, "durationHours", formatDurationToHours(totalS1)),
+                                "status2", Map.of("durationFormatted", formatDuration(totalS2), "durationSeconds", totalS2, "durationHours", formatDurationToHours(totalS2)),
+                                "status3", Map.of("durationFormatted", formatDuration(totalS3), "durationSeconds", totalS3, "durationHours", formatDurationToHours(totalS3))),
+                        "currentStatus", currentStatus, "abnormalRanking", deviceList, "deviceList", deviceList)));
     }
     }
 
 
-    /**
-     * 查询当前设备运行状态分布(从energy表) runStatus: 0-离线, 1-停机, 2-待机, 3-运行
-     */
-    private Map<String, Integer> queryCurrentRunStatus() {
-        String sql = "SELECT runStatus, COUNT(*) as cnt FROM " + energyTableName +
-                " WHERE corp_code = ? GROUP BY runStatus";
-        List<Map<String, Object>> rows = jdbcTemplate.queryForList(sql, energyCorpCode);
-
+    private Map<String, Integer> queryCurrentRunStatus(String corpCode) {
+        String energyTableName = corpConfigService.getEnergyTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
+        String sql = "SELECT runStatus, COUNT(*) as cnt FROM " + energyTableName + " WHERE corp_code = ? GROUP BY runStatus";
+        List<Map<String, Object>> rows = jt.queryForList(sql, corpCode);
         int s0 = 0, s1 = 0, s2 = 0, s3 = 0;
         int s0 = 0, s1 = 0, s2 = 0, s3 = 0;
         for (Map<String, Object> row : rows) {
         for (Map<String, Object> row : rows) {
             String key = String.valueOf(row.get("runStatus"));
             String key = String.valueOf(row.get("runStatus"));
@@ -914,46 +599,22 @@ public class EnergySearchService {
         return Map.of("0", s0, "1", s1, "2", s2, "3", s3);
         return Map.of("0", s0, "1", s1, "2", s2, "3", s3);
     }
     }
 
 
-    // ==================== eq_kwh 多设备时/日/月查询 ====================
-
-    /**
-     * 查询 eq_kwh 表的多设备能耗数据(按 时/日/月 聚合)
-     * <p>
-     * type=1 (时): 只需传 startDate，返回该日所有设备的原始用电量明细(kwhList)
-     * type=2 (日):
-     * - 若传了 startDate+endDate: 按此范围每日统计每台设备能耗
-     * - 若只传 startDate: 自动补全为当月的第1天~最后一天
-     * type=3 (月): 自动取本年1月~当前月，按月统计每台设备能耗
-     *
-     * @param type      查询类型: 1-时, 2-日, 3-月
-     * @param startDate 开始日期 yyyy-MM-dd (type=1,2必填; type=3可选)
-     * @param endDate   结束日期 yyyy-MM-dd (type=2可选)
-     */
-    public Map<String, Object> queryEqKwhByType(String type, String startDate, String endDate) {
-        log.info("========== [eq_kwh多设备查询] type={}, startDate={}, endDate={} ==========", type, startDate, endDate);
+    // ==================== eq_kwh 多设备查询 ====================
 
 
+    public Map<String, Object> queryEqKwhByType(String corpCode, String type, String startDate, String endDate) {
+        log.info("========== [eq_kwh多设备查询] corpCode={}, type={}, startDate={}, endDate={} ==========", corpCode, type, startDate, endDate);
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
         List<String> dateList = new ArrayList<>();
         List<String> dateList = new ArrayList<>();
-
-        // 根据type构建日期列表 + 实际起止日期
         String actualStart;
         String actualStart;
         String actualEnd;
         String actualEnd;
-
         if ("1".equals(type)) {
         if ("1".equals(type)) {
-            // type=1: 单日查询，直接返回原始kwh数据
-            if (!StringUtils.hasText(startDate)) {
-                return Map.of("code", 400, "msg", "参数错误: type=1时startDate必填");
-            }
+            if (!StringUtils.hasText(startDate)) return Map.of("code", 400, "msg", "参数错误: type=1时startDate必填");
             dateList.add(startDate);
             dateList.add(startDate);
             actualStart = startDate;
             actualStart = startDate;
             actualEnd = startDate;
             actualEnd = startDate;
         } else if ("2".equals(type)) {
         } else if ("2".equals(type)) {
-            // type=2: 按日统计
-            if (!StringUtils.hasText(startDate)) {
-                return Map.of("code", 400, "msg", "参数错误: type=2时startDate必填");
-            }
+            if (!StringUtils.hasText(startDate)) return Map.of("code", 400, "msg", "参数错误: type=2时startDate必填");
             if (StringUtils.hasText(endDate)) {
             if (StringUtils.hasText(endDate)) {
-                // 有结束日期，直接用传入范围
                 try {
                 try {
                     Date start = sdf.parse(startDate);
                     Date start = sdf.parse(startDate);
                     Date end = sdf.parse(endDate);
                     Date end = sdf.parse(endDate);
@@ -969,19 +630,17 @@ public class EnergySearchService {
                     return Map.of("code", 400, "msg", "日期格式错误: " + startDate + " ~ " + endDate);
                     return Map.of("code", 400, "msg", "日期格式错误: " + startDate + " ~ " + endDate);
                 }
                 }
             } else {
             } else {
-                // 只有开始日期 -> 自动取所在月的1号~最后一天
                 try {
                 try {
                     Date startD = sdf.parse(startDate);
                     Date startD = sdf.parse(startDate);
                     Calendar cal = Calendar.getInstance();
                     Calendar cal = Calendar.getInstance();
                     cal.setTime(startD);
                     cal.setTime(startD);
-                    cal.set(Calendar.DAY_OF_MONTH, 1);       // 月初
+                    cal.set(Calendar.DAY_OF_MONTH, 1);
                     actualStart = sdf.format(cal.getTime());
                     actualStart = sdf.format(cal.getTime());
-                    cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH)); // 月末
+                    cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
                     actualEnd = sdf.format(cal.getTime());
                     actualEnd = sdf.format(cal.getTime());
-
                     Calendar cur = Calendar.getInstance();
                     Calendar cur = Calendar.getInstance();
                     cur.setTime(sdf.parse(actualStart));
                     cur.setTime(sdf.parse(actualStart));
-                    while (!cur.after(cal)) { // cur <= actualEnd
+                    while (!cur.after(cal)) {
                         dateList.add(sdf.format(cur.getTime()));
                         dateList.add(sdf.format(cur.getTime()));
                         cur.add(Calendar.DAY_OF_MONTH, 1);
                         cur.add(Calendar.DAY_OF_MONTH, 1);
                     }
                     }
@@ -990,9 +649,7 @@ public class EnergySearchService {
                 }
                 }
             }
             }
         } else if ("3".equals(type)) {
         } else if ("3".equals(type)) {
-            // type=3: 按月统计
             if (StringUtils.hasText(startDate) && StringUtils.hasText(endDate)) {
             if (StringUtils.hasText(startDate) && StringUtils.hasText(endDate)) {
-                // 有起止日期：按传入范围按月聚合
                 try {
                 try {
                     Date start = sdf.parse(startDate);
                     Date start = sdf.parse(startDate);
                     Date end = sdf.parse(endDate);
                     Date end = sdf.parse(endDate);
@@ -1008,14 +665,12 @@ public class EnergySearchService {
                     return Map.of("code", 400, "msg", "日期格式错误: " + startDate + " ~ " + endDate);
                     return Map.of("code", 400, "msg", "日期格式错误: " + startDate + " ~ " + endDate);
                 }
                 }
             } else {
             } else {
-                // 无日期：默认本年1月1日 ~ 今天
                 Calendar now = Calendar.getInstance();
                 Calendar now = Calendar.getInstance();
                 int year = now.get(Calendar.YEAR);
                 int year = now.get(Calendar.YEAR);
                 Calendar startCal = Calendar.getInstance();
                 Calendar startCal = Calendar.getInstance();
                 startCal.set(year, Calendar.JANUARY, 1);
                 startCal.set(year, Calendar.JANUARY, 1);
                 actualStart = sdf.format(startCal.getTime());
                 actualStart = sdf.format(startCal.getTime());
                 actualEnd = sdf.format(now.getTime());
                 actualEnd = sdf.format(now.getTime());
-
                 Calendar cur = Calendar.getInstance();
                 Calendar cur = Calendar.getInstance();
                 cur.setTime(startCal.getTime());
                 cur.setTime(startCal.getTime());
                 while (!cur.getTime().after(now.getTime())) {
                 while (!cur.getTime().after(now.getTime())) {
@@ -1026,28 +681,13 @@ public class EnergySearchService {
         } else {
         } else {
             return Map.of("code", 400, "msg", "参数错误: type只支持1/2/3");
             return Map.of("code", 400, "msg", "参数错误: type只支持1/2/3");
         }
         }
-
         log.info("实际日期范围: {} ~ {}, 共{}天", actualStart, actualEnd, dateList.size());
         log.info("实际日期范围: {} ~ {}, 共{}天", actualStart, actualEnd, dateList.size());
-
-        // 获取所有设备列表及名称
-        Map<String, String> deviceNameMap = queryAllEnergyDeviceNames();
-
-        // 从 eq_kwh 批量查询所有记录
-        List<Map<String, Object>> allRawData = queryEqKwhBatch(dateList);
-        log.info("eq_kwh 批量查询返回 {} 条原始记录", allRawData.size());
-
-        // 构建结果
-        return buildEqKwhByTypeResult(type, dateList, allRawData, deviceNameMap, actualStart, actualEnd);
+        Map<String, String> deviceNameMap = queryAllEnergyDeviceNames(corpCode);
+        List<Map<String, Object>> allRawData = queryEqKwhBatch(corpCode, dateList);
+        return buildEqKwhByTypeResult(corpCode, type, dateList, allRawData, deviceNameMap, actualStart, actualEnd);
     }
     }
 
 
-    /**
-     * 构建 type=1/2/3 的多设备查询结果
-     */
-    private Map<String, Object> buildEqKwhByTypeResult(String type, List<String> dateList,
-                                                       List<Map<String, Object>> allRawData,
-                                                       Map<String, String> deviceNameMap,
-                                                       String actualStart, String actualEnd) {
-        // 按 dtuSn+日期 建立快速查找Map: key="dtuSn|yyyy-MM-dd" -> JSONArray(kwh原始数据)
+    private Map<String, Object> buildEqKwhByTypeResult(String corpCode, String type, List<String> dateList, List<Map<String, Object>> allRawData, Map<String, String> deviceNameMap, String actualStart, String actualEnd) {
         Map<String, Object> rawDataMap = new LinkedHashMap<>();
         Map<String, Object> rawDataMap = new LinkedHashMap<>();
         for (Map<String, Object> row : allRawData) {
         for (Map<String, Object> row : allRawData) {
             String sn = (String) row.get("dtuSn");
             String sn = (String) row.get("dtuSn");
@@ -1055,56 +695,32 @@ public class EnergySearchService {
             String desc = row.get("description") != null ? String.valueOf(row.get("description")) : "";
             String desc = row.get("description") != null ? String.valueOf(row.get("description")) : "";
             if (StringUtils.hasText(desc)) {
             if (StringUtils.hasText(desc)) {
                 try {
                 try {
-                    // use_date 可能是 "2026-05-21T00:00:00" 或 "2026-05-21 00:00:00"，统一截取前10位作为纯日期key
                     String dateKey = ud.length() > 10 ? ud.substring(0, 10) : ud;
                     String dateKey = ud.length() > 10 ? ud.substring(0, 10) : ud;
                     rawDataMap.put(sn + "|" + dateKey, JSON.parseArray(desc));
                     rawDataMap.put(sn + "|" + dateKey, JSON.parseArray(desc));
                 } catch (Exception ignored) {
                 } catch (Exception ignored) {
                 }
                 }
             }
             }
         }
         }
-
-        // ---- type=1: 返回所有设备的原始kwh明细 ----
-        if ("1".equals(type)) {
-            return buildType1Result(dateList.get(0), rawDataMap, deviceNameMap);
-        }
-
-        // ---- type=2: 按日统计 ----
-        if ("2".equals(type)) {
-            return buildType2Result(dateList, rawDataMap, deviceNameMap, actualStart, actualEnd);
-        }
-
-        // ---- type=3: 按月统计 ----
-        if ("3".equals(type)) {
-            return buildType3Result(dateList, rawDataMap, deviceNameMap, actualStart, actualEnd);
-        }
-
+        if ("1".equals(type)) return buildType1Result(dateList.get(0), rawDataMap, deviceNameMap);
+        if ("2".equals(type)) return buildType2Result(dateList, rawDataMap, deviceNameMap, actualStart, actualEnd);
+        if ("3".equals(type)) return buildType3Result(dateList, rawDataMap, deviceNameMap, actualStart, actualEnd);
         return Map.of("code", 500, "msg", "未知type");
         return Map.of("code", 500, "msg", "未知type");
     }
     }
 
 
-    /**
-     * type=1 (时): 单日查询 - 返回每个设备的 kwh 原始数据 + 当日汇总
-     */
-    private Map<String, Object> buildType1Result(String dateStr, Map<String, Object> rawDataMap,
-                                                 Map<String, String> deviceNameMap) {
+    private Map<String, Object> buildType1Result(String dateStr, Map<String, Object> rawDataMap, Map<String, String> deviceNameMap) {
         List<Map<String, Object>> list = new ArrayList<>();
         List<Map<String, Object>> list = new ArrayList<>();
         BigDecimal totalKwhAll = BigDecimal.ZERO;
         BigDecimal totalKwhAll = BigDecimal.ZERO;
-
         for (String sn : deviceNameMap.keySet()) {
         for (String sn : deviceNameMap.keySet()) {
             String mapKey = sn + "|" + dateStr;
             String mapKey = sn + "|" + dateStr;
             Object rawObj = rawDataMap.getOrDefault(mapKey, Collections.emptyList());
             Object rawObj = rawDataMap.getOrDefault(mapKey, Collections.emptyList());
-            @SuppressWarnings("unchecked")
-            JSONArray dataArray = rawObj instanceof JSONArray ? (JSONArray) rawObj : new JSONArray();
-
-            // 统计当日总用电量
+            @SuppressWarnings("unchecked") JSONArray dataArray = rawObj instanceof JSONArray ? (JSONArray) rawObj : new JSONArray();
             BigDecimal dayKwh = BigDecimal.ZERO;
             BigDecimal dayKwh = BigDecimal.ZERO;
             for (int i = 0; i < dataArray.size(); i++) {
             for (int i = 0; i < dataArray.size(); i++) {
                 JSONObject item = dataArray.getJSONObject(i);
                 JSONObject item = dataArray.getJSONObject(i);
-                if (item != null && item.getDouble("value") != null) {
+                if (item != null && item.getDouble("value") != null)
                     dayKwh = dayKwh.add(BigDecimal.valueOf(item.getDouble("value")));
                     dayKwh = dayKwh.add(BigDecimal.valueOf(item.getDouble("value")));
-                }
             }
             }
             totalKwhAll = totalKwhAll.add(dayKwh);
             totalKwhAll = totalKwhAll.add(dayKwh);
-
             Map<String, Object> item = new LinkedHashMap<>();
             Map<String, Object> item = new LinkedHashMap<>();
             item.put("dtuSn", sn);
             item.put("dtuSn", sn);
             item.put("deviceName", deviceNameMap.getOrDefault(sn, ""));
             item.put("deviceName", deviceNameMap.getOrDefault(sn, ""));
@@ -1113,67 +729,44 @@ public class EnergySearchService {
             item.put("totalKwh", dayKwh.setScale(2, RoundingMode.HALF_UP));
             item.put("totalKwh", dayKwh.setScale(2, RoundingMode.HALF_UP));
             list.add(item);
             list.add(item);
         }
         }
-
-        return Map.of(
-                "code", 200, "msg", "请求成功",
-                "type", "1",
-                "date", dateStr,
-                "totalDevices", deviceNameMap.size(),
-                "totalKwh", totalKwhAll.setScale(2, RoundingMode.HALF_UP),
-                "list", list
-        );
+        return Map.of("code", 200, "msg", "请求成功", "type", "1", "date", dateStr, "totalDevices", deviceNameMap.size(), "totalKwh", totalKwhAll.setScale(2, RoundingMode.HALF_UP), "list", list);
     }
     }
 
 
-    /**
-     * type=2 (日): 按设备统计 - 每个设备一行，包含该设备每天的能耗明细
-     */
-    private Map<String, Object> buildType2Result(List<String> dateList, Map<String, Object> rawDataMap,
-                                                 Map<String, String> deviceNameMap,
-                                                 String actualStart, String actualEnd) {
+    private Map<String, Object> buildType2Result(List<String> dateList, Map<String, Object> rawDataMap, Map<String, String> deviceNameMap, String actualStart, String actualEnd) {
         BigDecimal grandTotalKwh = BigDecimal.ZERO;
         BigDecimal grandTotalKwh = BigDecimal.ZERO;
         List<Map<String, Object>> deviceList = new ArrayList<>(deviceNameMap.size());
         List<Map<String, Object>> deviceList = new ArrayList<>(deviceNameMap.size());
-
         for (String sn : deviceNameMap.keySet()) {
         for (String sn : deviceNameMap.keySet()) {
             Map<String, Object> devItem = new LinkedHashMap<>();
             Map<String, Object> devItem = new LinkedHashMap<>();
             devItem.put("dtuSn", sn);
             devItem.put("dtuSn", sn);
             devItem.put("deviceName", deviceNameMap.getOrDefault(sn, ""));
             devItem.put("deviceName", deviceNameMap.getOrDefault(sn, ""));
-
-            // 该设备的每日数据列表
             List<Map<String, Object>> dailyDataList = new ArrayList<>(dateList.size());
             List<Map<String, Object>> dailyDataList = new ArrayList<>(dateList.size());
             BigDecimal devTotalKwh = BigDecimal.ZERO;
             BigDecimal devTotalKwh = BigDecimal.ZERO;
             long devTotalDur = 0;
             long devTotalDur = 0;
             Map<Integer, Long> devStatusAll = initStatusMap();
             Map<Integer, Long> devStatusAll = initStatusMap();
-
             for (String d : dateList) {
             for (String d : dateList) {
                 String mapKey = sn + "|" + d;
                 String mapKey = sn + "|" + d;
                 Object rawObj = rawDataMap.getOrDefault(mapKey, Collections.emptyList());
                 Object rawObj = rawDataMap.getOrDefault(mapKey, Collections.emptyList());
-                @SuppressWarnings("unchecked")
-                JSONArray dataArray = rawObj instanceof JSONArray ? (JSONArray) rawObj : new JSONArray();
-
+                @SuppressWarnings("unchecked") JSONArray dataArray = rawObj instanceof JSONArray ? (JSONArray) rawObj : new JSONArray();
                 BigDecimal dayKwh = BigDecimal.ZERO;
                 BigDecimal dayKwh = BigDecimal.ZERO;
                 long dayDur = 0;
                 long dayDur = 0;
                 Map<Integer, Long> dayStatus = initStatusMap();
                 Map<Integer, Long> dayStatus = initStatusMap();
-
                 for (int i = 0; i < dataArray.size(); i++) {
                 for (int i = 0; i < dataArray.size(); i++) {
                     JSONObject item = dataArray.getJSONObject(i);
                     JSONObject item = dataArray.getJSONObject(i);
                     if (item == null) continue;
                     if (item == null) continue;
-
                     Double value = item.getDouble("value");
                     Double value = item.getDouble("value");
                     if (value != null) dayKwh = dayKwh.add(BigDecimal.valueOf(value));
                     if (value != null) dayKwh = dayKwh.add(BigDecimal.valueOf(value));
-
                     for (int sk = 0; sk <= 3; sk++) {
                     for (int sk = 0; sk <= 3; sk++) {
                         Long dur = item.getLong(String.valueOf(sk));
                         Long dur = item.getLong(String.valueOf(sk));
                         if (dur != null && dur > 0) {
                         if (dur != null && dur > 0) {
                             dayDur += dur;
                             dayDur += dur;
-                            dayStatus.merge(sk, dur, Long::sum);
                             devTotalDur += dur;
                             devTotalDur += dur;
+                            dayStatus.merge(sk, dur, Long::sum);
                             devStatusAll.merge(sk, dur, Long::sum);
                             devStatusAll.merge(sk, dur, Long::sum);
                         }
                         }
                     }
                     }
                 }
                 }
-
                 devTotalKwh = devTotalKwh.add(dayKwh);
                 devTotalKwh = devTotalKwh.add(dayKwh);
-
+                grandTotalKwh = grandTotalKwh.add(devTotalKwh);
                 Map<String, Object> dayEntry = new LinkedHashMap<>();
                 Map<String, Object> dayEntry = new LinkedHashMap<>();
                 dayEntry.put("date", d);
                 dayEntry.put("date", d);
                 dayEntry.put("totalKwh", dayKwh.setScale(2, RoundingMode.HALF_UP));
                 dayEntry.put("totalKwh", dayKwh.setScale(2, RoundingMode.HALF_UP));
@@ -1182,50 +775,27 @@ public class EnergySearchService {
                 dayEntry.put("statusStats", buildStatusStats(dayStatus, dayDur));
                 dayEntry.put("statusStats", buildStatusStats(dayStatus, dayDur));
                 dailyDataList.add(dayEntry);
                 dailyDataList.add(dayEntry);
             }
             }
-
-            grandTotalKwh = grandTotalKwh.add(devTotalKwh);
-
             devItem.put("totalKwh", devTotalKwh.setScale(2, RoundingMode.HALF_UP));
             devItem.put("totalKwh", devTotalKwh.setScale(2, RoundingMode.HALF_UP));
             devItem.put("totalDurationFormatted", formatDuration(devTotalDur));
             devItem.put("totalDurationFormatted", formatDuration(devTotalDur));
             devItem.put("totalDurationSeconds", devTotalDur);
             devItem.put("totalDurationSeconds", devTotalDur);
             devItem.put("statusStats", buildStatusStats(devStatusAll, devTotalDur));
             devItem.put("statusStats", buildStatusStats(devStatusAll, devTotalDur));
             devItem.put("dailyData", dailyDataList);
             devItem.put("dailyData", dailyDataList);
-
             deviceList.add(devItem);
             deviceList.add(devItem);
         }
         }
-
-        return Map.of(
-                "code", 200, "msg", "请求成功",
-                "type", "2",
-                "actualStartDate", actualStart,
-                "actualEndDate", actualEnd,
-                "totalDays", dateList.size(),
-                "totalDevices", deviceList.size(),
-                "grandTotalKwh", grandTotalKwh.setScale(2, RoundingMode.HALF_UP),
-                "list", deviceList
-        );
+        return Map.of("code", 200, "msg", "请求成功", "type", "2", "actualStartDate", actualStart, "actualEndDate", actualEnd,
+                "totalDays", dateList.size(), "totalDevices", deviceList.size(), "grandTotalKwh", grandTotalKwh.setScale(2, RoundingMode.HALF_UP), "list", deviceList);
     }
     }
 
 
-    /**
-     * type=3 (月): 按设备统计 - 每个设备一行，包含该设备每月的能耗明细
-     */
-    private Map<String, Object> buildType3Result(List<String> dateList, Map<String, Object> rawDataMap,
-                                                 Map<String, String> deviceNameMap,
-                                                 String actualStart, String actualEnd) {
+    private Map<String, Object> buildType3Result(List<String> dateList, Map<String, Object> rawDataMap, Map<String, String> deviceNameMap, String actualStart, String actualEnd) {
         BigDecimal grandTotalKwh = BigDecimal.ZERO;
         BigDecimal grandTotalKwh = BigDecimal.ZERO;
         List<Map<String, Object>> deviceList = new ArrayList<>(deviceNameMap.size());
         List<Map<String, Object>> deviceList = new ArrayList<>(deviceNameMap.size());
-
         for (String sn : deviceNameMap.keySet()) {
         for (String sn : deviceNameMap.keySet()) {
             Map<String, Object> devItem = new LinkedHashMap<>();
             Map<String, Object> devItem = new LinkedHashMap<>();
             devItem.put("dtuSn", sn);
             devItem.put("dtuSn", sn);
             devItem.put("deviceName", deviceNameMap.getOrDefault(sn, ""));
             devItem.put("deviceName", deviceNameMap.getOrDefault(sn, ""));
-
-            // 该设备的按月聚合数据
             Map<String, Map<String, Object>> monthAgg = new LinkedHashMap<>();
             Map<String, Map<String, Object>> monthAgg = new LinkedHashMap<>();
-
             for (String d : dateList) {
             for (String d : dateList) {
                 String monthKey = d.substring(0, 7);
                 String monthKey = d.substring(0, 7);
-
                 monthAgg.computeIfAbsent(monthKey, k -> {
                 monthAgg.computeIfAbsent(monthKey, k -> {
                     Map<String, Object> m = new LinkedHashMap<>();
                     Map<String, Object> m = new LinkedHashMap<>();
                     m.put("month", k);
                     m.put("month", k);
@@ -1235,18 +805,15 @@ public class EnergySearchService {
                     m.put("statusDurationMap", initStatusMap());
                     m.put("statusDurationMap", initStatusMap());
                     return m;
                     return m;
                 });
                 });
-
                 String mapKey = sn + "|" + d;
                 String mapKey = sn + "|" + d;
                 Object rawObj = rawDataMap.getOrDefault(mapKey, Collections.emptyList());
                 Object rawObj = rawDataMap.getOrDefault(mapKey, Collections.emptyList());
                 @SuppressWarnings("unchecked")
                 @SuppressWarnings("unchecked")
                 JSONArray dataArray = rawObj instanceof JSONArray ? (JSONArray) rawObj : new JSONArray();
                 JSONArray dataArray = rawObj instanceof JSONArray ? (JSONArray) rawObj : new JSONArray();
 
 
                 Map<String, Object> mEntry = monthAgg.get(monthKey);
                 Map<String, Object> mEntry = monthAgg.get(monthKey);
-
                 for (int i = 0; i < dataArray.size(); i++) {
                 for (int i = 0; i < dataArray.size(); i++) {
                     JSONObject item = dataArray.getJSONObject(i);
                     JSONObject item = dataArray.getJSONObject(i);
                     if (item == null) continue;
                     if (item == null) continue;
-
                     Double value = item.getDouble("value");
                     Double value = item.getDouble("value");
                     if (value != null) {
                     if (value != null) {
                         BigDecimal valBd = BigDecimal.valueOf(value);
                         BigDecimal valBd = BigDecimal.valueOf(value);
@@ -1270,21 +837,17 @@ public class EnergySearchService {
             BigDecimal devTotalKwh = BigDecimal.ZERO;
             BigDecimal devTotalKwh = BigDecimal.ZERO;
             long devTotalDur = 0;
             long devTotalDur = 0;
             Map<Integer, Long> devStatusAll = initStatusMap();
             Map<Integer, Long> devStatusAll = initStatusMap();
-
             for (Map.Entry<String, Map<String, Object>> me : monthAgg.entrySet()) {
             for (Map.Entry<String, Map<String, Object>> me : monthAgg.entrySet()) {
                 Map<String, Object> m = me.getValue();
                 Map<String, Object> m = me.getValue();
                 long mDur = (Long) m.get("totalDurationSeconds");
                 long mDur = (Long) m.get("totalDurationSeconds");
                 BigDecimal mKwh = (BigDecimal) m.get("totalKwh");
                 BigDecimal mKwh = (BigDecimal) m.get("totalKwh");
-                @SuppressWarnings("unchecked")
-                Map<Integer, Long> mStatus = (Map<Integer, Long>) m.get("statusDurationMap");
-
+                @SuppressWarnings("unchecked") Map<Integer, Long> mStatus = (Map<Integer, Long>) m.get("statusDurationMap");
                 devTotalKwh = devTotalKwh.add(mKwh);
                 devTotalKwh = devTotalKwh.add(mKwh);
                 devTotalDur += mDur;
                 devTotalDur += mDur;
                 for (int sk = 0; sk <= 3; sk++) {
                 for (int sk = 0; sk <= 3; sk++) {
                     long sd = mStatus.getOrDefault(sk, 0L);
                     long sd = mStatus.getOrDefault(sk, 0L);
                     if (sd > 0) devStatusAll.merge(sk, sd, Long::sum);
                     if (sd > 0) devStatusAll.merge(sk, sd, Long::sum);
                 }
                 }
-
                 Map<String, Object> monthEntry = new LinkedHashMap<>();
                 Map<String, Object> monthEntry = new LinkedHashMap<>();
                 monthEntry.put("month", m.get("month"));
                 monthEntry.put("month", m.get("month"));
                 monthEntry.put("label", m.get("label"));
                 monthEntry.put("label", m.get("label"));
@@ -1294,71 +857,37 @@ public class EnergySearchService {
                 monthEntry.put("statusStats", buildStatusStats(mStatus, mDur));
                 monthEntry.put("statusStats", buildStatusStats(mStatus, mDur));
                 monthlyDataList.add(monthEntry);
                 monthlyDataList.add(monthEntry);
             }
             }
-
             grandTotalKwh = grandTotalKwh.add(devTotalKwh);
             grandTotalKwh = grandTotalKwh.add(devTotalKwh);
-
             devItem.put("totalKwh", devTotalKwh.setScale(2, RoundingMode.HALF_UP));
             devItem.put("totalKwh", devTotalKwh.setScale(2, RoundingMode.HALF_UP));
             devItem.put("totalDurationFormatted", formatDuration(devTotalDur));
             devItem.put("totalDurationFormatted", formatDuration(devTotalDur));
             devItem.put("totalDurationSeconds", devTotalDur);
             devItem.put("totalDurationSeconds", devTotalDur);
             devItem.put("statusStats", buildStatusStats(devStatusAll, devTotalDur));
             devItem.put("statusStats", buildStatusStats(devStatusAll, devTotalDur));
             devItem.put("monthlyData", monthlyDataList);
             devItem.put("monthlyData", monthlyDataList);
-
             deviceList.add(devItem);
             deviceList.add(devItem);
         }
         }
-
-        return Map.of(
-                "code", 200, "msg", "请求成功",
-                "type", "3",
-                "year", actualStart.substring(0, 4),
-                "actualStartDate", actualStart,
-                "actualEndDate", actualEnd,
-                "totalMonths", dateList.isEmpty() ? 0 :
-                        (dateList.stream().map(d -> d.substring(0, 7)).distinct().toList()).size(),
-                "totalDevices", deviceList.size(),
-                "grandTotalKwh", grandTotalKwh.setScale(2, RoundingMode.HALF_UP),
-                "list", deviceList
-        );
+        return Map.of("code", 200, "msg", "请求成功", "type", "3", "year", actualStart.substring(0, 4), "actualStartDate", actualStart,
+                "actualEndDate", actualEnd, "totalMonths", dateList.isEmpty() ? 0 : (dateList.stream().map(d -> d.substring(0, 7)).distinct().toList()).size(),
+                "totalDevices", deviceList.size(), "grandTotalKwh", grandTotalKwh.setScale(2, RoundingMode.HALF_UP), "list", deviceList);
     }
     }
 
 
-    /** 调试接口: 查看eq_kwh表中的数据概况 */
-    public Map<String, Object> debugEqKwhInfo() {
-        // 总记录数
-        Long totalCount = jdbcTemplate.queryForObject(
-                "SELECT COUNT(*) FROM " + eqKwhTableName + " WHERE corp_code = ?", Long.class, energyCorpCode);
-
-        // 按日期分组统计
-        List<Map<String, Object>> dateStats = jdbcTemplate.queryForList(
-                "SELECT use_date, COUNT(*) as cnt FROM " + eqKwhTableName +
-                        " WHERE corp_code = ? GROUP BY use_date ORDER BY use_date DESC LIMIT 20",
-                energyCorpCode);
-
-        // 按设备分组统计
-        List<Map<String, Object>> deviceStats = jdbcTemplate.queryForList(
-                "SELECT dtuSn, COUNT(*) as cnt FROM " + eqKwhTableName +
-                        " WHERE corp_code = ? GROUP BY dtuSn ORDER BY dtuSn",
-                energyCorpCode);
-
-        // 最新一条记录的 description 预览
+    /**
+     * 调试接口
+     */
+    public Map<String, Object> debugEqKwhInfo(String corpCode) {
+        String eqKwhTableName = corpConfigService.getEqKwhTableName(corpCode);
+        String energyTableName = corpConfigService.getEnergyTableName(corpCode);
+        JdbcTemplate jt = corpConfigService.getJdbcTemplate(corpCode);
+        Long totalCount = jt.queryForObject("SELECT COUNT(*) FROM " + eqKwhTableName + " WHERE corp_code = ?", Long.class, corpCode);
+        List<Map<String, Object>> dateStats = jt.queryForList("SELECT use_date, COUNT(*) as cnt FROM " + eqKwhTableName + " WHERE corp_code = ? GROUP BY use_date ORDER BY use_date DESC LIMIT 20", corpCode);
+        List<Map<String, Object>> deviceStats = jt.queryForList("SELECT dtuSn, COUNT(*) as cnt FROM " + eqKwhTableName + " WHERE corp_code = ? GROUP BY dtuSn ORDER BY dtuSn", corpCode);
         Map<String, Object> lastRecord = null;
         Map<String, Object> lastRecord = null;
         try {
         try {
-            String sql = "SELECT dtuSn, use_date, LEFT(description, 500) AS desc_preview, LENGTH(description) as desc_len " +
-                    "FROM " + eqKwhTableName + " WHERE corp_code = ? ORDER BY use_date DESC LIMIT 1";
-            lastRecord = jdbcTemplate.queryForMap(sql, energyCorpCode);
-        } catch (Exception ignored) {}
-
-        // energy 表设备数
-        Long deviceCount = jdbcTemplate.queryForObject(
-                "SELECT COUNT(*) FROM " + energyTableName + " WHERE corp_code = ?", Long.class, energyCorpCode);
-
-        return Map.of(
-                "code", 200, "msg", "请求成功",
-                "tableName", eqKwhTableName,
-                "corpCode", energyCorpCode,
-                "totalRecords", totalCount != null ? totalCount : 0,
-                "deviceCountInEnergyTable", deviceCount != null ? deviceCount : 0,
-                "latestDateRecords", dateStats,
-                "perDeviceRecordCount", deviceStats,
-                "lastRecordPreview", lastRecord
-        );
+            String sql = "SELECT dtuSn, use_date, LEFT(description, 500) AS desc_preview, LENGTH(description) as desc_len FROM " + eqKwhTableName + " WHERE corp_code = ? ORDER BY use_date DESC LIMIT 1";
+            lastRecord = jt.queryForMap(sql, corpCode);
+        } catch (Exception ignored) {
+        }
+        Long deviceCount = jt.queryForObject("SELECT COUNT(*) FROM " + energyTableName + " WHERE corp_code = ?", Long.class, corpCode);
+        return Map.of("code", 200, "msg", "请求成功", "tableName", eqKwhTableName, "corpCode", corpCode, "totalRecords", totalCount != null ? totalCount : 0,
+                "deviceCountInEnergyTable", deviceCount != null ? deviceCount : 0, "latestDateRecords", dateStats, "perDeviceRecordCount", deviceStats, "lastRecordPreview", lastRecord);
     }
     }
 }
 }

@@ -89,3 +89,8 @@ energy:
     eRunDtlTableName: "t_auto_ymk_iot_e_run_dtl"
     eRunDtlTableName: "t_auto_ymk_iot_e_run_dtl"
   runStatus:
   runStatus:
     url: "https://iotgc.cniot.vip/api/energy/runStatus"
     url: "https://iotgc.cniot.vip/api/energy/runStatus"
+
+# 公司配置表（主数据库中存储各公司的数据源和IoT配置）
+corp:
+  config:
+    tableName: "t_auto_ymk_ccfg_corp_conf"