运行优化列表、详情接口

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/controller/FhzgReconController.java

@@ -0,0 +1,85 @@
+package com.hdkj.lt.bf.controller;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.hdkj.hussar.ApiResponse;
+import com.hdkj.lt.bf.entity.dto.ReconDetailReqDTO;
+import com.hdkj.lt.bf.entity.dto.ReconListReqDTO;
+import com.hdkj.lt.bf.entity.dto.ReconPageReqDTO;
+import com.hdkj.lt.bf.entity.vo.*;
+import com.hdkj.lt.bf.service.ReconQueryService;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 重构方案查询控制器
+ *
+ * @author Sunlit
+ * @date 2026/7/17
+ */
+@RestController
+@RequestMapping("/recon")
+@RequiredArgsConstructor
+public class FhzgReconController {
+
+    @Autowired
+    private ReconQueryService reconQueryService;
+
+    /**
+     * 查询方案列表（事件详情页）
+     */
+    @PostMapping("/list")
+    @ApiOperation(value = "查询重构方案列表")
+    public ApiResponse<ReconListVO> getSchemeList(@RequestBody ReconListReqDTO reqDTO) {
+        return ApiResponse.success(reconQueryService.getSchemeList(reqDTO));
+    }
+
+    /**
+     * 查询方案详情（方案详情页）
+     */
+    @PostMapping("/detail")
+    @ApiOperation(value = "查询重构方案详情")
+    public ApiResponse<ReconDetailVO> getSchemeDetail(@RequestBody ReconDetailReqDTO reqDTO) {
+        return ApiResponse.success(reconQueryService.getSchemeDetail(reqDTO));
+    }
+
+    /**
+     * 查询开关动作顺序（分页）
+     */
+    @PostMapping("/switch-seq/page")
+    @ApiOperation(value = "查询开关动作顺序")
+    public ApiResponse<Page<ReconSwitchSeqVO>> getSwitchSeqPage(@RequestBody ReconPageReqDTO reqDTO) {
+        return ApiResponse.success(reconQueryService.getSwitchSeqPage(reqDTO));
+    }
+
+    /**
+     * 查询馈线重构前后对比（分页）
+     */
+    @PostMapping("/feeder-compare/page")
+    @ApiOperation(value = "查询馈线重构前后对比")
+    public ApiResponse<Page<ReconFeederCompareVO>> getFeederComparePage(@RequestBody ReconPageReqDTO reqDTO) {
+        return ApiResponse.success(reconQueryService.getFeederComparePage(reqDTO));
+    }
+
+    /**
+     * 查询负荷点电压对比（分页）
+     */
+    @PostMapping("/loadpoint-compare/page")
+    @ApiOperation(value = "查询负荷点电压对比")
+    public ApiResponse<Page<ReconLoadpointCompareVO>> getLoadpointComparePage(@RequestBody ReconPageReqDTO reqDTO) {
+        return ApiResponse.success(reconQueryService.getLoadpointComparePage(reqDTO));
+    }
+
+    /**
+     * 查询开关状态对比（分页）
+     */
+    @PostMapping("/switch-compare/page")
+    @ApiOperation(value = "查询开关状态对比")
+    public ApiResponse<Page<ReconSwitchCompareVO>> getSwitchComparePage(@RequestBody ReconPageReqDTO reqDTO) {
+        return ApiResponse.success(reconQueryService.getSwitchComparePage(reqDTO));
+    }
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/entity/dto/ReconDetailReqDTO.java

@@ -0,0 +1,13 @@
+package com.hdkj.lt.bf.entity.dto;
+
+import lombok.Data;
+
+/**
+ * 重构方案详情查询请求
+ */
+@Data
+public class ReconDetailReqDTO {
+
+    /** 方案ID */
+    private Long id;
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/entity/dto/ReconListReqDTO.java

@@ -0,0 +1,13 @@
+package com.hdkj.lt.bf.entity.dto;
+
+import lombok.Data;
+
+/**
+ * 重构方案列表查询请求
+ */
+@Data
+public class ReconListReqDTO {
+
+    /** 事件ID */
+    private String eventId;
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/entity/dto/ReconPageReqDTO.java

@@ -0,0 +1,19 @@
+package com.hdkj.lt.bf.entity.dto;
+
+import lombok.Data;
+
+/**
+ * 重构方案分页查询请求
+ */
+@Data
+public class ReconPageReqDTO {
+
+    /** 方案ID */
+    private Long resultId;
+
+    /** 页码 */
+    private Integer pageNum;
+
+    /** 每页条数 */
+    private Integer pageSize;
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/entity/vo/ReconDetailVO.java

@@ -0,0 +1,13 @@
+package com.hdkj.lt.bf.entity.vo;
+
+import lombok.Data;
+
+/**
+ * 重构方案详情返回
+ */
+@Data
+public class ReconDetailVO {
+
+    /** 方案信息（复用列表结构） */
+    private ReconSchemeVO schemeInfo;
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/entity/vo/ReconFeederCompareVO.java

@@ -0,0 +1,45 @@
+package com.hdkj.lt.bf.entity.vo;
+
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/**
+ * 馈线重构前后对比
+ */
+@Data
+public class ReconFeederCompareVO {
+
+    /** 馈线序号 */
+    private Integer feederNo;
+
+    /** 馈线名称 */
+    private String feederName;
+
+    /** 流向类型 */
+    private String flowType;
+
+    /** 重构前负载率(%) */
+    private BigDecimal loadingBefore;
+
+    /** 重构后负载率(%) */
+    private BigDecimal loadingAfter;
+
+    /** 负载率变化(%) */
+    private BigDecimal loadingChange;
+
+    /** 额定电流(A) */
+    private BigDecimal ratedCurrent;
+
+    /** 重构前电流(A) */
+    private BigDecimal currentBefore;
+
+    /** 重构后电流(A) */
+    private BigDecimal currentAfter;
+
+    /** 重构前线损率(%) */
+    private BigDecimal lineLossRateBefore;
+
+    /** 重构后线损率(%) */
+    private BigDecimal lineLossRateAfter;
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/entity/vo/ReconListVO.java

@@ -0,0 +1,24 @@
+package com.hdkj.lt.bf.entity.vo;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * 重构方案列表返回
+ */
+@Data
+public class ReconListVO {
+
+    /** 事件信息 */
+    private EventInfo eventInfo;
+
+    /** 方案列表 */
+    private List<ReconSchemeVO> schemeList;
+
+    @Data
+    public static class EventInfo {
+        /** 事件ID */
+        private String eventId;
+    }
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/entity/vo/ReconLoadpointCompareVO.java

@@ -0,0 +1,48 @@
+package com.hdkj.lt.bf.entity.vo;
+
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/**
+ * 负荷点电压对比
+ */
+@Data
+public class ReconLoadpointCompareVO {
+
+    /** 详情序号 */
+    private Integer detailNo;
+
+    /** 负荷点名称 */
+    private String loadPointName;
+
+    /** 负荷类型 */
+    private String loadType;
+
+    /** 重构前电压(kV) */
+    private BigDecimal voltageBefore;
+
+    /** 重构后电压(kV) */
+    private BigDecimal voltageAfter;
+
+    /** 重构前是否越限 */
+    private Boolean isOverLimitBefore;
+
+    /** 重构后是否越限 */
+    private Boolean isOverLimitAfter;
+
+    /** 电压变化(kV) */
+    private BigDecimal voltageChange;
+
+    /** 重构前低压侧电压(kV) */
+    private BigDecimal lowVoltageBefore;
+
+    /** 重构后低压侧电压(kV) */
+    private BigDecimal lowVoltageAfter;
+
+    /** 重构前有功功率(kW) */
+    private BigDecimal activePowerBefore;
+
+    /** 重构前无功功率(kVar) */
+    private BigDecimal reactivePowerBefore;
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/entity/vo/ReconSchemeVO.java

@@ -0,0 +1,120 @@
+package com.hdkj.lt.bf.entity.vo;
+
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/**
+ * 重构方案信息（列表和详情共用）
+ */
+@Data
+public class ReconSchemeVO {
+
+    /** 方案ID */
+    private Long id;
+
+    /** 事件ID */
+    private String eventId;
+
+    /** 是否推荐 */
+    private Boolean isRecommend;
+
+    /** 热校验是否通过 */
+    private Boolean hotCheckPassed;
+
+    /** 安全校验是否通过 */
+    private Boolean safetyCheckPassed;
+
+    /** 开关操作次数 */
+    private Integer switchOpCount;
+
+    /** 重构前健康度 */
+    private BigDecimal healthScoreBefore;
+
+    /** 重构后健康度 */
+    private BigDecimal healthScoreAfter;
+
+    /** 重构前最大负载率(%) */
+    private BigDecimal maxLoadingPctBefore;
+
+    /** 重构后最大负载率(%) */
+    private BigDecimal maxLoadingPctAfter;
+
+    /** 重构前电压越限节点数 */
+    private Integer voltageOverLimitCountBefore;
+
+    /** 重构后电压越限节点数 */
+    private Integer voltageOverLimitCountAfter;
+
+    /** 重构前总线损(MW) */
+    private BigDecimal totalLossMwBefore;
+
+    /** 重构后总线损(MW) */
+    private BigDecimal totalLossMwAfter;
+
+    /** 负载详细指标 */
+    private DetailLoading detailLoading;
+
+    /** 电压详细指标 */
+    private DetailVoltage detailVoltage;
+
+    /** 损耗详细指标 */
+    private DetailLoss detailLoss;
+
+    /** 五维度评分 */
+    private Dimensions dimensions;
+
+    @Data
+    public static class DetailLoading {
+        /** 重构前平均负载率(%) */
+        private BigDecimal avgLoadingPctBefore;
+        /** 重构后平均负载率(%) */
+        private BigDecimal avgLoadingPctAfter;
+        /** 重构前重过载线路数 */
+        private Integer overLoadLineCountBefore;
+        /** 重构后重过载线路数 */
+        private Integer overLoadLineCountAfter;
+    }
+
+    @Data
+    public static class DetailVoltage {
+        /** 重构前越上限节点数 */
+        private Integer overMaxCountBefore;
+        /** 重构后越上限节点数 */
+        private Integer overMaxCountAfter;
+        /** 最高电压(pu) */
+        private BigDecimal maxVoltagePu;
+        /** 重构前越下限节点数 */
+        private Integer underMinCountBefore;
+        /** 重构后越下限节点数 */
+        private Integer underMinCountAfter;
+        /** 最低电压(pu) */
+        private BigDecimal minVoltagePu;
+    }
+
+    @Data
+    public static class DetailLoss {
+        /** 重构前线路损耗(MW) */
+        private BigDecimal lineLossMwBefore;
+        /** 重构后线路损耗(MW) */
+        private BigDecimal lineLossMwAfter;
+        /** 重构前变压器损耗(MW) */
+        private BigDecimal trafoLossMwBefore;
+        /** 重构后变压器损耗(MW) */
+        private BigDecimal trafoLossMwAfter;
+    }
+
+    @Data
+    public static class Dimensions {
+        /** 安全评分 */
+        private BigDecimal safetyScore;
+        /** 电压评分 */
+        private BigDecimal voltageScore;
+        /** 损耗评分 */
+        private BigDecimal lossScore;
+        /** 均衡评分 */
+        private BigDecimal balanceScore;
+        /** 风险评分 */
+        private BigDecimal riskScore;
+    }
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/entity/vo/ReconSwitchCompareVO.java

@@ -0,0 +1,33 @@
+package com.hdkj.lt.bf.entity.vo;
+
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/**
+ * 开关状态对比
+ */
+@Data
+public class ReconSwitchCompareVO {
+
+    /** 详情序号 */
+    private Integer detailNo;
+
+    /** 开关名称 */
+    private String switchName;
+
+    /** 状态变化 */
+    private String stateChange;
+
+    /** 重构前电流(A) */
+    private BigDecimal currentBefore;
+
+    /** 重构后电流(A) */
+    private BigDecimal currentAfter;
+
+    /** 重构前电压(kV) */
+    private BigDecimal voltageBefore;
+
+    /** 重构后电压(kV) */
+    private BigDecimal voltageAfter;
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/entity/vo/ReconSwitchSeqVO.java

@@ -0,0 +1,34 @@
+package com.hdkj.lt.bf.entity.vo;
+
+import lombok.Data;
+
+/**
+ * 开关动作顺序
+ */
+@Data
+public class ReconSwitchSeqVO {
+
+    /** 序列序号 */
+    private Integer seqNo;
+
+    /** 合闸开关名称 */
+    private String closeName;
+
+    /** 合闸操作类型 */
+    private String closeOperation;
+
+    /** 分闸开关名称 */
+    private String openName;
+
+    /** 分闸操作类型 */
+    private String openOperation;
+
+    /** 是否三遥开关 */
+    private Boolean isThreeRemotely;
+
+    /** 热校验是否通过 */
+    private Boolean hotCheckPassed;
+
+    /** 安全校验是否通过 */
+    private Boolean safetyCheckPassed;
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/mapper/FhzgReconFeederResultMapper.java

@@ -0,0 +1,10 @@
+package com.hdkj.lt.bf.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.hdkj.lt.modle.po.FhzgReconFeederResult;
+import org.apache.ibatis.annotations.Mapper;
+
+/** 馈线结果 Mapper */
+@Mapper
+public interface FhzgReconFeederResultMapper extends BaseMapper<FhzgReconFeederResult> {
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/mapper/FhzgReconMetricsMapper.java

@@ -0,0 +1,10 @@
+package com.hdkj.lt.bf.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.hdkj.lt.modle.po.FhzgReconMetrics;
+import org.apache.ibatis.annotations.Mapper;
+
+/** 运行指标 Mapper */
+@Mapper
+public interface FhzgReconMetricsMapper extends BaseMapper<FhzgReconMetrics> {
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/mapper/FhzgReconResultMapper.java

@@ -0,0 +1,10 @@
+package com.hdkj.lt.bf.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.hdkj.lt.modle.po.FhzgReconResult;
+import org.apache.ibatis.annotations.Mapper;
+
+/** 重构结果主表 Mapper */
+@Mapper
+public interface FhzgReconResultMapper extends BaseMapper<FhzgReconResult> {
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/mapper/FhzgReconSwitchOpMapper.java

@@ -0,0 +1,10 @@
+package com.hdkj.lt.bf.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.hdkj.lt.modle.po.FhzgReconSwitchOp;
+import org.apache.ibatis.annotations.Mapper;
+
+/** 开关操作-简化版 Mapper */
+@Mapper
+public interface FhzgReconSwitchOpMapper extends BaseMapper<FhzgReconSwitchOp> {
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/mapper/FhzgReconSwitchResultDetailMapper.java

@@ -0,0 +1,10 @@
+package com.hdkj.lt.bf.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.hdkj.lt.modle.po.FhzgReconSwitchResultDetail;
+import org.apache.ibatis.annotations.Mapper;
+
+/** 开关状态-详情 Mapper */
+@Mapper
+public interface FhzgReconSwitchResultDetailMapper extends BaseMapper<FhzgReconSwitchResultDetail> {
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/mapper/FhzgReconSwitchSeqMapper.java

@@ -0,0 +1,10 @@
+package com.hdkj.lt.bf.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.hdkj.lt.modle.po.FhzgReconSwitchSeq;
+import org.apache.ibatis.annotations.Mapper;
+
+/** 开关操作序列-详细 Mapper */
+@Mapper
+public interface FhzgReconSwitchSeqMapper extends BaseMapper<FhzgReconSwitchSeq> {
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/mapper/FhzgReconVolDetailMapper.java

@@ -0,0 +1,10 @@
+package com.hdkj.lt.bf.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.hdkj.lt.modle.po.FhzgReconVolDetail;
+import org.apache.ibatis.annotations.Mapper;
+
+/** 电压结果-节点详情 Mapper */
+@Mapper
+public interface FhzgReconVolDetailMapper extends BaseMapper<FhzgReconVolDetail> {
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/mapper/FhzgReconVolResultMapper.java

@@ -0,0 +1,10 @@
+package com.hdkj.lt.bf.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.hdkj.lt.modle.po.FhzgReconVolResult;
+import org.apache.ibatis.annotations.Mapper;
+
+/** 电压结果-汇总 Mapper */
+@Mapper
+public interface FhzgReconVolResultMapper extends BaseMapper<FhzgReconVolResult> {
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/service/ReconQueryService.java

@@ -0,0 +1,43 @@
+package com.hdkj.lt.bf.service;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.hdkj.lt.bf.entity.dto.ReconDetailReqDTO;
+import com.hdkj.lt.bf.entity.dto.ReconListReqDTO;
+import com.hdkj.lt.bf.entity.dto.ReconPageReqDTO;
+import com.hdkj.lt.bf.entity.vo.*;
+
+/**
+ * 重构方案查询服务
+ */
+public interface ReconQueryService {
+
+    /**
+     * 查询方案列表
+     */
+    ReconListVO getSchemeList(ReconListReqDTO reqDTO);
+
+    /**
+     * 查询方案详情
+     */
+    ReconDetailVO getSchemeDetail(ReconDetailReqDTO reqDTO);
+
+    /**
+     * 查询开关动作顺序（分页）
+     */
+    Page<ReconSwitchSeqVO> getSwitchSeqPage(ReconPageReqDTO reqDTO);
+
+    /**
+     * 查询馈线重构前后对比（分页）
+     */
+    Page<ReconFeederCompareVO> getFeederComparePage(ReconPageReqDTO reqDTO);
+
+    /**
+     * 查询负荷点电压对比（分页）
+     */
+    Page<ReconLoadpointCompareVO> getLoadpointComparePage(ReconPageReqDTO reqDTO);
+
+    /**
+     * 查询开关状态对比（分页）
+     */
+    Page<ReconSwitchCompareVO> getSwitchComparePage(ReconPageReqDTO reqDTO);
+}

services/load-transfer-bf/src/main/java/com/hdkj/lt/bf/service/impl/ReconQueryServiceImpl.java

@@ -0,0 +1,405 @@
+package com.hdkj.lt.bf.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.hdkj.lt.base.exception.BusinessException;
+import com.hdkj.lt.bf.entity.dto.ReconDetailReqDTO;
+import com.hdkj.lt.bf.entity.dto.ReconListReqDTO;
+import com.hdkj.lt.bf.entity.dto.ReconPageReqDTO;
+import com.hdkj.lt.bf.entity.vo.*;
+import com.hdkj.lt.bf.mapper.*;
+import com.hdkj.lt.bf.service.ReconQueryService;
+import com.hdkj.lt.modle.po.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * 重构方案查询服务实现
+ */
+@Service
+public class ReconQueryServiceImpl implements ReconQueryService {
+
+    @Autowired
+    private FhzgReconResultMapper reconResultMapper;
+    @Autowired
+    private FhzgReconMetricsMapper reconMetricsMapper;
+    @Autowired
+    private FhzgReconSwitchSeqMapper reconSwitchSeqMapper;
+    @Autowired
+    private FhzgReconSwitchOpMapper reconSwitchOpMapper;
+    @Autowired
+    private FhzgReconFeederResultMapper reconFeederResultMapper;
+    @Autowired
+    private FhzgReconVolDetailMapper reconVolDetailMapper;
+    @Autowired
+    private FhzgReconSwitchResultDetailMapper reconSwitchResultDetailMapper;
+
+    @Override
+    public ReconListVO getSchemeList(ReconListReqDTO reqDTO) {
+        if (Objects.isNull(reqDTO.getEventId())) {
+            throw new BusinessException("事件ID为空");
+        }
+
+        // 查询事件下所有方案
+        List<FhzgReconResult> resultList = reconResultMapper.selectList(
+                new LambdaQueryWrapper<FhzgReconResult>()
+                        .eq(FhzgReconResult::getEventId, reqDTO.getEventId())
+        );
+
+        // 构建方案VO列表
+        List<ReconSchemeVO> schemeList = resultList.stream()
+                .map(this::buildSchemeVO)
+                .sorted(Comparator.comparing(ReconSchemeVO::getHealthScoreAfter,
+                        Comparator.nullsLast(Comparator.reverseOrder())))
+                .collect(Collectors.toList());
+
+        // 按健康度排序后第一条为推荐
+        if (!schemeList.isEmpty()) {
+            schemeList.get(0).setIsRecommend(true);
+        }
+
+        // 组装返回
+        ReconListVO vo = new ReconListVO();
+        ReconListVO.EventInfo eventInfo = new ReconListVO.EventInfo();
+        eventInfo.setEventId(reqDTO.getEventId());
+        vo.setEventInfo(eventInfo);
+        vo.setSchemeList(schemeList);
+        return vo;
+    }
+
+    @Override
+    public ReconDetailVO getSchemeDetail(ReconDetailReqDTO reqDTO) {
+        if (Objects.isNull(reqDTO.getId())) {
+            throw new BusinessException("方案ID为空");
+        }
+
+        FhzgReconResult result = reconResultMapper.selectById(reqDTO.getId());
+        if (Objects.isNull(result)) {
+            throw new BusinessException("方案不存在");
+        }
+
+        // 复用列表的方案构建逻辑
+        ReconSchemeVO schemeInfo = buildSchemeVO(result);
+
+        ReconDetailVO vo = new ReconDetailVO();
+        vo.setSchemeInfo(schemeInfo);
+        return vo;
+    }
+
+    @Override
+    public Page<ReconSwitchSeqVO> getSwitchSeqPage(ReconPageReqDTO reqDTO) {
+        validatePageParam(reqDTO);
+
+        // 安全校验从主表获取
+        FhzgReconResult result = reconResultMapper.selectById(reqDTO.getResultId());
+        Boolean safetyCheckPassed = Objects.nonNull(result) ? result.getFinalCheckIsSafe() : null;
+
+        Page<FhzgReconSwitchSeq> page = new Page<>(reqDTO.getPageNum(), reqDTO.getPageSize());
+        Page<FhzgReconSwitchSeq> resultPage = reconSwitchSeqMapper.selectPage(page,
+                new LambdaQueryWrapper<FhzgReconSwitchSeq>()
+                        .eq(FhzgReconSwitchSeq::getResultId, reqDTO.getResultId())
+                        .orderByAsc(FhzgReconSwitchSeq::getSeqNo)
+        );
+
+        Page<ReconSwitchSeqVO> voPage = new Page<>();
+        voPage.setTotal(resultPage.getTotal());
+        voPage.setCurrent(resultPage.getCurrent());
+        voPage.setSize(resultPage.getSize());
+        voPage.setRecords(resultPage.getRecords().stream()
+                .map(seq -> buildSwitchSeqVO(seq, safetyCheckPassed))
+                .collect(Collectors.toList()));
+        return voPage;
+    }
+
+    @Override
+    public Page<ReconFeederCompareVO> getFeederComparePage(ReconPageReqDTO reqDTO) {
+        validatePageParam(reqDTO);
+
+        Page<FhzgReconFeederResult> page = new Page<>(reqDTO.getPageNum(), reqDTO.getPageSize());
+        Page<FhzgReconFeederResult> resultPage = reconFeederResultMapper.selectPage(page,
+                new LambdaQueryWrapper<FhzgReconFeederResult>()
+                        .eq(FhzgReconFeederResult::getResultId, reqDTO.getResultId())
+                        .orderByAsc(FhzgReconFeederResult::getFeederNo)
+        );
+
+        Page<ReconFeederCompareVO> voPage = new Page<>();
+        voPage.setTotal(resultPage.getTotal());
+        voPage.setCurrent(resultPage.getCurrent());
+        voPage.setSize(resultPage.getSize());
+        voPage.setRecords(resultPage.getRecords().stream().map(this::buildFeederCompareVO).collect(Collectors.toList()));
+        return voPage;
+    }
+
+    @Override
+    public Page<ReconLoadpointCompareVO> getLoadpointComparePage(ReconPageReqDTO reqDTO) {
+        validatePageParam(reqDTO);
+
+        Page<FhzgReconVolDetail> page = new Page<>(reqDTO.getPageNum(), reqDTO.getPageSize());
+        Page<FhzgReconVolDetail> resultPage = reconVolDetailMapper.selectPage(page,
+                new LambdaQueryWrapper<FhzgReconVolDetail>()
+                        .eq(FhzgReconVolDetail::getResultId, reqDTO.getResultId())
+                        .orderByAsc(FhzgReconVolDetail::getDetailNo)
+        );
+
+        Page<ReconLoadpointCompareVO> voPage = new Page<>();
+        voPage.setTotal(resultPage.getTotal());
+        voPage.setCurrent(resultPage.getCurrent());
+        voPage.setSize(resultPage.getSize());
+        voPage.setRecords(resultPage.getRecords().stream().map(this::buildLoadpointCompareVO).collect(Collectors.toList()));
+        return voPage;
+    }
+
+    @Override
+    public Page<ReconSwitchCompareVO> getSwitchComparePage(ReconPageReqDTO reqDTO) {
+        validatePageParam(reqDTO);
+
+        Page<FhzgReconSwitchResultDetail> page = new Page<>(reqDTO.getPageNum(), reqDTO.getPageSize());
+        Page<FhzgReconSwitchResultDetail> resultPage = reconSwitchResultDetailMapper.selectPage(page,
+                new LambdaQueryWrapper<FhzgReconSwitchResultDetail>()
+                        .eq(FhzgReconSwitchResultDetail::getResultId, reqDTO.getResultId())
+                        .orderByAsc(FhzgReconSwitchResultDetail::getDetailNo)
+        );
+
+        Page<ReconSwitchCompareVO> voPage = new Page<>();
+        voPage.setTotal(resultPage.getTotal());
+        voPage.setCurrent(resultPage.getCurrent());
+        voPage.setSize(resultPage.getSize());
+        voPage.setRecords(resultPage.getRecords().stream().map(this::buildSwitchCompareVO).collect(Collectors.toList()));
+        return voPage;
+    }
+
+    // ==================== 私有方法 ====================
+
+    /**
+     * 构建方案VO（列表和详情共用）
+     */
+    private ReconSchemeVO buildSchemeVO(FhzgReconResult result) {
+        ReconSchemeVO vo = new ReconSchemeVO();
+        vo.setId(result.getId());
+        vo.setEventId(result.getEventId());
+        vo.setIsRecommend(false);
+        vo.setSafetyCheckPassed(result.getFinalCheckIsSafe());
+
+        // 开关操作次数
+        Long switchOpCount = reconSwitchOpMapper.selectCount(
+                new LambdaQueryWrapper<FhzgReconSwitchOp>()
+                        .eq(FhzgReconSwitchOp::getResultId, result.getId())
+        );
+        vo.setSwitchOpCount(switchOpCount.intValue());
+
+        // 热校验：所有开关步骤热校验全部通过才为true
+        Long hotCheckFailCount = reconSwitchSeqMapper.selectCount(
+                new LambdaQueryWrapper<FhzgReconSwitchSeq>()
+                        .eq(FhzgReconSwitchSeq::getResultId, result.getId())
+                        .eq(FhzgReconSwitchSeq::getHotCheckIsSafe, false)
+        );
+        vo.setHotCheckPassed(hotCheckFailCount == 0);
+
+        // 查询指标
+        FhzgReconMetrics metrics = reconMetricsMapper.selectOne(
+                new LambdaQueryWrapper<FhzgReconMetrics>()
+                        .eq(FhzgReconMetrics::getResultId, result.getId())
+        );
+        if (Objects.nonNull(metrics)) {
+            vo.setHealthScoreBefore(metrics.getBeforeHealthScore());
+            vo.setHealthScoreAfter(metrics.getAfterHealthScore());
+            vo.setMaxLoadingPctBefore(metrics.getBeforeLoadingMaxLoadingPct());
+            vo.setMaxLoadingPctAfter(metrics.getAfterLoadingMaxLoadingPct());
+            vo.setVoltageOverLimitCountBefore(
+                    sumInt(metrics.getBeforeVoltageOverVmaxCount(), metrics.getBeforeVoltageUnderVminCount()));
+            vo.setVoltageOverLimitCountAfter(
+                    sumInt(metrics.getAfterVoltageOverVmaxCount(), metrics.getAfterVoltageUnderVminCount()));
+            vo.setTotalLossMwBefore(metrics.getBeforeLossTotalLossMw());
+            vo.setTotalLossMwAfter(metrics.getAfterLossTotalLossMw());
+
+            // 负载详细指标
+            ReconSchemeVO.DetailLoading detailLoading = new ReconSchemeVO.DetailLoading();
+            detailLoading.setAvgLoadingPctBefore(metrics.getBeforeLoadingAvgLoadingPct());
+            detailLoading.setAvgLoadingPctAfter(metrics.getAfterLoadingAvgLoadingPct());
+            detailLoading.setOverLoadLineCountBefore(metrics.getBeforeLoadingLineOverLimitCount());
+            detailLoading.setOverLoadLineCountAfter(metrics.getAfterLoadingLineOverLimitCount());
+            vo.setDetailLoading(detailLoading);
+
+            // 电压详细指标
+            ReconSchemeVO.DetailVoltage detailVoltage = new ReconSchemeVO.DetailVoltage();
+            detailVoltage.setOverMaxCountBefore(metrics.getBeforeVoltageOverVmaxCount());
+            detailVoltage.setOverMaxCountAfter(metrics.getAfterVoltageOverVmaxCount());
+            detailVoltage.setMaxVoltagePu(metrics.getAfterVoltageMaxVmPu());
+            detailVoltage.setUnderMinCountBefore(metrics.getBeforeVoltageUnderVminCount());
+            detailVoltage.setUnderMinCountAfter(metrics.getAfterVoltageUnderVminCount());
+            detailVoltage.setMinVoltagePu(metrics.getAfterVoltageMinVmPu());
+            vo.setDetailVoltage(detailVoltage);
+
+            // 损耗详细指标
+            ReconSchemeVO.DetailLoss detailLoss = new ReconSchemeVO.DetailLoss();
+            detailLoss.setLineLossMwBefore(metrics.getBeforeLossLineLossMw());
+            detailLoss.setLineLossMwAfter(metrics.getAfterLossLineLossMw());
+            detailLoss.setTrafoLossMwBefore(metrics.getBeforeLossTrafoLossMw());
+            detailLoss.setTrafoLossMwAfter(metrics.getAfterLossTrafoLossMw());
+            vo.setDetailLoss(detailLoss);
+
+            // 五维度评分
+            ReconSchemeVO.Dimensions dimensions = new ReconSchemeVO.Dimensions();
+            dimensions.setSafetyScore(metrics.getAfterHealthComponentSafe());
+            dimensions.setVoltageScore(metrics.getAfterHealthComponentVoltage());
+            dimensions.setLossScore(metrics.getAfterHealthComponentLoss());
+            dimensions.setBalanceScore(metrics.getAfterHealthComponentBalance());
+            dimensions.setRiskScore(metrics.getAfterHealthComponentRisk());
+            vo.setDimensions(dimensions);
+        }
+        return vo;
+    }
+
+    private ReconSwitchSeqVO buildSwitchSeqVO(FhzgReconSwitchSeq seq, Boolean safetyCheckPassed) {
+        ReconSwitchSeqVO vo = new ReconSwitchSeqVO();
+        vo.setSeqNo(seq.getSeqNo());
+        vo.setCloseName(seq.getCloseName());
+        vo.setCloseOperation(convertOperationType(seq.getCloseOperationType()));
+        vo.setOpenName(seq.getOpenName());
+        vo.setOpenOperation(convertOperationType(seq.getOpenOperationType()));
+        vo.setIsThreeRemotely(isThreeRemotely(seq.getCloseAutoType()));
+        vo.setHotCheckPassed(seq.getHotCheckIsSafe());
+        vo.setSafetyCheckPassed(safetyCheckPassed);
+        return vo;
+    }
+
+    private ReconFeederCompareVO buildFeederCompareVO(FhzgReconFeederResult feeder) {
+        ReconFeederCompareVO vo = new ReconFeederCompareVO();
+        vo.setFeederNo(feeder.getFeederNo());
+        vo.setFeederName(feeder.getName());
+        vo.setFlowType(determineFlowType(feeder));
+        vo.setRatedCurrent(feeder.getRateCurrent());
+        vo.setCurrentBefore(feeder.getBeforeI());
+        vo.setCurrentAfter(feeder.getAfterI());
+        vo.setLoadingBefore(calcLoadingPct(feeder.getBeforeI(), feeder.getRateCurrent()));
+        vo.setLoadingAfter(calcLoadingPct(feeder.getAfterI(), feeder.getRateCurrent()));
+        vo.setLoadingChange(calcLoadingChange(feeder.getBeforeI(), feeder.getAfterI(), feeder.getRateCurrent()));
+        vo.setLineLossRateBefore(feeder.getLineLossBefore());
+        vo.setLineLossRateAfter(feeder.getLineLossAfter());
+        return vo;
+    }
+
+    private ReconLoadpointCompareVO buildLoadpointCompareVO(FhzgReconVolDetail detail) {
+        ReconLoadpointCompareVO vo = new ReconLoadpointCompareVO();
+        vo.setDetailNo(detail.getDetailNo());
+        vo.setLoadPointName(detail.getName());
+        vo.setLoadType(detail.getLoadType());
+        vo.setVoltageBefore(detail.getBeforeU());
+        vo.setVoltageAfter(detail.getAfterU());
+        vo.setLowVoltageBefore(detail.getBeforeUlv());
+        vo.setLowVoltageAfter(detail.getAfterUlv());
+        vo.setActivePowerBefore(detail.getBeforeP());
+        vo.setReactivePowerBefore(detail.getBeforeQ());
+        return vo;
+    }
+
+    private ReconSwitchCompareVO buildSwitchCompareVO(FhzgReconSwitchResultDetail detail) {
+        ReconSwitchCompareVO vo = new ReconSwitchCompareVO();
+        vo.setDetailNo(detail.getDetailNo());
+        vo.setSwitchName(detail.getPsrId());
+        vo.setStateChange(buildStateChange(detail.getBeforeState(), detail.getAfterState()));
+        vo.setCurrentBefore(detail.getBeforeI());
+        vo.setCurrentAfter(detail.getAfterI());
+        vo.setVoltageBefore(detail.getBeforeU());
+        vo.setVoltageAfter(detail.getAfterU());
+        return vo;
+    }
+
+    private void validatePageParam(ReconPageReqDTO reqDTO) {
+        if (Objects.isNull(reqDTO.getResultId())) {
+            throw new BusinessException("方案ID为空");
+        }
+        if (Objects.isNull(reqDTO.getPageNum())) {
+            throw new BusinessException("分页页码为空");
+        }
+        if (Objects.isNull(reqDTO.getPageSize())) {
+            throw new BusinessException("分页长度为空");
+        }
+    }
+
+    /** close→合, open→分 */
+    private String convertOperationType(String operationType) {
+        if ("close".equals(operationType)) {
+            return "合";
+        }
+        if ("open".equals(operationType)) {
+            return "分";
+        }
+        return operationType;
+    }
+
+    /** 判断是否三遥开关 */
+    private Boolean isThreeRemotely(String autoType) {
+        return "three_remotely".equals(autoType);
+    }
+
+    /** 计算负载率(%) = 电流 / 额定电流 * 100 */
+    private BigDecimal calcLoadingPct(BigDecimal current, BigDecimal ratedCurrent) {
+        if (Objects.isNull(current) || Objects.isNull(ratedCurrent) || ratedCurrent.compareTo(BigDecimal.ZERO) == 0) {
+            return null;
+        }
+        return current.divide(ratedCurrent, 4, RoundingMode.HALF_UP)
+                .multiply(new BigDecimal(100));
+    }
+
+    /** 计算负载率变化(%) */
+    private BigDecimal calcLoadingChange(BigDecimal beforeI, BigDecimal afterI, BigDecimal ratedCurrent) {
+        BigDecimal before = calcLoadingPct(beforeI, ratedCurrent);
+        BigDecimal after = calcLoadingPct(afterI, ratedCurrent);
+        if (Objects.isNull(before) || Objects.isNull(after)) {
+            return null;
+        }
+        return after.subtract(before);
+    }
+
+    /** 判断流向类型 */
+    private String determineFlowType(FhzgReconFeederResult feeder) {
+        if (Objects.isNull(feeder.getBeforeI()) || Objects.isNull(feeder.getAfterI())) {
+            return null;
+        }
+        if (feeder.getAfterI().compareTo(feeder.getBeforeI()) > 0) {
+            return "流入馈线";
+        }
+        return "流出馈线";
+    }
+
+    /** 构建状态变化描述 */
+    private String buildStateChange(String beforeState, String afterState) {
+        String before = convertState(beforeState);
+        String after = convertState(afterState);
+        if (before.equals(after)) {
+            return "-";
+        }
+        return before + "→" + after;
+    }
+
+    /** open→分, close→合 */
+    private String convertState(String state) {
+        if ("close".equals(state)) {
+            return "合";
+        }
+        if ("open".equals(state)) {
+            return "分";
+        }
+        return state;
+    }
+
+    /** 两个Integer求和（null安全） */
+    private Integer sumInt(Integer a, Integer b) {
+        int sum = 0;
+        if (Objects.nonNull(a)) {
+            sum += a;
+        }
+        if (Objects.nonNull(b)) {
+            sum += b;
+        }
+        return sum;
+    }
+}