代码调整

2022-11-10 10:47:55 +08:00
parent de1c9a6209
commit 11048c17f1
130 changed files with 10553 additions and 0 deletions
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RStatPwPermeabilityMService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RStatPwPermeabilityMService.java
@@ -0,0 +1,26 @@
+package com.njcn.harmonic.service;
+
+import com.njcn.harmonic.pojo.param.RStatPwPermeabilityMParam;
+import com.njcn.harmonic.pojo.po.RStatPwPermeabilityM;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.vo.RStatPwPermeabilityMVO;
+
+import java.util.List;
+
+/**
+ * 各渗透率光伏台区基准水平
+* @author jianghf
+* @description 针对表【r_stat_pw_permeability_m】的数据库操作Service
+* @createDate 2022-11-07 10:35:21
+*/
+public interface RStatPwPermeabilityMService extends IService<RStatPwPermeabilityM> {
+
+    /***
+     * 获取各渗透率光伏台区基准水平
+     * @author jianghaifei
+     * @date 2022-11-07 14:38
+     * @param rStatPwPermeabilityMParam
+     * @return java.util.List<com.njcn.harmonic.pojo.vo.RStatPwPermeabilityMVO>
+     */
+    List<RStatPwPermeabilityMVO> getPwPermeabilityList(RStatPwPermeabilityMParam rStatPwPermeabilityMParam);
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/distribution/PwRStatOrgService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/distribution/PwRStatOrgService.java
@@ -0,0 +1,37 @@
+package com.njcn.harmonic.service.distribution;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatOrgQ;
+import com.njcn.harmonic.pojo.vo.PwRStatOrgVO;
+import com.njcn.harmonic.pojo.vo.RStatOrgIndexVO;
+import com.njcn.harmonic.pojo.vo.RStatOrgVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 配网区域分类统计月表 服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-11-08
+ */
+public interface PwRStatOrgService extends IService<RStatOrgQ> {
+
+    /**
+     * 配网查询区域超标统计
+     * @param param
+     * @return
+     */
+    List<RStatOrgVO.PwRStatOrgVO> getRStatHarmonicAll(StatSubstationBizBaseParam param);
+
+    /**
+     * 配网区域稳态指标合格率统计表
+     *
+     * @param param
+     * @return
+     */
+    List<PwRStatOrgVO> getRStatOrgIndex(StatSubstationBizBaseParam param);
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/distribution/impl/PwRStatOrgServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/distribution/impl/PwRStatOrgServiceImpl.java
@@ -0,0 +1,143 @@
+package com.njcn.harmonic.service.distribution.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollectionUtil;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.common.pojo.constant.BizParamConstant;
+import com.njcn.device.pms.api.PwMonitorClient;
+import com.njcn.device.pms.pojo.dto.PwPmsMonitorDTO;
+import com.njcn.device.pms.pojo.param.PwPmsMonitorParam;
+import com.njcn.harmonic.mapper.distribution.PwRStatOrgMapper;
+import com.njcn.harmonic.mapper.majornetwork.RStatOrgMMapper;
+import com.njcn.harmonic.mapper.majornetwork.RStatOrgQMapper;
+import com.njcn.harmonic.mapper.majornetwork.RStatOrgYMapper;
+import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatOrgQ;
+import com.njcn.harmonic.pojo.vo.PwRStatOrgVO;
+import com.njcn.harmonic.pojo.vo.RStatOrgVO;
+import com.njcn.harmonic.service.distribution.PwRStatOrgService;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataEnum;
+import com.njcn.system.pojo.po.DictData;
+import com.njcn.user.api.DeptFeignClient;
+import com.njcn.user.pojo.dto.DeptDTO;
+import com.njcn.web.utils.WebUtil;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.compress.utils.Lists;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 配网区域分类统计月表 服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-11-08
+ */
+@Service
+@RequiredArgsConstructor
+public class PwRStatOrgServiceImpl extends ServiceImpl<PwRStatOrgMapper, RStatOrgQ> implements PwRStatOrgService {
+
+    private final DeptFeignClient deptFeignClient;
+    private final DicDataFeignClient dicDataFeignClient;
+    private final PwRStatOrgMapper pwRStatOrgMapper;
+    private final RStatOrgYMapper rStatOrgYMapper;
+    private final RStatOrgQMapper rStatOrgQMapper;
+    private final RStatOrgMMapper rStatOrgMMapper;
+    private final PwMonitorClient pwMonitorClient;
+
+
+    @Override
+    public List<RStatOrgVO.PwRStatOrgVO> getRStatHarmonicAll(StatSubstationBizBaseParam param) {
+        List<DeptDTO> deptDTOList = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        //获取部门id集合
+        List<String> deptIds = deptDTOList.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        Map<String, DeptDTO> deptMap = deptDTOList.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+        //获取配网信息
+        DictData distributionData = dicDataFeignClient.getDicDataByCode(DicDataEnum.DISTRIBUTION_POINT.getCode()).getData();
+        List<RStatOrgVO.PwRStatOrgVO> info = new ArrayList<>();
+        List<RStatOrgVO.PwRStatOrgVO> newList = new ArrayList<>();
+        switch (String.valueOf(param.getType())) {
+            //查询区域超标统计-年数据
+            case BizParamConstant.STAT_BIZ_YEAR:
+                info = pwRStatOrgMapper.selectListY(param,deptIds,distributionData.getId());
+                break;
+            //查询区域超标统计-季数据
+            case BizParamConstant.STAT_BIZ_QUARTER:
+                info = pwRStatOrgMapper.selectListQ(param,deptIds,distributionData.getId());
+                break;
+            //查询各区域超标统计-月数据
+            case BizParamConstant.STAT_BIZ_MONTH:
+                info = pwRStatOrgMapper.selectListM(param,deptIds,distributionData.getId());
+                break;
+            default:
+                break;
+        }
+        if(CollectionUtil.isNotEmpty(info)){
+            Map<String, List<RStatOrgVO.PwRStatOrgVO>> collect = info.stream().collect(
+                    Collectors.groupingBy(RStatOrgVO.PwRStatOrgVO::getOrgNo));
+            collect.forEach((key, value) -> {
+                if (deptMap.containsKey(key)) {
+                    for (RStatOrgVO.PwRStatOrgVO org : value) {
+                        DeptDTO deptDTO = deptMap.get(key);
+                        org.setOrgName(deptDTO.getName());
+                        newList.add(org);
+                    }
+                }
+            });
+            return newList;
+        }
+       return Lists.newArrayList();
+    }
+
+    @Override
+    public List<PwRStatOrgVO> getRStatOrgIndex(StatSubstationBizBaseParam param) {
+        // 获取当前用户的部门的子部门信息
+        PwPmsMonitorParam pwPmsMonitorParam=new PwPmsMonitorParam();
+        pwPmsMonitorParam.setOrgId(param.getId());
+        pwPmsMonitorParam.setMonitorSort(param.getIds());
+        List<PwPmsMonitorDTO> data = pwMonitorClient.getPwMonitorList(pwPmsMonitorParam).getData();
+        //获取配网信息
+        DictData distributionData = dicDataFeignClient.getDicDataByCode(DicDataEnum.DISTRIBUTION_POINT.getCode()).getData();
+        List<PwRStatOrgVO> info=new ArrayList<>();
+        if (CollectionUtil.isNotEmpty(data)) {
+            // 过滤出部门id
+            List<String> deptIds = data.stream().map(PwPmsMonitorDTO::getOrgId).collect(Collectors.toList());
+            StatSubstationBizBaseParam baseParam = BeanUtil.copyProperties(param, StatSubstationBizBaseParam.class);
+            baseParam.setIds(deptIds);
+            // 类型（1年 2季度 3月份 4日
+            switch (param.getType().toString()) {
+                case BizParamConstant.STAT_BIZ_YEAR:
+                    // 获取年区域稳态指标合格率统计表
+                    info = rStatOrgYMapper.getPwYearRStatOrgIndex(baseParam, distributionData.getId());
+                    break;
+                case BizParamConstant.STAT_BIZ_QUARTER:
+                    // 获取季区域稳态指标合格率统计表
+                    info = rStatOrgQMapper.getPwQuarterRStatOrgIndex(baseParam, distributionData.getId());
+                    break;
+                case BizParamConstant.STAT_BIZ_MONTH:
+                    // 获取月区域稳态指标合格率统计表
+                    info = rStatOrgMMapper.getPwMonthRStatOrgIndex(baseParam, distributionData.getId());
+                    break;
+                default:
+                    break;
+            }
+        }
+        //匹配名称
+        for (PwPmsMonitorDTO dto : data) {
+            for (PwRStatOrgVO vo : info) {
+                if (dto.getOrgId().equals(vo.getOrgNo())) {
+                    vo.setOrgNo(dto.getOrgId());
+                    vo.setOrgName(dto.getOrgName());
+                }
+            }
+        }
+        return info;
+    }
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RStatPwPermeabilityMServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RStatPwPermeabilityMServiceImpl.java
@@ -0,0 +1,85 @@
+package com.njcn.harmonic.service.impl;
+
+import cn.hutool.core.collection.CollUtil;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.device.pms.api.PwMonitorClient;
+import com.njcn.device.pms.pojo.dto.PwPmsMonitorDTO;
+import com.njcn.device.pms.pojo.param.PwPmsMonitorParam;
+import com.njcn.harmonic.mapper.RStatPwPermeabilityMMapper;
+import com.njcn.harmonic.pojo.param.RStatPwPermeabilityMParam;
+import com.njcn.harmonic.pojo.po.RStatPwPermeabilityM;
+import com.njcn.harmonic.pojo.vo.RStatPwPermeabilityMVO;
+import com.njcn.harmonic.service.RStatPwPermeabilityMService;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataTypeEnum;
+import com.njcn.system.pojo.po.DictData;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * 各渗透率光伏台区基准水平
+* @author jianghf
+* @description 针对表【r_stat_pw_permeability_m】的数据库操作Service实现
+* @createDate 2022-11-07 10:35:21
+*/
+@Service
+@RequiredArgsConstructor
+public class RStatPwPermeabilityMServiceImpl extends ServiceImpl<RStatPwPermeabilityMMapper, RStatPwPermeabilityM>
+    implements RStatPwPermeabilityMService{
+
+    private final PwMonitorClient pwMonitorClient;
+
+    private final DicDataFeignClient dicDataFeignClient;
+
+
+    /***
+     * 获取各渗透率光伏台区基准水平
+     * @author jianghaifei
+     * @date 2022-11-07 14:38
+     * @param rStatPwPermeabilityMParam
+     * @return java.util.List<com.njcn.harmonic.pojo.vo.RStatPwPermeabilityMVO>
+     */
+    @Override
+    public List<RStatPwPermeabilityMVO> getPwPermeabilityList(RStatPwPermeabilityMParam rStatPwPermeabilityMParam) {
+        //提起参数
+        String id = rStatPwPermeabilityMParam.getId(); //单位id
+        String psrName = rStatPwPermeabilityMParam.getPsrName(); //台区名称
+        String startTime = rStatPwPermeabilityMParam.getStartTime(); //开始时间
+        String endTime = rStatPwPermeabilityMParam.getEndTime(); //结束时间
+
+        //根据条件查询单位下面的所有配网监测点
+        PwPmsMonitorParam pwPmsMonitorParam = new PwPmsMonitorParam();
+        pwPmsMonitorParam.setOrgId(id); //单位id
+        pwPmsMonitorParam.setMonitorName(psrName); //台区名称（监测点名称）
+        List<PwPmsMonitorDTO> pwMonitorList = pwMonitorClient.getPwMonitorList(pwPmsMonitorParam).getData();
+        if (CollUtil.isEmpty(pwMonitorList)) {
+            return new ArrayList<>();
+        }
+        //监测点id集合
+        List<String> monitorIdList = pwMonitorList.stream().map(PwPmsMonitorDTO::getMonitorId).collect(Collectors.toList());
+        //监测点map  key:监测点id  value:监测点实体
+        Map<String, PwPmsMonitorDTO> monitorMap = pwMonitorList.stream().collect(Collectors.toMap(PwPmsMonitorDTO::getMonitorId, monitor -> monitor));
+
+        //获取各渗透率字典
+        List<DictData> rateList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.PERMEABILITY_TYPE.getCode()).getData();
+        Map<String, Object> condMap = rateList.stream().collect(Collectors.toMap(DictData::getCode, DictData::getId));
+        condMap.put("startTime", startTime);
+        condMap.put("endTime", endTime);
+        condMap.put("idList", monitorIdList);
+        List<RStatPwPermeabilityMVO> list = this.baseMapper.getPwPermeabilityList(condMap);
+        list = list.stream().peek(item -> {
+            item.setOrgName(monitorMap.get(item.getPsrId()).getOrgName()); //单位名称
+            item.setPsrName(monitorMap.get(item.getPsrId()).getMonitorName()); //台区名称
+        }).collect(Collectors.toList());
+        return list;
+    }
+}
+
+
+
+
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RMpPartHarmonicDetailDService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RMpPartHarmonicDetailDService.java
@@ -0,0 +1,27 @@
+package com.njcn.harmonic.service.majornetwork;
+
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.po.RMpPartHarmonicDetailD;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.vo.RMpPartHarmonicDetailIconVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-24
+ */
+public interface RMpPartHarmonicDetailDService extends IService<RMpPartHarmonicDetailD> {
+
+    /**
+     * 稳态指标超标明细表-指标趋势图
+     *
+     * @param param
+     * @return
+     */
+    List<RMpPartHarmonicDetailIconVO> getRMpPartHarmonicDetailIcon(StatisticsBizBaseParam param);
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RMpPartHarmonicDetailMService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RMpPartHarmonicDetailMService.java
@@ -0,0 +1,29 @@
+package com.njcn.harmonic.service.majornetwork;
+
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.param.RStatOrgParam;
+import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
+import com.njcn.harmonic.pojo.po.RMpPartHarmonicDetailM;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.vo.RMpPartHarmonicDetailVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-24
+ */
+public interface RMpPartHarmonicDetailMService extends IService<RMpPartHarmonicDetailM> {
+
+    /**
+     * 稳态指标超标明细表
+     *
+     * @param param
+     * @return
+     */
+    List<RMpPartHarmonicDetailVO> getRMpPartHarmonicDetail(RStatOrgParam param);
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RMpPassRateService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RMpPassRateService.java
@@ -0,0 +1,29 @@
+package com.njcn.harmonic.service.majornetwork;
+
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.param.RStatOrgParam;
+import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
+import com.njcn.harmonic.pojo.po.RMpPassRateQ;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.vo.RStatOrgIndexVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-24
+ */
+public interface RMpPassRateService extends IService<RMpPassRateQ> {
+
+    /**
+     * 稳态指标合格率明细表
+     *
+     * @param param
+     * @return
+     */
+    List<RStatOrgIndexVO> getRMpPassRateInfo(RStatOrgParam param);
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatHarmonicMService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatHarmonicMService.java
@@ -0,0 +1,57 @@
+package com.njcn.harmonic.service.majornetwork;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.param.RStatHarmonicMParam;
+import com.njcn.harmonic.pojo.po.RStatHarmonicM;
+import com.njcn.harmonic.pojo.vo.RArrayVO;
+import com.njcn.harmonic.pojo.vo.RHarmonicPolylineVO;
+import com.njcn.harmonic.pojo.vo.RIconVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ *  服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-09
+ */
+public interface RStatHarmonicMService extends IService<RStatHarmonicM> {
+
+    /**
+     * 主网查询查询监测点稳态指标 日/月点数
+     * @param param
+     * @return
+     */
+    List<RArrayVO> getRStatHarmonicMAll(StatisticsBizBaseParam param);
+
+    /**
+     * 主网稳态电铁-频率偏差-电压统计图
+     * @param param
+     * @return
+     */
+    List<RIconVO> getRStatHarmonicIconVoltage(RStatHarmonicMParam param);
+
+    /**
+     * 主网稳态电铁-频率偏差-越线日期统计图
+     * @param param
+     * @return
+     */
+    List<RHarmonicPolylineVO> getRStatHarmonicIconDate(RStatHarmonicMParam param);
+
+    /**
+     * 配网查询监测点稳态指标（月）
+     * @param param
+     * @return
+     */
+    List<RArrayVO> getPwRStatHarmonicMAll(StatisticsBizBaseParam param);
+
+    /**
+     * 配网监测点-频率偏差-越线日期统计图
+     * @param param
+     * @return
+     */
+    List<RHarmonicPolylineVO> getPwRStatHarmonicIconDate(RStatHarmonicMParam param);
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatHarmonicOrgMService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatHarmonicOrgMService.java
@@ -0,0 +1,53 @@
+package com.njcn.harmonic.service.majornetwork;
+
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.param.RStatHarmonicMParam;
+import com.njcn.harmonic.pojo.po.RStatHarmonicOrgM;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.vo.RArrayVO;
+import com.njcn.harmonic.pojo.vo.RIconVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-14
+ */
+public interface RStatHarmonicOrgMService extends IService<RStatHarmonicOrgM> {
+
+    /**
+     * 主网查询各单位稳态指标（月）
+     *
+     * @param param
+     * @return
+     */
+    List<RArrayVO> getRStatHarmonicMAll(StatisticsBizBaseParam param);
+
+    /**
+     * 主网查询各单位累计超标监测点数统计图-月数据
+     *
+     * @param param
+     * @return
+     */
+    List<RIconVO> getRStatHarmonicOrgMIcon(RStatHarmonicMParam param);
+
+    /**
+     * 配网查询各单位稳态指标（月）
+     *
+     * @param param
+     * @return
+     */
+    List<RArrayVO> getPwRStatHarmonicMAll(StatisticsBizBaseParam param);
+
+    /**
+     * 配网查询各单位累计超标监测点数统计图-月数据
+     *
+     * @param param
+     * @return
+     */
+    List<RIconVO> getPwRStatHarmonicOrgMIcon(RStatHarmonicMParam param);
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatHarmonicOrgQService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatHarmonicOrgQService.java
@@ -0,0 +1,53 @@
+package com.njcn.harmonic.service.majornetwork;
+
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.param.RStatHarmonicMParam;
+import com.njcn.harmonic.pojo.po.RStatHarmonicOrgQ;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.vo.RArrayVO;
+import com.njcn.harmonic.pojo.vo.RIconVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-14
+ */
+public interface RStatHarmonicOrgQService extends IService<RStatHarmonicOrgQ> {
+
+    /**
+     * 主网查询各单位稳态指标（季）
+     *
+     * @param param
+     * @return
+     */
+    List<RArrayVO> getRStatHarmonicQAll(StatisticsBizBaseParam param);
+
+    /**
+     * 主网查询各单位累计超标监测点数统计图-季数据
+     *
+     * @param param
+     * @return
+     */
+    List<RIconVO> getRStatHarmonicOrgQIcon(RStatHarmonicMParam param);
+
+    /**
+     * 配网网查询各单位稳态指标（季）
+     *
+     * @param param
+     * @return
+     */
+    List<RArrayVO> getPwRStatHarmonicQAll(StatisticsBizBaseParam param);
+
+    /**
+     * 配网查询各单位累计超标监测点数统计图-季数据
+     *
+     * @param param
+     * @return
+     */
+    List<RIconVO> getPwRStatHarmonicOrgQIcon(RStatHarmonicMParam param);
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatHarmonicOrgYService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatHarmonicOrgYService.java
@@ -0,0 +1,53 @@
+package com.njcn.harmonic.service.majornetwork;
+
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.param.RStatHarmonicMParam;
+import com.njcn.harmonic.pojo.po.RStatHarmonicOrgY;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.vo.RArrayVO;
+import com.njcn.harmonic.pojo.vo.RIconVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-14
+ */
+public interface RStatHarmonicOrgYService extends IService<RStatHarmonicOrgY> {
+
+    /**
+     * 主网查询各单位稳态指标（年）
+     *
+     * @param param
+     * @return
+     */
+    List<RArrayVO> getRStatHarmonicYAll(StatisticsBizBaseParam param);
+
+    /**
+     * 主网各单位累计超标监测点数统计图-年数据
+     *
+     * @param param
+     * @return
+     */
+    List<RIconVO> getRStatHarmonicOrgYIcon(RStatHarmonicMParam param);
+
+    /**
+     * 配网查询各单位稳态指标（年）
+     *
+     * @param param
+     * @return
+     */
+    List<RArrayVO> getPwRStatHarmonicYAll(StatisticsBizBaseParam param);
+
+    /**
+     * 配网各单位累计超标监测点数统计图-年数据
+     *
+     * @param param
+     * @return
+     */
+    List<RIconVO> getPwRStatHarmonicOrgYIcon(RStatHarmonicMParam param);
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatHarmonicQService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatHarmonicQService.java
@@ -0,0 +1,33 @@
+package com.njcn.harmonic.service.majornetwork;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatHarmonicQ;
+import com.njcn.harmonic.pojo.vo.RArrayVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ *  服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-12
+ */
+public interface RStatHarmonicQService extends IService<RStatHarmonicQ> {
+
+    /**
+     * 主网查询监测点稳态指标（季）
+     * @param param
+     * @return
+     */
+    List<RArrayVO> getRStatHarmonicQAll(StatisticsBizBaseParam param);
+
+    /**
+     *  配网查询监测点稳态指标（季）
+     * @param param
+     * @return
+     */
+    List<RArrayVO> getPwRStatHarmonicQAll(StatisticsBizBaseParam param);
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatHarmonicYService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatHarmonicYService.java
@@ -0,0 +1,36 @@
+package com.njcn.harmonic.service.majornetwork;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatHarmonicY;
+import com.njcn.harmonic.pojo.vo.RArrayVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-12
+ */
+public interface RStatHarmonicYService extends IService<RStatHarmonicY> {
+
+    /**
+     * 主网查询监测点稳态指标（年）
+     *
+     * @param param
+     * @return
+     */
+    List<RArrayVO> getRStatHarmonicYAll(StatisticsBizBaseParam param);
+
+    /**
+     * 配网查询监测点稳态指标（年）
+     *
+     * @param param
+     * @return
+     */
+    List<RArrayVO> getPwRStatHarmonicYAll(StatisticsBizBaseParam param);
+
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatLoadTypeService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatLoadTypeService.java
@@ -0,0 +1,26 @@
+package com.njcn.harmonic.service.majornetwork;
+
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatLoadTypeM;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.vo.RArrayVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ *  服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-19
+ */
+public interface RStatLoadTypeService extends IService<RStatLoadTypeM> {
+
+    /**
+     * 区域干扰源电流类指标超标统计
+     * @param param
+     * @return
+     */
+    List<RArrayVO> getRStatLoadType(StatisticsBizBaseParam param);
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatOrgBusbarVoltageService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatOrgBusbarVoltageService.java
@@ -0,0 +1,27 @@
+package com.njcn.harmonic.service.majornetwork;
+
+import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatOrgBusbarVoltageM;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.vo.RStatOrgBusbarVoltageVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-19
+ */
+public interface RStatOrgBusbarVoltageService extends IService<RStatOrgBusbarVoltageM> {
+
+    /**
+     * 区域电站母线电压类指标超标计
+     *
+     * @param param
+     * @return
+     */
+    List<RStatOrgBusbarVoltageVO> getRStatOrgBusbarVoltage(StatSubstationBizBaseParam param);
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatOrgMService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatOrgMService.java
@@ -0,0 +1,26 @@
+package com.njcn.harmonic.service.majornetwork;
+
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatOrgM;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.vo.RStatOrgVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 区域分类统计月表 服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-17
+ */
+public interface RStatOrgMService extends IService<RStatOrgM> {
+
+    /**
+     * 查询区域超标统计-月数据
+     * @param param
+     * @return
+     */
+    List<RStatOrgVO> getRStatHarmonicMAll(StatisticsBizBaseParam param);
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatOrgQService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatOrgQService.java
@@ -0,0 +1,26 @@
+package com.njcn.harmonic.service.majornetwork;
+
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatOrgQ;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.vo.RStatOrgVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 区域分类统计季表 服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-17
+ */
+public interface RStatOrgQService extends IService<RStatOrgQ> {
+
+    /**
+     * 查询区域超标统计-季数据
+     * @param param
+     * @return
+     */
+    List<RStatOrgVO> getRStatHarmonicQAll(StatisticsBizBaseParam param);
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatOrgYService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatOrgYService.java
@@ -0,0 +1,54 @@
+package com.njcn.harmonic.service.majornetwork;
+
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatOrgY;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.vo.*;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 区域分类统计年表 服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-17
+ */
+public interface RStatOrgYService extends IService<RStatOrgY> {
+
+    /**
+     * 查询区域超标统计-年数据
+     *
+     * @param param
+     * @return
+     */
+    List<RStatOrgVO> getRStatHarmonicYAll(StatisticsBizBaseParam param);
+
+    /**
+     * 区域稳态指标超标分类统计表
+     *
+     * @param param
+     * @return
+     */
+    List<RStatSubstationOrg2VO> getRStatSubstationOrg(StatisticsBizBaseParam param);
+
+    /**
+     * 变电站（换流站）稳态指标超标分类统计表
+     *
+     * @param param
+     * @return
+     */
+    List<RSubstationIcon2VO.RSubstationInfoVO> getRStatSubstation(StatSubstationBizBaseParam param);
+
+    /**
+     * 区域稳态指标合格率统计表
+     *
+     * @param param
+     * @return
+     */
+    List<RStatOrgIndexVO.RStatOrgIndexInfoVO> getRStatOrgIndex(StatisticsBizBaseParam param);
+
+
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatSubstationMService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatSubstationMService.java
@@ -0,0 +1,36 @@
+package com.njcn.harmonic.service.majornetwork;
+
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatSubstationM;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.vo.RSubstationIcon2VO;
+import com.njcn.harmonic.pojo.vo.RSubstationIconVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-18
+ */
+public interface RStatSubstationMService extends IService<RStatSubstationM> {
+
+    /**
+     * 变电站稳态指标超标分布（按超标天数）
+     *
+     * @param param
+     * @return
+     */
+    RSubstationIconVO getStatSubstationIcon(StatisticsBizBaseParam param);
+
+    /**
+     * 变电站稳态指标平均超标天数
+     *
+     * @param param
+     * @return
+     */
+    List<RSubstationIcon2VO> getStatSubstationIcon2(StatisticsBizBaseParam param);
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatSubstationVoltageMService.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatSubstationVoltageMService.java
@@ -0,0 +1,28 @@
+package com.njcn.harmonic.service.majornetwork;
+
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatSubstationVoltageM;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.vo.RVoltageIconVO;
+
+import java.util.List;
+
+/**
+ * <p>
+ *  服务类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-18
+ */
+public interface RStatSubstationVoltageMService extends IService<RStatSubstationVoltageM> {
+
+    /**
+     * 变电站稳态指标超标分布（按电压等级）
+     * @param param
+     * @return
+     */
+    List<RVoltageIconVO> getStatSubstationIcon(StatisticsBizBaseParam param);
+
+
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RMpPartHarmonicDetailDServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RMpPartHarmonicDetailDServiceImpl.java
@@ -0,0 +1,33 @@
+package com.njcn.harmonic.service.majornetwork.impl;
+
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.po.RMpPartHarmonicDetailD;
+import com.njcn.harmonic.mapper.majornetwork.RMpPartHarmonicDetailDMapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.harmonic.pojo.vo.RMpPartHarmonicDetailIconVO;
+import com.njcn.harmonic.service.majornetwork.RMpPartHarmonicDetailDService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-24
+ */
+@Service
+@RequiredArgsConstructor
+public class RMpPartHarmonicDetailDServiceImpl extends ServiceImpl<RMpPartHarmonicDetailDMapper, RMpPartHarmonicDetailD> implements RMpPartHarmonicDetailDService {
+
+    private final RMpPartHarmonicDetailDMapper rMpPartHarmonicDetailDMapper;
+
+
+    @Override
+    public List<RMpPartHarmonicDetailIconVO> getRMpPartHarmonicDetailIcon(StatisticsBizBaseParam param) {
+        return rMpPartHarmonicDetailDMapper.getRMpPartHarmonicDetailIcon(param);
+    }
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RMpPartHarmonicDetailMServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RMpPartHarmonicDetailMServiceImpl.java
@@ -0,0 +1,105 @@
+package com.njcn.harmonic.service.majornetwork.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollectionUtil;
+import com.njcn.common.pojo.dto.SimpleDTO;
+import com.njcn.device.pms.api.MonitorClient;
+import com.njcn.device.pms.api.PmsGeneralDeviceInfoClient;
+import com.njcn.device.pms.pojo.dto.PmsGeneralDeviceDTO;
+import com.njcn.device.pms.pojo.dto.PmsMonitorDTO;
+import com.njcn.device.pms.pojo.param.PmsDeviceInfoParam;
+import com.njcn.device.pms.pojo.param.PmsMonitorParam;
+import com.njcn.harmonic.mapper.majornetwork.RMpSurplusHarmonicDetailMMapper;
+import com.njcn.harmonic.pojo.param.RStatOrgParam;
+import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
+import com.njcn.harmonic.pojo.po.RMpPartHarmonicDetailM;
+import com.njcn.harmonic.mapper.majornetwork.RMpPartHarmonicDetailMMapper;
+import com.njcn.harmonic.pojo.vo.RMpPartHarmonicDetailVO;
+import com.njcn.harmonic.service.majornetwork.RMpPartHarmonicDetailMService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataTypeEnum;
+import com.njcn.system.pojo.po.DictData;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-24
+ */
+@Service
+@RequiredArgsConstructor
+public class RMpPartHarmonicDetailMServiceImpl extends ServiceImpl<RMpPartHarmonicDetailMMapper, RMpPartHarmonicDetailM> implements RMpPartHarmonicDetailMService {
+
+    private final RMpSurplusHarmonicDetailMMapper rMpSurplusHarmonicDetailMMapper;
+    private final PmsGeneralDeviceInfoClient pmsGeneralDeviceInfoClient;
+    private final MonitorClient monitorClient;
+    private final DicDataFeignClient dicDataFeignClient;
+
+    @Override
+    public List<RMpPartHarmonicDetailVO> getRMpPartHarmonicDetail(RStatOrgParam param) {
+        //根据部门获取监测点信息(根据部门过滤基本信息)
+        PmsDeviceInfoParam pms = new PmsDeviceInfoParam();
+        pms.setDeptIndex(param.getId());
+        pms.setStatisticalType(new SimpleDTO());
+        List<PmsGeneralDeviceDTO> data = pmsGeneralDeviceInfoClient.getPmsDeviceInfoWithInOrg(pms).getData();
+        List<String> addIds = new ArrayList<>();
+        data.stream().forEach(e -> addIds.addAll(e.getMonitorIdList()));
+
+        if (CollectionUtil.isNotEmpty(addIds)) {
+            //根据监测点ids获取监测点相关详细信息(变电站id，电压id，监测点名称)
+            PmsMonitorParam dto = BeanUtil.copyProperties(param, PmsMonitorParam.class);
+            dto.setMonitorIds(addIds);
+            dto.setMonitorName(param.getMonitorName());
+            dto.setVoltageLevels(param.getVoltageLevels());
+            dto.setPowerrIds(param.getPowerrIds());
+            List<PmsMonitorDTO> pmsMonitorDTOS = monitorClient.getMonitorInfoListByCond(dto).getData();
+            Map<String, PmsMonitorDTO> pmsMonitorDTOMap = pmsMonitorDTOS.stream()
+                    .collect(Collectors.toMap(PmsMonitorDTO::getId, Function.identity()));
+            //获取电压等级
+            List<DictData> devVoltageData = dicDataFeignClient.getDicDataByTypeCode(
+                    DicDataTypeEnum.DEV_VOLTAGE.getCode()).getData();
+            Map<String, DictData> devVoltageMap = devVoltageData.stream()
+                    .collect(Collectors.toMap(DictData::getId, Function.identity()));
+            //获取最新过滤的监测点id
+            List<String> ids = pmsMonitorDTOS.stream().map(PmsMonitorDTO::getId).collect(Collectors.toList());
+            //筛选出数据库对应监测点
+            StatSubstationBizBaseParam baseParam = BeanUtil.copyProperties(param, StatSubstationBizBaseParam.class);
+            baseParam.setIds(ids);
+            List<RMpPartHarmonicDetailVO> rMpPartHarmonicDetail = rMpSurplusHarmonicDetailMMapper.getRMpPartHarmonicDetail(baseParam);
+            if (CollectionUtil.isNotEmpty(rMpPartHarmonicDetail)) {
+                //因为只有月表，数据进行查询可能出现重复数据。进行分组
+                Map<String, List<RMpPartHarmonicDetailVO>> detailVOMap = rMpPartHarmonicDetail.stream()
+                        .collect(Collectors.groupingBy(RMpPartHarmonicDetailVO::getMeasurementPointId));
+                detailVOMap.forEach((Key, value) -> {
+                    if (pmsMonitorDTOMap.containsKey(Key)) {
+                        PmsMonitorDTO dto1 = pmsMonitorDTOMap.get(Key);
+                        for (RMpPartHarmonicDetailVO rmp : value) {
+                            rmp.setOrgName(dto1.getOrgName());
+                            rmp.setPowerrName(dto1.getPowerrName());
+                            rmp.setMeasurementPointName(dto1.getName());
+                            //获取字典电压等级名称
+                            if (devVoltageMap.containsKey(dto1.getVoltageLevel())) {
+                                DictData data1 = devVoltageMap.get(dto1.getVoltageLevel());
+                                rmp.setMonitorVoltageName(data1.getName());
+                            }
+                        }
+
+                    }
+                });
+            }
+            return rMpPartHarmonicDetail;
+        }
+        return null;
+    }
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RMpPassRateServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RMpPassRateServiceImpl.java
@@ -0,0 +1,130 @@
+package com.njcn.harmonic.service.majornetwork.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollectionUtil;
+import com.njcn.common.pojo.constant.BizParamConstant;
+import com.njcn.common.pojo.dto.SimpleDTO;
+import com.njcn.device.pms.api.MonitorClient;
+import com.njcn.device.pms.api.PmsGeneralDeviceInfoClient;
+import com.njcn.device.pms.pojo.dto.PmsGeneralDeviceDTO;
+import com.njcn.device.pms.pojo.dto.PmsMonitorDTO;
+import com.njcn.device.pms.pojo.param.PmsDeviceInfoParam;
+import com.njcn.device.pms.pojo.param.PmsMonitorParam;
+import com.njcn.harmonic.mapper.majornetwork.RMpPassRateMMapper;
+import com.njcn.harmonic.mapper.majornetwork.RMpPassRateYMapper;
+import com.njcn.harmonic.pojo.param.RStatOrgParam;
+import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
+import com.njcn.harmonic.pojo.po.RMpPassRateQ;
+import com.njcn.harmonic.mapper.majornetwork.RMpPassRateQMapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.harmonic.pojo.vo.RStatOrgIndexVO;
+import com.njcn.harmonic.service.majornetwork.RMpPassRateService;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataTypeEnum;
+import com.njcn.system.pojo.po.DictData;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-24
+ */
+@Service
+@RequiredArgsConstructor
+public class RMpPassRateServiceImpl extends ServiceImpl<RMpPassRateQMapper, RMpPassRateQ> implements RMpPassRateService {
+
+    private final RMpPassRateYMapper rMpPassRateYMapper;
+    private final RMpPassRateQMapper rMpPassRateQMapper;
+    private final RMpPassRateMMapper rMpPassRateMMapper;
+    private final PmsGeneralDeviceInfoClient pmsGeneralDeviceInfoClient;
+    private final MonitorClient monitorClient;
+    private final DicDataFeignClient dicDataFeignClient;
+
+    @Override
+    public List<RStatOrgIndexVO> getRMpPassRateInfo(RStatOrgParam param) {
+        //初始化对象
+        List<RStatOrgIndexVO> temp = new ArrayList<>();
+        //根据部门获取监测点信息
+        PmsDeviceInfoParam pms = new PmsDeviceInfoParam();
+        pms.setDeptIndex(param.getId());
+        pms.setStatisticalType(new SimpleDTO());
+        List<PmsGeneralDeviceDTO> data = pmsGeneralDeviceInfoClient.getPmsDeviceInfoWithInOrg(pms).getData();
+        List<String> addIds = new ArrayList<>();
+        data.stream().forEach(e -> addIds.addAll(e.getMonitorIdList()));
+
+        if (CollectionUtil.isNotEmpty(addIds)) {
+            //根据监测点ids获取监测点相关详细信息(变电站id，电压id，监测点名称)
+            PmsMonitorParam dto = BeanUtil.copyProperties(param, PmsMonitorParam.class);
+            dto.setMonitorIds(addIds);
+            dto.setMonitorName(param.getMonitorName());
+            dto.setVoltageLevels(param.getVoltageLevels());
+            dto.setPowerrIds(param.getPowerrIds());
+            List<PmsMonitorDTO> pmsMonitorDTOS = monitorClient.getMonitorInfoListByCond(dto).getData();
+            Map<String, PmsMonitorDTO> pmsMonitorDTOMap = pmsMonitorDTOS.stream()
+                    .collect(Collectors.toMap(PmsMonitorDTO::getId, Function.identity()));
+            //获取电压等级
+            List<DictData> devVoltageData = dicDataFeignClient.getDicDataByTypeCode(
+                    DicDataTypeEnum.DEV_VOLTAGE.getCode()).getData();
+            Map<String, DictData> devVoltageMap = devVoltageData.stream()
+                    .collect(Collectors.toMap(DictData::getId, Function.identity()));
+
+            //获取最新过滤的监测点id
+            List<String> ids = pmsMonitorDTOS.stream().map(PmsMonitorDTO::getId).collect(Collectors.toList());
+            StatSubstationBizBaseParam baseParam = BeanUtil.copyProperties(param, StatSubstationBizBaseParam.class);
+            baseParam.setIds(ids);
+
+            if (CollectionUtil.isNotEmpty(addIds)) {
+                // 类型（1年 2季度 3月份
+                switch (param.getType().toString()) {
+                    case BizParamConstant.STAT_BIZ_YEAR:
+                        // 获取年稳态指标合格率明细表
+                        temp = rMpPassRateYMapper.getYearPassRate(baseParam);
+                        break;
+                    case BizParamConstant.STAT_BIZ_QUARTER:
+                        // 获取季稳态指标合格率明细表
+                        temp = rMpPassRateQMapper.getQuarterPassRate(baseParam);
+                        break;
+                    case BizParamConstant.STAT_BIZ_MONTH:
+                        // 获取月稳态指标合格率明细表
+                        temp = rMpPassRateMMapper.getMonthPassRate(baseParam);
+                        break;
+                    default:
+                        break;
+
+                }
+            }
+            if (CollectionUtil.isNotEmpty(temp)) {
+                Map<String, RStatOrgIndexVO> collect = temp.stream()
+                        .collect(Collectors.toMap(RStatOrgIndexVO::getMeasurementPointId, Function.identity()));
+                collect.forEach((Key, value) -> {
+                    if (pmsMonitorDTOMap.containsKey(Key)) {
+                        //根据监测点信息，进行属性赋值
+                        PmsMonitorDTO dto1 = pmsMonitorDTOMap.get(Key);
+                        value.setOrgNo(dto1.getOrgId());
+                        value.setOrgName(dto1.getOrgName());
+                        value.setMeasurementPointName(dto1.getName());
+                        value.setPowerrName(dto1.getPowerrName());
+                        //获取电压字典的名称
+                        if (devVoltageMap.containsKey(dto1.getVoltageLevel())) {
+                            DictData data1 = devVoltageMap.get(dto1.getVoltageLevel());
+                            value.setMonitorVoltageName(data1.getName());
+                        }
+                    }
+                });
+                return new ArrayList<>(collect.values());
+            }
+
+        }
+        return new ArrayList<>();
+    }
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatHarmonicMServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatHarmonicMServiceImpl.java
@@ -0,0 +1,608 @@
+package com.njcn.harmonic.service.majornetwork.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.date.LocalDateTimeUtil;
+import cn.hutool.core.lang.Assert;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.mapper.majornetwork.RStatHarmonicDMapper;
+import com.njcn.harmonic.mapper.majornetwork.RStatHarmonicMMapper;
+import com.njcn.harmonic.mapper.majornetwork.RStatHarmonicVoltageMMapper;
+import com.njcn.harmonic.pojo.param.RStatHarmonicMParam;
+import com.njcn.harmonic.pojo.po.RStatHarmonicD;
+import com.njcn.harmonic.pojo.po.RStatHarmonicM;
+import com.njcn.harmonic.pojo.po.RStatHarmonicVoltageM;
+import com.njcn.harmonic.pojo.vo.RArrayVO;
+import com.njcn.harmonic.pojo.vo.RHarmonicPolylineVO;
+import com.njcn.harmonic.pojo.vo.RIconVO;
+import com.njcn.harmonic.pojo.vo.RStatHarmonicMVO;
+import com.njcn.harmonic.service.majornetwork.RStatHarmonicMService;
+import com.njcn.device.pq.utils.PublicDateUtil;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataEnum;
+import com.njcn.system.enums.DicDataTypeEnum;
+import com.njcn.system.pojo.po.DictData;
+import lombok.RequiredArgsConstructor;
+import lombok.SneakyThrows;
+import org.springframework.stereotype.Service;
+
+import java.text.DecimalFormat;
+import java.text.SimpleDateFormat;
+import java.time.LocalDate;
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-09
+ */
+@Service
+@RequiredArgsConstructor
+public class RStatHarmonicMServiceImpl extends ServiceImpl<RStatHarmonicMMapper, RStatHarmonicM> implements RStatHarmonicMService {
+
+    private final RStatHarmonicMMapper rStatHarmonicMMapper;
+    private final DicDataFeignClient dicDataFeignClient;
+    private final RStatHarmonicVoltageMMapper rStatHarmonicVoltageMMapper;
+    private final RStatHarmonicDMapper rStatHarmonicDMapper;
+
+    @Override
+    public List<RArrayVO> getRStatHarmonicMAll(StatisticsBizBaseParam param) {
+
+        //子节点 获取所有得干扰源类型（监测点类型）
+        List<DictData> interferenceSourceTypeData = dicDataFeignClient.getDicDataByTypeCode(
+                DicDataTypeEnum.MONITORING_LABELS.getCode()).getData();
+        Map<String, DictData> interferenceMap = interferenceSourceTypeData.stream().collect(Collectors.toMap(DictData::getId, Function.identity()));
+
+        //对象主节点 获取所有得指标类型
+        List<DictData> lineTypeData = dicDataFeignClient.getDicDataByTypeCode(
+                DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+        Map<String, DictData> lineTypeMap = lineTypeData.stream()
+                .collect(Collectors.toMap(DictData::getId, Function.identity()));
+
+        //获取主网id信息
+        DictData mainnetData = dicDataFeignClient.getDicDataByCode(DicDataEnum.MAINNET_POINT.getCode()).getData();
+
+        //数据库查询
+        List<RStatHarmonicM> list = rStatHarmonicMMapper.selectList(new LambdaQueryWrapper<RStatHarmonicM>()
+                .eq(RStatHarmonicM::getDataType, mainnetData.getId())
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatHarmonicM::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatHarmonicM::getDataDate, param.getEndTime()));
+
+        //初始化指标类型（横向）
+        List<RArrayVO> arrayVOList = new ArrayList<>();
+        List<RStatHarmonicMVO> rm = new ArrayList<>();
+        for (DictData lineTypeDatum : interferenceSourceTypeData) {
+            RStatHarmonicMVO r = new RStatHarmonicMVO();
+            r.setHarmonicName(lineTypeDatum.getName());
+            r.setSort(lineTypeDatum.getSort());
+            r.setOverLimitMeasurementAverage(0);
+            r.setOverLimitMeasurementAccrued(0);
+            r.setAverageOverDay(0.0F);
+            r.setOverDay(0);
+            r.setOverLimitMeasurementRatioAverage(0.0F);
+            r.setOverLimitMeasurementRatioAccrued(0.0F);
+            rm.add(r);
+        }
+        for (DictData lineTypeDatum : lineTypeData) {
+            RArrayVO r = new RArrayVO();
+            r.setRowName(lineTypeDatum.getName());
+            r.setSort(lineTypeDatum.getSort());
+            r.setColumns(rm);
+            arrayVOList.add(r);
+        }
+        //根据稳态指标分组
+        Map<String, List<RStatHarmonicM>> MeasurementTypeClassMap = list.stream().collect(Collectors.groupingBy(RStatHarmonicM::getHarmonicType));
+        //重新生成数据结构
+        MeasurementTypeClassMap.forEach((key, value) -> {
+            if (lineTypeMap.containsKey(key)) {
+                RArrayVO arrayVO = new RArrayVO();
+                DictData data = lineTypeMap.get(key);
+                arrayVO.setRowName(data.getName());
+                arrayVO.setSort(data.getSort());
+                List<RStatHarmonicMVO> b = new ArrayList<>();
+                b.addAll(rm);
+                for (RStatHarmonicM rStatHarmonicM : value) {
+                    if(interferenceMap.containsKey(rStatHarmonicM.getMeasurementTypeClass())){
+                        RStatHarmonicMVO r = BeanUtil.copyProperties(rStatHarmonicM, RStatHarmonicMVO.class);
+                        DictData data1 = interferenceMap.get(rStatHarmonicM.getMeasurementTypeClass());
+                        r.setHarmonicName(data1.getName());
+                        r.setSort(data1.getSort());
+                        DecimalFormat df = new DecimalFormat("###.00");
+                        Float averageOverDay = Float.parseFloat(
+                                df.format(r.getOverDay() / (r.getOverLimitMeasurementAccrued() * 1.0)));
+                        r.setAverageOverDay(averageOverDay);
+                        b.add(r);
+                    }
+
+                }
+                Map<String, RStatHarmonicMVO> linkedHashMap = new LinkedHashMap<>();
+                for (RStatHarmonicMVO harmonicMVO : b) {
+                    linkedHashMap.put(harmonicMVO.getHarmonicName(), harmonicMVO);
+                }
+                List<RStatHarmonicMVO> aa = new ArrayList<>(linkedHashMap.values());
+                aa.sort(Comparator.comparing(rStatHarmonicMVO -> rStatHarmonicMVO.getSort()));
+                arrayVO.setColumns(aa);
+                arrayVOList.add(arrayVO);
+            }
+        });
+        Map<String, RArrayVO> linkedHashMap = new LinkedHashMap<>();
+        for (RArrayVO rStatHarmonicMVO : arrayVOList) {
+            linkedHashMap.put(rStatHarmonicMVO.getRowName(), rStatHarmonicMVO);
+        }
+        List<RArrayVO> aa = new ArrayList<>(linkedHashMap.values());
+        aa.sort(Comparator.comparing(rArrayVO -> rArrayVO.getSort()));
+        return aa;
+    }
+
+    @Override
+    public List<RIconVO> getRStatHarmonicIconVoltage(RStatHarmonicMParam param) {
+        //干扰数据类型（监测对象）
+        DictData measurementDate = null;
+        //指标对象类型属性
+        DictData harmonicDate = null;
+        //判断是是否传入检测点信息值（电压）
+        if (StrUtil.isBlank(param.getStasisID()) && StrUtil.isBlank(param.getMonitorID())) {
+            //干扰数据类型（监测对象）
+            List<DictData> interferenceSourceTypeData = dicDataFeignClient.getDicDataByTypeCode(
+                    DicDataTypeEnum.MONITORING_LABELS.getCode()).getData();
+            interferenceSourceTypeData.sort(Comparator.comparing(data -> data.getSort()));
+            measurementDate = interferenceSourceTypeData.get(0);
+            //指标对象类型
+            List<DictData> indicatorTypeDate = dicDataFeignClient.getDicDataByTypeCode(
+                    DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+            indicatorTypeDate.sort(Comparator.comparing(data -> data.getSort()));
+            harmonicDate = indicatorTypeDate.get(0);
+        } else {
+            //获取检测点对象（电压）
+            measurementDate = dicDataFeignClient.getDicDataById(
+                    param.getMonitorID()).getData();
+            //获取指标对象（频率偏差）
+            harmonicDate = dicDataFeignClient.getDicDataById(
+                    param.getStasisID()).getData();
+        }
+        //反防止参数查询数据报错
+        Assert.isTrue(
+                ObjectUtil.isNotNull(measurementDate) || ObjectUtil.isNotNull(harmonicDate)
+                , "干扰源类型或者指标类型为空,请检查入参是否准确");
+        //获取电压字典
+        List<DictData> devVoltageData = dicDataFeignClient.getDicDataByTypeCode(
+                DicDataTypeEnum.DEV_VOLTAGE.getCode()).getData();
+        Map<String, DictData> devVoltageMap = devVoltageData.stream()
+                .collect(Collectors.toMap(DictData::getId, Function.identity()));
+        //获取主网id信息
+        DictData mainnetData = dicDataFeignClient.getDicDataByCode(DicDataEnum.MAINNET_POINT.getCode()).getData();
+
+        //初始化对象
+        List<RIconVO> arrayVOList = new ArrayList<>();
+        List<RStatHarmonicVoltageM> rStatHarmonicVoltageMS = rStatHarmonicVoltageMMapper.selectList(new LambdaQueryWrapper<RStatHarmonicVoltageM>()
+                .eq(RStatHarmonicVoltageM::getDataType, mainnetData.getId())
+                .eq(RStatHarmonicVoltageM::getMeasurementTypeClass, measurementDate.getId())
+                .eq(RStatHarmonicVoltageM::getHarmonicType, harmonicDate.getId())
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatHarmonicVoltageM::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatHarmonicVoltageM::getDataDate, param.getEndTime())
+        );
+        //将数据转换为map进行便利
+        Map<String, RStatHarmonicVoltageM> voltageMMap = rStatHarmonicVoltageMS.stream()
+                .collect(Collectors.toMap(RStatHarmonicVoltageM::getVoltageType, Function.identity()));
+        //对象
+        if (CollUtil.isNotEmpty(rStatHarmonicVoltageMS)) {
+            voltageMMap.forEach((key, value) -> {
+                if (devVoltageMap.containsKey(key)) {
+                    DictData data = devVoltageMap.get(key);
+                    RIconVO rIconVO = new RIconVO();
+                    rIconVO.setRowName(data.getName());
+                    rIconVO.setSort(data.getSort());
+                    rIconVO.setOverLimitMeasurementAccrued(value.getOverLimitMeasurementAccrued());
+                    rIconVO.setOverLimitMeasurementAverage(value.getOverLimitMeasurementAverage());
+                    rIconVO.setOverLimitMeasurementRatioAccrued(value.getOverLimitMeasurementRatioAccrued());
+                    rIconVO.setOverLimitMeasurementRatioAverage(value.getOverLimitMeasurementRatioAverage());
+                    DecimalFormat df = new DecimalFormat("###.00");
+                    Float averageOverDay = Float.parseFloat(
+                            df.format(value.getOverDay() / (value.getOverLimitMeasurementAccrued() * 1.0)));
+                    rIconVO.setAverageOverDay(averageOverDay);
+                    arrayVOList.add(rIconVO);
+                }
+            });
+        }
+        arrayVOList.sort(Comparator.comparing(rIconVO -> rIconVO.getSort()));
+        return arrayVOList;
+    }
+
+    @SneakyThrows
+    @Override
+    public List<RHarmonicPolylineVO> getRStatHarmonicIconDate(RStatHarmonicMParam param) {
+        //初始化对象
+        List<RHarmonicPolylineVO> iconList = new ArrayList<>();
+        DictData measurementDate;
+        //指标对象类型属性
+        DictData harmonicDate;
+        //判断是是否传入检测点信息值（电压）
+        if (StrUtil.isBlank(param.getStasisID()) && StrUtil.isBlank(param.getMonitorID())) {
+            //干扰数据类型（监测对象）
+            List<DictData> interferenceSourceTypeData = dicDataFeignClient.getDicDataByTypeCode(
+                    DicDataTypeEnum.MONITORING_LABELS.getCode()).getData();
+            interferenceSourceTypeData.sort(Comparator.comparing(data -> data.getSort()));
+            measurementDate = interferenceSourceTypeData.get(0);
+            //指标对象类型
+            List<DictData> indicatorTypeDate = dicDataFeignClient.getDicDataByTypeCode(
+                    DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+            indicatorTypeDate.sort(Comparator.comparing(data -> data.getSort()));
+            harmonicDate = indicatorTypeDate.get(0);
+        } else {
+            //获取检测点对象（电压）
+            measurementDate = dicDataFeignClient.getDicDataById(
+                    param.getMonitorID()).getData();
+            //获取指标对象（频率偏差）
+            harmonicDate = dicDataFeignClient.getDicDataById(
+                    param.getStasisID()).getData();
+        }
+        //反防止参数查询数据报错
+        Assert.isTrue(
+                ObjectUtil.isNotNull(measurementDate) || ObjectUtil.isNotNull(harmonicDate)
+                , "干扰源类型或者指标类型为空,请检查入参是否准确");
+
+        //获取主网id信息
+        DictData mainnetData = dicDataFeignClient.getDicDataByCode(DicDataEnum.MAINNET_POINT.getCode()).getData();
+
+        List<RStatHarmonicD> rStatHarmonicVoltageMS = rStatHarmonicDMapper.selectList(new LambdaQueryWrapper<RStatHarmonicD>()
+                .eq(RStatHarmonicD::getDataType, mainnetData.getId())
+                .eq(RStatHarmonicD::getMeasurementTypeClass, measurementDate.getId())
+                .eq(RStatHarmonicD::getHarmonicType, harmonicDate.getId())
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatHarmonicD::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatHarmonicD::getDataDate, param.getEndTime())
+        );
+        Map<LocalDate, List<RStatHarmonicD>> collect =
+                rStatHarmonicVoltageMS.stream().collect(Collectors.groupingBy(RStatHarmonicD::getDataDate));
+
+        //获取月份
+        List<String> intervalTime = this.getIntervalTime(param.getStartTime(), param.getEndTime());
+        for (String interTime : intervalTime) {
+            //生成初始时间
+            String startTime = PublicDateUtil.getFisrtDayOfMonth(Integer.parseInt(interTime.substring(0, 4)), Integer.parseInt(interTime.substring(5)));
+            String endTime = PublicDateUtil.getLastDayOfMonth(Integer.parseInt(interTime.substring(0, 4)), Integer.parseInt(interTime.substring(5)));
+            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
+            Date dt = simpleDateFormat.parse(startTime);
+            Date dtDate = simpleDateFormat.parse(endTime);
+            Integer year = Integer.valueOf(String.format("%tY", dt));
+            Integer mon = Integer.valueOf(String.format("%tm", dt));
+            Integer day = Integer.valueOf(String.format("%td", dtDate));
+            //生成月份数据
+            List<String> dayTime = this.getIntervalDateTime(year, mon, day);
+            for (String s : dayTime) {
+                RHarmonicPolylineVO rPolylineVO = new RHarmonicPolylineVO();
+                rPolylineVO.setDate(s);
+                if (collect.containsKey(LocalDateTimeUtil.parseDate(s, "yyyy-MM-dd"))) {
+                    List<RStatHarmonicD> rSd = collect.get(LocalDateTimeUtil.parseDate(s, "yyyy-MM-dd"));
+                    rPolylineVO.setNum(rSd.get(0).getOverLimitMeasurement());
+                    rPolylineVO.setOverLimitMeasurementRatioAverage(rSd.get(0).getOverLimitMeasurementRatio());
+                    rPolylineVO.setAverageOverDay(1);
+                } else {
+                    rPolylineVO.setNum(0);
+                    rPolylineVO.setAverageOverDay(0);
+                    rPolylineVO.setOverLimitMeasurementRatioAverage(0.0f);
+                }
+                iconList.add(rPolylineVO);
+            }
+
+        }
+        return iconList;
+    }
+
+    @Override
+    public List<RArrayVO> getPwRStatHarmonicMAll(StatisticsBizBaseParam param) {
+        //对象主节点 获取所有的稳态类型
+        List<DictData> eventData = dicDataFeignClient.getDicDataByTypeCode(
+                DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+        Map<String, DictData> eventMap = eventData.stream()
+                .collect(Collectors.toMap(DictData::getId, Function.identity()));
+
+        //子节点获取监测点类别
+        List<DictData> lineData = dicDataFeignClient.getDicDataByTypeCode(
+                DicDataTypeEnum.LINE_SORT.getCode()).getData();
+        Map<String, DictData> lineMap = lineData.stream()
+                .collect(Collectors.toMap(DictData::getId, Function.identity()));
+
+        //获取配网id信息
+        DictData distributionData = dicDataFeignClient.getDicDataByCode(DicDataEnum.DISTRIBUTION_POINT.getCode()).getData();
+        //初始化指标类型（横向）
+        List<RArrayVO> arrayVOList = new ArrayList<>();
+        //数据库查询
+        List<RStatHarmonicM> list = rStatHarmonicMMapper.selectList(new LambdaQueryWrapper<RStatHarmonicM>()
+                .eq(RStatHarmonicM::getDataType, distributionData.getId())
+                .ge(param.getStartTime() != null, RStatHarmonicM::getDataDate, param.getStartTime())
+                .le(param.getEndTime() != null, RStatHarmonicM::getDataDate, param.getEndTime()));
+
+        //根据稳态指标分组
+        Map<String, List<RStatHarmonicM>> measurementMap = list.stream().collect(Collectors.groupingBy(RStatHarmonicM::getHarmonicType));
+
+        //判断对象是否为空
+        if (CollUtil.isNotEmpty(list)) {
+            //重新生成数据结构
+            measurementMap.forEach((key, value) -> {
+                List<RStatHarmonicMVO> eventVO = new ArrayList<>();
+                if (eventMap.containsKey(key)) {
+                    RArrayVO arrayVO = new RArrayVO();
+                    DictData data = eventMap.get(key);
+                    arrayVO.setRowName(data.getName());
+                    arrayVO.setSort(data.getSort());
+                    for (RStatHarmonicM statHarmonic : value) {
+                        if(lineMap.containsKey(statHarmonic.getMeasurementTypeClass())){
+                            RStatHarmonicMVO r = BeanUtil.copyProperties(statHarmonic, RStatHarmonicMVO.class);
+                            DictData data1 = lineMap.get(statHarmonic.getMeasurementTypeClass());
+                            r.setHarmonicName(data1.getName());
+                            r.setSort(data1.getSort());
+                            DecimalFormat df = new DecimalFormat("###.00");
+                            Float averageOverDay = Float.parseFloat(
+                                    df.format(r.getOverDay() / (r.getOverLimitMeasurementAccrued() * 1.0)));
+                            r.setAverageOverDay(averageOverDay);
+                            eventVO.add(r);
+                        }
+                    }
+                    //根据监测点类别获取差集
+                    Map<String, List<RStatHarmonicM>> listMap = value.stream().collect(Collectors.groupingBy(RStatHarmonicM::getMeasurementTypeClass));
+                    List<DictData> differenceList = lineData.stream().filter(r -> !listMap.containsKey(r.getId()))
+                            .collect(Collectors.toList());
+                    this.assignDict(differenceList, eventVO, arrayVO);
+                    eventVO.sort(Comparator.comparing(statHarmonic -> statHarmonic.getSort()));
+                    arrayVOList.add(arrayVO);
+                }
+            });
+        }
+        //处理主节点不存在的集合
+        List<DictData> notMeasurementList = eventData.stream().filter(r -> !measurementMap.containsKey(r.getId()))
+                .collect(Collectors.toList());
+        for (DictData notData : notMeasurementList) {
+            List<RStatHarmonicMVO> statharmonicVO = new ArrayList<>();
+            RArrayVO arrayVO = new RArrayVO();
+            arrayVO.setRowName(notData.getName());
+            arrayVO.setSort(notData.getSort());
+            this.assignDict(lineData, statharmonicVO, arrayVO);
+            statharmonicVO.sort(Comparator.comparing(statHarmonic -> statHarmonic.getSort()));
+            arrayVOList.add(arrayVO);
+        }
+        arrayVOList.sort(Comparator.comparing(rArrayVO -> rArrayVO.getSort()));
+        return arrayVOList;
+    }
+
+    @SneakyThrows
+    @Override
+    public List<RHarmonicPolylineVO> getPwRStatHarmonicIconDate(RStatHarmonicMParam param) {
+        //初始化对象
+        List<RHarmonicPolylineVO> iconList = new ArrayList<>();
+        DictData measurementDate;
+        //指标对象类型属性
+        DictData harmonicDate;
+        //判断是是否传入检测点信息值（电压）
+        if (StrUtil.isBlank(param.getStasisID()) && StrUtil.isBlank(param.getMonitorID())) {
+            //干扰数据类型（监测对象）
+            List<DictData> interferenceSourceTypeData = dicDataFeignClient.getDicDataByTypeCode(
+                    DicDataTypeEnum.LINE_SORT.getCode()).getData();
+            interferenceSourceTypeData.sort(Comparator.comparing(data -> data.getSort()));
+            measurementDate = interferenceSourceTypeData.get(0);
+            //指标对象类型
+            List<DictData> indicatorTypeDate = dicDataFeignClient.getDicDataByTypeCode(
+                    DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+            indicatorTypeDate.sort(Comparator.comparing(data -> data.getSort()));
+            harmonicDate = indicatorTypeDate.get(0);
+        } else {
+            //获取检测点对象（电压）
+            measurementDate = dicDataFeignClient.getDicDataById(
+                    param.getMonitorID()).getData();
+            //获取指标对象（频率偏差）
+            harmonicDate = dicDataFeignClient.getDicDataById(
+                    param.getStasisID()).getData();
+        }
+        //反防止参数查询数据报错
+        Assert.isTrue(
+                ObjectUtil.isNotNull(measurementDate) || ObjectUtil.isNotNull(harmonicDate)
+                , "监测点类别或者指标类型为空,请检查入参是否准确");
+        //获取配网信息
+        DictData distributionData = dicDataFeignClient.getDicDataByCode(DicDataEnum.DISTRIBUTION_POINT.getCode()).getData();
+
+        List<RStatHarmonicD> rStatHarmonicVoltageMS = rStatHarmonicDMapper.selectList(new LambdaQueryWrapper<RStatHarmonicD>()
+                .eq(RStatHarmonicD::getDataType, distributionData.getId())
+                .eq(RStatHarmonicD::getMeasurementTypeClass, measurementDate.getId())
+                .eq(RStatHarmonicD::getHarmonicType, harmonicDate.getId())
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatHarmonicD::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatHarmonicD::getDataDate, param.getEndTime())
+        );
+        Map<LocalDate, List<RStatHarmonicD>> collect =
+                rStatHarmonicVoltageMS.stream().collect(Collectors.groupingBy(RStatHarmonicD::getDataDate));
+
+        //获取月份
+        List<String> intervalTime = this.getIntervalTime(param.getStartTime(), param.getEndTime());
+        for (String interTime : intervalTime) {
+            //生成初始时间
+            String startTime = PublicDateUtil.getFisrtDayOfMonth(Integer.parseInt(interTime.substring(0, 4)), Integer.parseInt(interTime.substring(5)));
+            String endTime = PublicDateUtil.getLastDayOfMonth(Integer.parseInt(interTime.substring(0, 4)), Integer.parseInt(interTime.substring(5)));
+            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
+            Date dt = simpleDateFormat.parse(startTime);
+            Date dtDate = simpleDateFormat.parse(endTime);
+            Integer year = Integer.valueOf(String.format("%tY", dt));
+            Integer mon = Integer.valueOf(String.format("%tm", dt));
+            Integer day = Integer.valueOf(String.format("%td", dtDate));
+            //生成月份数据
+            List<String> dayTime = this.getIntervalDateTime(year, mon, day);
+            for (String s : dayTime) {
+                RHarmonicPolylineVO rPolylineVO = new RHarmonicPolylineVO();
+                rPolylineVO.setDate(s);
+                if (collect.containsKey(LocalDateTimeUtil.parseDate(s, "yyyy-MM-dd"))) {
+                    List<RStatHarmonicD> rSd = collect.get(LocalDateTimeUtil.parseDate(s, "yyyy-MM-dd"));
+                    rPolylineVO.setNum(rSd.get(0).getOverLimitMeasurement());
+                    rPolylineVO.setOverLimitMeasurementRatioAverage(rSd.get(0).getOverLimitMeasurementRatio());
+                    rPolylineVO.setAverageOverDay(1);
+                } else {
+                    rPolylineVO.setNum(0);
+                    rPolylineVO.setAverageOverDay(0);
+                    rPolylineVO.setOverLimitMeasurementRatioAverage(0.0f);
+                }
+                iconList.add(rPolylineVO);
+            }
+
+        }
+        return iconList;
+    }
+
+    /**
+     * 便利赋值
+     *
+     * @param DictDataList   稳态指标类型集合
+     * @param statharmonicVO 暂态监测点
+     * @param arrayVO        初始化对象
+     */
+    private void assignDict(List<DictData> DictDataList, List<RStatHarmonicMVO> statharmonicVO, RArrayVO arrayVO) {
+        for (DictData dictData : DictDataList) {
+            RStatHarmonicMVO notStatHarmonicVO = new RStatHarmonicMVO();
+            notStatHarmonicVO.setHarmonicName(dictData.getName());
+            notStatHarmonicVO.setSort(dictData.getSort());
+            notStatHarmonicVO.setOverLimitMeasurementAverage(0);
+            notStatHarmonicVO.setOverLimitMeasurementAccrued(0);
+            notStatHarmonicVO.setOverDay(0);
+            notStatHarmonicVO.setOverLimitMeasurementRatioAverage(0.0F);
+            notStatHarmonicVO.setOverLimitMeasurementRatioAccrued(0.0F);
+            notStatHarmonicVO.setAverageOverDay(0.0F);
+            statharmonicVO.add(notStatHarmonicVO);
+        }
+        arrayVO.setColumns(statharmonicVO);
+    }
+
+    /**
+     * 根据用户选择的时间区间返回月份日期
+     */
+    @SneakyThrows
+    private List<String> getIntervalTime(String startTime, String endTime) {
+        List<String> times = new ArrayList<>();
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
+        Date start = sdf.parse(startTime);
+        Date end = sdf.parse(endTime);
+        // 同月
+        if (start.getTime() == end.getTime()) {
+            String time = startTime.substring(0, 7);
+            times.add(time);
+        } else if (start.getYear() == end.getYear()) {
+            // 同年
+            int startM = start.getMonth() + 1;
+            int endM = end.getMonth() + 1;
+            int temp = endM - startM;
+            for (int i = 0; i <= temp; i++) {
+                String time = start.getYear() + 1900 + "";
+                int month = startM + i;
+                if (month < 10) {
+                    time = time + "-0" + month;
+                } else {
+                    time = time + "-" + month;
+                }
+                times.add(time);
+            }
+        } else {
+            // 不同年!!!!这里忽略了年份之间跨年的情况
+            int startY = start.getYear() + 1900;
+            int startM = start.getMonth() + 1;
+            int endY = end.getYear() + 1900;
+            int endM = end.getMonth() + 1;
+            int tempS = 12 - startM;
+            // 连续的年份
+            if (endY - startY == 1) {
+                // 第一年的时间获取
+                for (int i = 0; i <= tempS; i++) {
+                    int month = startM + i;
+                    String time = startY + "-";
+                    if (month < 10) {
+                        time = time + "0" + month;
+                    } else {
+                        time = time + month;
+                    }
+                    times.add(time);
+                }
+                // 第二年的时间获取
+
+                for (int i = 1; i <= endM; i++) {
+                    String time = endY + "-";
+                    if (i < 10) {
+                        time = time + "0" + i;
+                    } else {
+                        time = time + i;
+                    }
+                    times.add(time);
+                }
+            } else {
+                // 不连续的年份
+                // 第一年的时间获取
+                for (int i = 0; i <= tempS; i++) {
+                    int month = startM + i;
+                    String time = startY + "-";
+                    if (month < 10) {
+                        time = time + "0" + month;
+                    } else {
+                        time = time + month;
+                    }
+                    times.add(time);
+                }
+                int tempY = endY - startY;
+                // 中间年份的时间
+                for (int i = 1; i < tempY; i++) {
+                    for (int j = 1; j <= 12; j++) {
+                        String time = startY + i + "-";
+                        if (j < 10) {
+                            time = time + "0" + j;
+                        } else {
+                            time = time + j;
+                        }
+                        times.add(time);
+                    }
+                }
+                // 最后一年的时间获取
+                for (int i = 1; i <= endM; i++) {
+                    String time = endY + "-";
+                    if (i < 10) {
+                        time = time + "0" + i;
+                    } else {
+                        time = time + i;
+                    }
+                    times.add(time);
+                }
+            }
+
+        }
+        return times;
+    }
+
+    @SneakyThrows
+    private List<String> getIntervalDateTime(Integer startTime, Integer endTime, Integer dd) {
+        List<String> list = new ArrayList<>();
+        Calendar calendar = Calendar.getInstance(Locale.CHINA);
+        calendar.set(startTime, endTime - 1, 1);
+        //年份
+        int year = calendar.get(Calendar.YEAR);
+        //月份
+        int month = calendar.get(Calendar.MONTH) + 1;
+        for (int i = 1; i <= dd; i++) {
+            String date = null;
+            if (month < 10 && i < 10) {
+                date = year + "-0" + month + "-0" + i;
+            }
+            if (month < 10 && i >= 10) {
+                date = year + "-0" + month + "-" + i;
+            }
+            if (month >= 10 && i < 10) {
+                date = year + "-" + month + "-0" + i;
+            }
+            if (month >= 10 && i >= 10) {
+                date = year + "-" + month + "-" + i;
+            }
+
+            list.add(date);
+        }
+        return list;
+    }
+
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatHarmonicOrgMServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatHarmonicOrgMServiceImpl.java
@@ -0,0 +1,364 @@
+package com.njcn.harmonic.service.majornetwork.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.lang.Assert;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.param.RStatHarmonicMParam;
+import com.njcn.harmonic.pojo.po.RStatHarmonicOrgM;
+import com.njcn.harmonic.mapper.StatHarmonicOrgMMapper;
+import com.njcn.harmonic.pojo.vo.RArrayVO;
+import com.njcn.harmonic.pojo.vo.RIconVO;
+import com.njcn.harmonic.pojo.vo.RStatHarmonicMVO;
+import com.njcn.harmonic.service.majornetwork.RStatHarmonicOrgMService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataEnum;
+import com.njcn.system.enums.DicDataTypeEnum;
+import com.njcn.system.pojo.po.DictData;
+import com.njcn.user.api.DeptFeignClient;
+import com.njcn.user.pojo.dto.DeptDTO;
+import com.njcn.web.utils.WebUtil;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.text.DecimalFormat;
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-14
+ */
+@Service
+@RequiredArgsConstructor
+public class RStatHarmonicOrgMServiceImpl extends ServiceImpl<StatHarmonicOrgMMapper, RStatHarmonicOrgM> implements RStatHarmonicOrgMService {
+
+    private final DeptFeignClient deptFeignClient;
+    private final DicDataFeignClient dicDataFeignClient;
+    private final StatHarmonicOrgMMapper statHarmonicOrgMMapper;
+
+    @Override
+    public List<RArrayVO> getRStatHarmonicMAll(StatisticsBizBaseParam param) {
+        //子节点 获取所有得各单位类型
+        List<DeptDTO> deptDTOList = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        //获取部门id集合
+        List<String> deptIds = deptDTOList.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        Map<String, DeptDTO> deptMap = deptDTOList.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+
+        //对象主节点 获取所有得指标类型
+        List<DictData> lineTypeData = dicDataFeignClient.getDicDataByTypeCode
+                (DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+        Map<String, DictData> lineTypeMap = lineTypeData.stream()
+                .collect(Collectors.toMap(DictData::getId, Function.identity()));
+        //获取主网id信息
+        DictData mainnetData = dicDataFeignClient.getDicDataByCode(DicDataEnum.MAINNET_POINT.getCode()).getData();
+
+        //数据库查询
+        List<RStatHarmonicOrgM> list = statHarmonicOrgMMapper.selectList(new LambdaQueryWrapper<RStatHarmonicOrgM>()
+                .eq(RStatHarmonicOrgM::getDataType, mainnetData.getId())
+                .in(RStatHarmonicOrgM::getOrgNo, deptIds)
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatHarmonicOrgM::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatHarmonicOrgM::getDataDate, param.getEndTime()));
+
+        //初始化指标类型（横向）
+        List<RArrayVO> arrayVOList = new ArrayList<>();
+        List<RStatHarmonicMVO> rm = new ArrayList<>();
+        for (DeptDTO deptDTO : deptDTOList) {
+            RStatHarmonicMVO r = new RStatHarmonicMVO();
+            r.setHarmonicName(deptDTO.getName());
+            r.setOverLimitMeasurementAverage(0);
+            r.setOverLimitMeasurementAccrued(0);
+            r.setAverageOverDay(0.0F);
+            r.setOverDay(0);
+            r.setOverLimitMeasurementRatioAverage(0.0F);
+            r.setOverLimitMeasurementRatioAccrued(0.0F);
+            rm.add(r);
+        }
+        for (DictData lineTypeDatum : lineTypeData) {
+            RArrayVO r = new RArrayVO();
+            r.setRowName(lineTypeDatum.getName());
+            r.setColumns(rm);
+            r.setSort(lineTypeDatum.getSort());
+            arrayVOList.add(r);
+        }
+        //根据检测点对象分组
+        Map<String, List<RStatHarmonicOrgM>> MeasurementTypeClassMap = list.stream().collect(Collectors.groupingBy(RStatHarmonicOrgM::getHarmonicType));
+        //重新生成数据结构
+        MeasurementTypeClassMap.forEach((key, value) -> {
+            if (lineTypeMap.containsKey(key)) {
+                RArrayVO arrayVO = new RArrayVO();
+                DictData data = lineTypeMap.get(key);
+                arrayVO.setRowName(data.getName());
+                arrayVO.setSort(data.getSort());
+                List<RStatHarmonicMVO> b = new ArrayList<>();
+                b.addAll(rm);
+                for (RStatHarmonicOrgM orgY : value) {
+                    RStatHarmonicMVO r = BeanUtil.copyProperties(orgY, RStatHarmonicMVO.class);
+                    DeptDTO data1 = deptMap.get(orgY.getOrgNo());
+                    if (ObjectUtil.isNotNull(data1)) {
+                        r.setHarmonicName(data1.getName());
+                        DecimalFormat df = new DecimalFormat("###.00");
+                        Float averageOverDay = Float.parseFloat(
+                                df.format(r.getOverDay() / (r.getOverLimitMeasurementAccrued() * 1.0)));
+                        r.setAverageOverDay(averageOverDay);
+                        b.add(r);
+                    }
+                }
+                Map<String, RStatHarmonicMVO> linkedHashMap = new LinkedHashMap<>();
+                for (RStatHarmonicMVO harmonicMVO : b) {
+                    linkedHashMap.put(harmonicMVO.getHarmonicName(), harmonicMVO);
+                }
+                List<RStatHarmonicMVO> aa = new ArrayList<>(linkedHashMap.values());
+                aa.sort(Comparator.comparing(rStatHarmonicMVO -> rStatHarmonicMVO.getHarmonicName()));
+                arrayVO.setColumns(aa);
+                arrayVOList.add(arrayVO);
+            }
+
+        });
+        Map<String, RArrayVO> linkedHashMap = new LinkedHashMap<>();
+        for (RArrayVO rStatHarmonicMVO : arrayVOList) {
+            linkedHashMap.put(rStatHarmonicMVO.getRowName(), rStatHarmonicMVO);
+        }
+        List<RArrayVO> aa = new ArrayList<>(linkedHashMap.values());
+        arrayVOList.sort(Comparator.comparing(rArrayVO -> rArrayVO.getRowName()));
+        return aa;
+    }
+
+    @Override
+    public List<RIconVO> getRStatHarmonicOrgMIcon(RStatHarmonicMParam param) {
+        //各单位类型
+        List<DeptDTO> deptDTOList = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        Map<String, DeptDTO> deptMap = deptDTOList.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+        //获取部门id集合
+        List<String> deptIds = deptDTOList.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        //指标对象类型属性
+        DictData harmonicData;
+        //判断是是否传入检测点信息值（电压）
+        if (StrUtil.isBlank(param.getStasisID()) && StrUtil.isBlank(param.getMonitorID())) {
+            //指标对象类型
+            List<DictData> indicatorTypeDate = dicDataFeignClient.getDicDataByTypeCode(
+                    DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+            indicatorTypeDate.sort(Comparator.comparing(data -> data.getSort()));
+            harmonicData = indicatorTypeDate.get(0);
+        } else {
+            //获取指标对象（频率偏差）
+            harmonicData = dicDataFeignClient.getDicDataById(
+                    param.getStasisID()).getData();
+        }
+        //反防止参数查询数据报错
+        Assert.isTrue(
+                CollUtil.isNotEmpty(deptDTOList) || ObjectUtil.isNotNull(harmonicData)
+                , "各单位或者指标类型为空,请检查入参是否准确");
+        //获取主网id信息
+        DictData mainnetData = dicDataFeignClient.getDicDataByCode(DicDataEnum.MAINNET_POINT.getCode()).getData();
+
+        //初始化对象
+        List<RIconVO> arrayVOList = new ArrayList<>();
+        List<RStatHarmonicOrgM> rStatHarmonicVoltageMS = statHarmonicOrgMMapper.selectList(new LambdaQueryWrapper<RStatHarmonicOrgM>()
+                .eq(RStatHarmonicOrgM::getDataType, mainnetData.getId())
+                .in(RStatHarmonicOrgM::getOrgNo, deptIds)
+                .eq(RStatHarmonicOrgM::getHarmonicType, harmonicData.getId())
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatHarmonicOrgM::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatHarmonicOrgM::getDataDate, param.getEndTime())
+        );
+        //将数据转换为map进行便利
+        Map<String, List<RStatHarmonicOrgM>> voltageMMap = rStatHarmonicVoltageMS.stream()
+                .collect(Collectors.groupingBy(RStatHarmonicOrgM::getOrgNo));
+        //对象
+        if (CollUtil.isNotEmpty(rStatHarmonicVoltageMS)) {
+            voltageMMap.forEach((key, value) -> {
+                if (deptMap.containsKey(key)) {
+                    DeptDTO data = deptMap.get(key);
+                    for (RStatHarmonicOrgM orgM : value) {
+                        RIconVO rIconVO = new RIconVO();
+                        rIconVO.setRowName(data.getName());
+                        rIconVO.setOverLimitMeasurementAccrued(orgM.getOverLimitMeasurementAccrued());
+                        rIconVO.setOverLimitMeasurementAverage(orgM.getOverLimitMeasurementAverage());
+                        rIconVO.setOverLimitMeasurementRatioAccrued(orgM.getOverLimitMeasurementRatioAccrued());
+                        rIconVO.setOverLimitMeasurementRatioAverage(orgM.getOverLimitMeasurementRatioAverage());
+                        DecimalFormat df = new DecimalFormat("###.00");
+                        Float averageOverDay = Float.parseFloat(
+                                df.format(orgM.getOverDay() / (orgM.getOverLimitMeasurementAccrued() * 1.0)));
+                        rIconVO.setAverageOverDay(averageOverDay);
+                        arrayVOList.add(rIconVO);
+                    }
+
+                }
+            });
+        }
+        arrayVOList.sort(Comparator.comparing(rIconVO -> rIconVO.getRowName()));
+        return arrayVOList;
+    }
+
+    @Override
+    public List<RArrayVO> getPwRStatHarmonicMAll(StatisticsBizBaseParam param) {
+        //对象主节点 获取所有的稳态类型
+        List<DictData> steadyData = dicDataFeignClient.getDicDataByTypeCode(
+                DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+        Map<String, DictData> steadyMap = steadyData.stream()
+                .collect(Collectors.toMap(DictData::getId, Function.identity()));
+
+        //子节点 获取所有得各单位类型
+        List<DeptDTO> deptDTOList = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        //获取部门id集合
+        List<String> deptIds = deptDTOList.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        Map<String, DeptDTO> deptMap = deptDTOList.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+
+        //获取配网信息
+        DictData distributionData = dicDataFeignClient.getDicDataByCode(DicDataEnum.DISTRIBUTION_POINT.getCode()).getData();
+        //初始化指标类型（横向）
+        List<RArrayVO> arrayVOList = new ArrayList<>();
+        //数据库查询
+        List<RStatHarmonicOrgM> list = statHarmonicOrgMMapper.selectList(new LambdaQueryWrapper<RStatHarmonicOrgM>()
+                .eq(RStatHarmonicOrgM::getDataType, distributionData.getId())
+                .in(RStatHarmonicOrgM::getOrgNo, deptIds)
+                .ge(param.getStartTime() != null, RStatHarmonicOrgM::getDataDate, param.getStartTime())
+                .le(param.getEndTime() != null, RStatHarmonicOrgM::getDataDate, param.getEndTime()));
+        //根据稳态指标分组
+        Map<String, List<RStatHarmonicOrgM>> measurementMap = list.stream().collect(Collectors.groupingBy(RStatHarmonicOrgM::getHarmonicType));
+        //判断对象是否为空
+        if (CollUtil.isNotEmpty(list)) {
+            //重新生成数据结构
+            measurementMap.forEach((key, value) -> {
+                List<RStatHarmonicMVO> eventVO = new ArrayList<>();
+                if (steadyMap.containsKey(key)) {
+                    RArrayVO arrayVO = new RArrayVO();
+                    DictData data = steadyMap.get(key);
+                    arrayVO.setRowName(data.getName());
+                    arrayVO.setSort(data.getSort());
+                    for (RStatHarmonicOrgM statHarmonic : value) {
+                        if(deptMap.containsKey(statHarmonic.getOrgNo())){
+                            RStatHarmonicMVO r = BeanUtil.copyProperties(statHarmonic, RStatHarmonicMVO.class);
+                            DeptDTO deptDTO = deptMap.get(statHarmonic.getOrgNo());
+                            r.setHarmonicName(deptDTO.getName());
+                            DecimalFormat df = new DecimalFormat("###.00");
+                            Float averageOverDay = Float.parseFloat(
+                                    df.format(r.getOverDay() / (r.getOverLimitMeasurementAccrued() * 1.0)));
+                            r.setAverageOverDay(averageOverDay);
+                            eventVO.add(r);
+                        }
+
+                    }
+                    //根据监测点类别获取差集
+                    Map<String, List<RStatHarmonicOrgM>> listMap = value.stream().collect(Collectors.groupingBy(RStatHarmonicOrgM::getOrgNo));
+                    List<DeptDTO> notDeptDTOS = deptDTOList.stream().filter(r -> !listMap.containsKey(r.getId()))
+                            .collect(Collectors.toList());
+                    this.assignDict(notDeptDTOS, eventVO, arrayVO);
+                    eventVO.sort(Comparator.comparing(statHarmonic -> statHarmonic.getHarmonicName()));
+                    arrayVOList.add(arrayVO);
+                }
+            });
+        }
+        //处理主节点不存在的集合
+        List<DictData> notMeasurementList = steadyData.stream().filter(r -> !measurementMap.containsKey(r.getId()))
+                .collect(Collectors.toList());
+        for (DictData notData : notMeasurementList) {
+            List<RStatHarmonicMVO> statharmonicVO = new ArrayList<>();
+            RArrayVO arrayVO = new RArrayVO();
+            arrayVO.setRowName(notData.getName());
+            arrayVO.setSort(notData.getSort());
+            this.assignDict(deptDTOList, statharmonicVO, arrayVO);
+            statharmonicVO.sort(Comparator.comparing(statHarmonic -> statHarmonic.getHarmonicName()));
+            arrayVOList.add(arrayVO);
+        }
+        arrayVOList.sort(Comparator.comparing(rArrayVO -> rArrayVO.getSort()));
+        return arrayVOList;
+    }
+
+    @Override
+    public List<RIconVO> getPwRStatHarmonicOrgMIcon(RStatHarmonicMParam param) {
+        //各单位类型
+        List<DeptDTO> deptDTOList = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        Map<String, DeptDTO> deptMap = deptDTOList.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+        //获取部门id集合
+        List<String> deptIds = deptDTOList.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        //指标对象类型属性
+        DictData harmonicData;
+        //判断是是否传入检测点信息值（电压）
+        if (StrUtil.isBlank(param.getStasisID()) && StrUtil.isBlank(param.getMonitorID())) {
+            //指标对象类型
+            List<DictData> indicatorTypeDate = dicDataFeignClient.getDicDataByTypeCode(
+                    DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+            indicatorTypeDate.sort(Comparator.comparing(data -> data.getSort()));
+            harmonicData = indicatorTypeDate.get(0);
+        } else {
+            //获取指标对象（频率偏差）
+            harmonicData = dicDataFeignClient.getDicDataById(
+                    param.getStasisID()).getData();
+        }
+        //反防止参数查询数据报错
+        Assert.isTrue(
+                CollUtil.isNotEmpty(deptDTOList) || ObjectUtil.isNotNull(harmonicData)
+                , "各单位或者指标类型为空,请检查入参是否准确");
+        //获取主网id信息
+        DictData distributionData = dicDataFeignClient.getDicDataByCode(DicDataEnum.DISTRIBUTION_POINT.getCode()).getData();
+
+        //初始化对象
+        List<RIconVO> arrayVOList = new ArrayList<>();
+        List<RStatHarmonicOrgM> rStatHarmonicVoltageMS = statHarmonicOrgMMapper.selectList(new LambdaQueryWrapper<RStatHarmonicOrgM>()
+                .eq(RStatHarmonicOrgM::getDataType, distributionData.getId())
+                .in(RStatHarmonicOrgM::getOrgNo, deptIds)
+                .eq(RStatHarmonicOrgM::getHarmonicType, harmonicData.getId())
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatHarmonicOrgM::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatHarmonicOrgM::getDataDate, param.getEndTime())
+        );
+        //将数据转换为map进行便利
+        Map<String, List<RStatHarmonicOrgM>> voltageMMap = rStatHarmonicVoltageMS.stream()
+                .collect(Collectors.groupingBy(RStatHarmonicOrgM::getOrgNo));
+        //对象
+        if (CollUtil.isNotEmpty(rStatHarmonicVoltageMS)) {
+            voltageMMap.forEach((key, value) -> {
+                if (deptMap.containsKey(key)) {
+                    DeptDTO data = deptMap.get(key);
+                    for (RStatHarmonicOrgM orgM : value) {
+                        RIconVO rIconVO = new RIconVO();
+                        rIconVO.setRowName(data.getName());
+                        rIconVO.setOverLimitMeasurementAccrued(orgM.getOverLimitMeasurementAccrued());
+                        rIconVO.setOverLimitMeasurementAverage(orgM.getOverLimitMeasurementAverage());
+                        rIconVO.setOverLimitMeasurementRatioAccrued(orgM.getOverLimitMeasurementRatioAccrued());
+                        rIconVO.setOverLimitMeasurementRatioAverage(orgM.getOverLimitMeasurementRatioAverage());
+                        DecimalFormat df = new DecimalFormat("###.00");
+                        Float averageOverDay = Float.parseFloat(
+                                df.format(orgM.getOverDay() / (orgM.getOverLimitMeasurementAccrued() * 1.0)));
+                        rIconVO.setAverageOverDay(averageOverDay);
+                        arrayVOList.add(rIconVO);
+                    }
+
+                }
+            });
+        }
+        arrayVOList.sort(Comparator.comparing(rIconVO -> rIconVO.getRowName()));
+        return arrayVOList;
+    }
+
+    /**
+     * 便利赋值
+     *
+     * @param deptDTOList    部门信息集合
+     * @param statharmonicVO 暂态监测点
+     * @param arrayVO        初始化对象
+     */
+    private void assignDict(List<DeptDTO> deptDTOList, List<RStatHarmonicMVO> statharmonicVO, RArrayVO arrayVO) {
+        for (DeptDTO dictData : deptDTOList) {
+            RStatHarmonicMVO notStatHarmonicVO = new RStatHarmonicMVO();
+            notStatHarmonicVO.setHarmonicName(dictData.getName());
+            notStatHarmonicVO.setOverLimitMeasurementAverage(0);
+            notStatHarmonicVO.setOverLimitMeasurementAccrued(0);
+            notStatHarmonicVO.setOverDay(0);
+            notStatHarmonicVO.setOverLimitMeasurementRatioAverage(0.0F);
+            notStatHarmonicVO.setOverLimitMeasurementRatioAccrued(0.0F);
+            notStatHarmonicVO.setAverageOverDay(0.0F);
+            statharmonicVO.add(notStatHarmonicVO);
+        }
+        arrayVO.setColumns(statharmonicVO);
+    }
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatHarmonicOrgQServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatHarmonicOrgQServiceImpl.java
@@ -0,0 +1,350 @@
+package com.njcn.harmonic.service.majornetwork.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.lang.Assert;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.param.RStatHarmonicMParam;
+import com.njcn.harmonic.pojo.po.RStatHarmonicOrgQ;
+import com.njcn.harmonic.mapper.StatHarmonicOrgQMapper;
+import com.njcn.harmonic.pojo.vo.RArrayVO;
+import com.njcn.harmonic.pojo.vo.RIconVO;
+import com.njcn.harmonic.pojo.vo.RStatHarmonicMVO;
+import com.njcn.harmonic.service.majornetwork.RStatHarmonicOrgQService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataEnum;
+import com.njcn.system.enums.DicDataTypeEnum;
+import com.njcn.system.pojo.po.DictData;
+import com.njcn.user.api.DeptFeignClient;
+import com.njcn.user.pojo.dto.DeptDTO;
+import com.njcn.web.utils.WebUtil;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-14
+ */
+@Service
+@RequiredArgsConstructor
+public class RStatHarmonicOrgQServiceImpl extends ServiceImpl<StatHarmonicOrgQMapper, RStatHarmonicOrgQ> implements RStatHarmonicOrgQService {
+
+    private final DeptFeignClient deptFeignClient;
+    private final DicDataFeignClient dicDataFeignClient;
+    private final StatHarmonicOrgQMapper statHarmonicOrgQMapper;
+
+    @Override
+    public List<RArrayVO> getRStatHarmonicQAll(StatisticsBizBaseParam param) {
+        //子节点 获取所有得各单位类型
+        List<DeptDTO> deptDTOList = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        //获取部门id集合
+        List<String> deptIds = deptDTOList.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        Map<String, DeptDTO> deptMap = deptDTOList.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+
+        //对象主节点 获取所有得指标类型
+        List<DictData> lineTypeData = dicDataFeignClient.getDicDataByTypeCode
+                (DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+        Map<String, DictData> lineTypeMap = lineTypeData.stream()
+                .collect(Collectors.toMap(DictData::getId, Function.identity()));
+        //获取主网id信息
+        DictData mainnetData = dicDataFeignClient.getDicDataByCode(DicDataEnum.MAINNET_POINT.getCode()).getData();
+
+        //数据库查询
+        List<RStatHarmonicOrgQ> list = statHarmonicOrgQMapper.selectList(new LambdaQueryWrapper<RStatHarmonicOrgQ>()
+                .eq(RStatHarmonicOrgQ::getDataType, mainnetData.getId())
+                .in(RStatHarmonicOrgQ::getOrgNo, deptIds)
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatHarmonicOrgQ::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatHarmonicOrgQ::getDataDate, param.getEndTime()));
+
+        //初始化指标类型（横向）
+        List<RArrayVO> arrayVOList = new ArrayList<>();
+        List<RStatHarmonicMVO> rm = new ArrayList<>();
+        for (DeptDTO deptDTO : deptDTOList) {
+            RStatHarmonicMVO r = new RStatHarmonicMVO();
+            r.setHarmonicName(deptDTO.getName());
+            r.setOverLimitMeasurementAverage(0);
+            r.setOverLimitMeasurementAccrued(0);
+            r.setAverageOverDay(0.0F);
+            r.setOverDay(0);
+            r.setOverLimitMeasurementRatioAverage(0.0F);
+            r.setOverLimitMeasurementRatioAccrued(0.0F);
+            rm.add(r);
+        }
+        for (DictData lineTypeDatum : lineTypeData) {
+            RArrayVO r = new RArrayVO();
+            r.setRowName(lineTypeDatum.getName());
+            r.setColumns(rm);
+            r.setSort(lineTypeDatum.getSort());
+            arrayVOList.add(r);
+        }
+        //根据检测点对象分组
+        Map<String, List<RStatHarmonicOrgQ>> MeasurementTypeClassMap = list.stream().collect(Collectors.groupingBy(RStatHarmonicOrgQ::getHarmonicType));
+        //重新生成数据结构
+        MeasurementTypeClassMap.forEach((key, value) -> {
+            if (lineTypeMap.containsKey(key)) {
+                RArrayVO arrayVO = new RArrayVO();
+                DictData data = lineTypeMap.get(key);
+                arrayVO.setRowName(data.getName());
+                arrayVO.setSort(data.getSort());
+                List<RStatHarmonicMVO> b = new ArrayList<>();
+                b.addAll(rm);
+                for (RStatHarmonicOrgQ orgY : value) {
+                    RStatHarmonicMVO r = BeanUtil.copyProperties(orgY, RStatHarmonicMVO.class);
+                    DeptDTO data1 = deptMap.get(orgY.getOrgNo());
+                    if (ObjectUtil.isNotNull(data1)) {
+                        r.setHarmonicName(data1.getName());
+                        r.setOverDay(0);
+                        b.add(r);
+                    }
+                }
+                Map<String, RStatHarmonicMVO> linkedHashMap = new LinkedHashMap<>();
+                for (RStatHarmonicMVO harmonicMVO : b) {
+                    linkedHashMap.put(harmonicMVO.getHarmonicName(), harmonicMVO);
+                }
+                List<RStatHarmonicMVO> aa = new ArrayList<>(linkedHashMap.values());
+                aa.sort(Comparator.comparing(rStatHarmonicMVO -> rStatHarmonicMVO.getHarmonicName()));
+                arrayVO.setColumns(aa);
+                arrayVOList.add(arrayVO);
+            }
+
+        });
+        Map<String, RArrayVO> linkedHashMap = new LinkedHashMap<>();
+        for (RArrayVO rStatHarmonicMVO : arrayVOList) {
+            linkedHashMap.put(rStatHarmonicMVO.getRowName(), rStatHarmonicMVO);
+        }
+        List<RArrayVO> aa = new ArrayList<>(linkedHashMap.values());
+        arrayVOList.sort(Comparator.comparing(rArrayVO -> rArrayVO.getRowName()));
+        return aa;
+    }
+
+    @Override
+    public List<RIconVO> getRStatHarmonicOrgQIcon(RStatHarmonicMParam param) {
+        //各单位类型
+        List<DeptDTO> deptDTOList = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        Map<String, DeptDTO> deptMap = deptDTOList.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+        //获取部门id集合
+        List<String> deptIds = deptDTOList.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        //指标对象类型属性
+        DictData harmonicData;
+        //判断是是否传入检测点信息值（电压）
+        if (StrUtil.isBlank(param.getStasisID()) && StrUtil.isBlank(param.getMonitorID())) {
+            //指标对象类型
+            List<DictData> indicatorTypeDate = dicDataFeignClient.getDicDataByTypeCode(
+                    DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+            indicatorTypeDate.sort(Comparator.comparing(data -> data.getSort()));
+            harmonicData = indicatorTypeDate.get(0);
+        } else {
+            //获取指标对象（频率偏差）
+            harmonicData = dicDataFeignClient.getDicDataById(
+                    param.getStasisID()).getData();
+        }
+        //反防止参数查询数据报错
+        Assert.isTrue(
+                CollUtil.isNotEmpty(deptDTOList) || ObjectUtil.isNotNull(harmonicData)
+                , "各单位或者指标类型为空,请检查入参是否准确");
+        //获取主网id信息
+        DictData mainnetData = dicDataFeignClient.getDicDataByCode(DicDataEnum.MAINNET_POINT.getCode()).getData();
+
+        //初始化对象
+        List<RIconVO> arrayVOList = new ArrayList<>();
+        List<RStatHarmonicOrgQ> rStatHarmonicVoltageMS = statHarmonicOrgQMapper.selectList(new LambdaQueryWrapper<RStatHarmonicOrgQ>()
+                .eq(RStatHarmonicOrgQ::getDataType, mainnetData.getId())
+                .in(RStatHarmonicOrgQ::getOrgNo, deptIds)
+                .eq(RStatHarmonicOrgQ::getHarmonicType, harmonicData.getId())
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatHarmonicOrgQ::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatHarmonicOrgQ::getDataDate, param.getEndTime())
+        );
+        //将数据转换为map进行便利
+        Map<String, List<RStatHarmonicOrgQ>> voltageMMap = rStatHarmonicVoltageMS.stream()
+                .collect(Collectors.groupingBy(RStatHarmonicOrgQ::getOrgNo));
+        //对象
+        if (CollUtil.isNotEmpty(rStatHarmonicVoltageMS)) {
+            voltageMMap.forEach((key, value) -> {
+                if (deptMap.containsKey(key)) {
+                    DeptDTO data = deptMap.get(key);
+                    for (RStatHarmonicOrgQ orgQ : value) {
+                        RIconVO rIconVO = new RIconVO();
+                        rIconVO.setRowName(data.getName());
+                        rIconVO.setOverLimitMeasurementAccrued(orgQ.getOverLimitMeasurementAccrued());
+                        rIconVO.setOverLimitMeasurementAverage(orgQ.getOverLimitMeasurementAverage());
+                        rIconVO.setOverLimitMeasurementRatioAccrued(orgQ.getOverLimitMeasurementRatioAccrued());
+                        rIconVO.setOverLimitMeasurementRatioAverage(orgQ.getOverLimitMeasurementRatioAverage());
+                        rIconVO.setAverageOverDay(orgQ.getAverageOverDay());
+                        arrayVOList.add(rIconVO);
+                    }
+
+                }
+            });
+        }
+        arrayVOList.sort(Comparator.comparing(rIconVO -> rIconVO.getRowName()));
+        return arrayVOList;
+    }
+
+    @Override
+    public List<RArrayVO> getPwRStatHarmonicQAll(StatisticsBizBaseParam param) {
+        //对象主节点 获取所有的稳态类型
+        List<DictData> steadyData = dicDataFeignClient.getDicDataByTypeCode(
+                DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+        Map<String, DictData> steadyMap = steadyData.stream()
+                .collect(Collectors.toMap(DictData::getId, Function.identity()));
+
+        //子节点 获取所有得各单位类型
+        List<DeptDTO> deptDTOList = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        //获取部门id集合
+        List<String> deptIds = deptDTOList.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        Map<String, DeptDTO> deptMap = deptDTOList.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+
+        //获取配网信息
+        DictData distributionData = dicDataFeignClient.getDicDataByCode(DicDataEnum.DISTRIBUTION_POINT.getCode()).getData();
+        //初始化指标类型（横向）
+        List<RArrayVO> arrayVOList = new ArrayList<>();
+        //数据库查询
+        List<RStatHarmonicOrgQ> list = statHarmonicOrgQMapper.selectList(new LambdaQueryWrapper<RStatHarmonicOrgQ>()
+                .eq(RStatHarmonicOrgQ::getDataType, distributionData.getId())
+                .in(RStatHarmonicOrgQ::getOrgNo, deptIds)
+                .ge(param.getStartTime() != null, RStatHarmonicOrgQ::getDataDate, param.getStartTime())
+                .le(param.getEndTime() != null, RStatHarmonicOrgQ::getDataDate, param.getEndTime()));
+        //根据稳态指标分组
+        Map<String, List<RStatHarmonicOrgQ>> measurementMap = list.stream().collect(Collectors.groupingBy(RStatHarmonicOrgQ::getHarmonicType));
+        //判断对象是否为空
+        if (CollUtil.isNotEmpty(list)) {
+            //重新生成数据结构
+            measurementMap.forEach((key, value) -> {
+                List<RStatHarmonicMVO> eventVO = new ArrayList<>();
+                if (steadyMap.containsKey(key)) {
+                    RArrayVO arrayVO = new RArrayVO();
+                    DictData data = steadyMap.get(key);
+                    arrayVO.setRowName(data.getName());
+                    arrayVO.setSort(data.getSort());
+                    for (RStatHarmonicOrgQ statHarmonic : value) {
+                        if(deptMap.containsKey(statHarmonic.getOrgNo())){
+                            RStatHarmonicMVO r = BeanUtil.copyProperties(statHarmonic, RStatHarmonicMVO.class);
+                            DeptDTO deptDTO = deptMap.get(statHarmonic.getOrgNo());
+                            r.setHarmonicName(deptDTO.getName());
+                            eventVO.add(r);
+                        }
+
+                    }
+                    //根据监测点类别获取差集
+                    Map<String, List<RStatHarmonicOrgQ>> listMap = value.stream().collect(Collectors.groupingBy(RStatHarmonicOrgQ::getOrgNo));
+                    List<DeptDTO> notDeptDTOS = deptDTOList.stream().filter(r -> !listMap.containsKey(r.getId()))
+                            .collect(Collectors.toList());
+                    this.assignDict(notDeptDTOS, eventVO, arrayVO);
+                    eventVO.sort(Comparator.comparing(statHarmonic -> statHarmonic.getHarmonicName()));
+                    arrayVOList.add(arrayVO);
+                }
+            });
+        }
+        //处理主节点不存在的集合
+        List<DictData> notMeasurementList = steadyData.stream().filter(r -> !measurementMap.containsKey(r.getId()))
+                .collect(Collectors.toList());
+        for (DictData notData : notMeasurementList) {
+            List<RStatHarmonicMVO> statharmonicVO = new ArrayList<>();
+            RArrayVO arrayVO = new RArrayVO();
+            arrayVO.setRowName(notData.getName());
+            arrayVO.setSort(notData.getSort());
+            this.assignDict(deptDTOList, statharmonicVO, arrayVO);
+            statharmonicVO.sort(Comparator.comparing(statHarmonic -> statHarmonic.getHarmonicName()));
+            arrayVOList.add(arrayVO);
+        }
+        arrayVOList.sort(Comparator.comparing(rArrayVO -> rArrayVO.getSort()));
+        return arrayVOList;
+    }
+
+    @Override
+    public List<RIconVO> getPwRStatHarmonicOrgQIcon(RStatHarmonicMParam param) {
+        //各单位类型
+        List<DeptDTO> deptDTOList = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        Map<String, DeptDTO> deptMap = deptDTOList.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+        //获取部门id集合
+        List<String> deptIds = deptDTOList.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        //指标对象类型属性
+        DictData harmonicData;
+        //判断是是否传入检测点信息值（电压）
+        if (StrUtil.isBlank(param.getStasisID()) && StrUtil.isBlank(param.getMonitorID())) {
+            //指标对象类型
+            List<DictData> indicatorTypeDate = dicDataFeignClient.getDicDataByTypeCode(
+                    DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+            indicatorTypeDate.sort(Comparator.comparing(data -> data.getSort()));
+            harmonicData = indicatorTypeDate.get(0);
+        } else {
+            //获取指标对象（频率偏差）
+            harmonicData = dicDataFeignClient.getDicDataById(
+                    param.getStasisID()).getData();
+        }
+        //反防止参数查询数据报错
+        Assert.isTrue(
+                CollUtil.isNotEmpty(deptDTOList) || ObjectUtil.isNotNull(harmonicData)
+                , "各单位或者指标类型为空,请检查入参是否准确");
+        //获取配网信息
+        DictData distributionData = dicDataFeignClient.getDicDataByCode(DicDataEnum.DISTRIBUTION_POINT.getCode()).getData();
+
+        //初始化对象
+        List<RIconVO> arrayVOList = new ArrayList<>();
+        List<RStatHarmonicOrgQ> rStatHarmonicVoltageMS = statHarmonicOrgQMapper.selectList(new LambdaQueryWrapper<RStatHarmonicOrgQ>()
+                .eq(RStatHarmonicOrgQ::getDataType, distributionData.getId())
+                .in(RStatHarmonicOrgQ::getOrgNo, deptIds)
+                .eq(RStatHarmonicOrgQ::getHarmonicType, harmonicData.getId())
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatHarmonicOrgQ::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatHarmonicOrgQ::getDataDate, param.getEndTime())
+        );
+        //将数据转换为map进行便利
+        Map<String, List<RStatHarmonicOrgQ>> voltageMMap = rStatHarmonicVoltageMS.stream()
+                .collect(Collectors.groupingBy(RStatHarmonicOrgQ::getOrgNo));
+        //对象
+        if (CollUtil.isNotEmpty(rStatHarmonicVoltageMS)) {
+            voltageMMap.forEach((key, value) -> {
+                if (deptMap.containsKey(key)) {
+                    DeptDTO data = deptMap.get(key);
+                    for (RStatHarmonicOrgQ orgQ : value) {
+                        RIconVO rIconVO = new RIconVO();
+                        rIconVO.setRowName(data.getName());
+                        rIconVO.setOverLimitMeasurementAccrued(orgQ.getOverLimitMeasurementAccrued());
+                        rIconVO.setOverLimitMeasurementAverage(orgQ.getOverLimitMeasurementAverage());
+                        rIconVO.setOverLimitMeasurementRatioAccrued(orgQ.getOverLimitMeasurementRatioAccrued());
+                        rIconVO.setOverLimitMeasurementRatioAverage(orgQ.getOverLimitMeasurementRatioAverage());
+                        rIconVO.setAverageOverDay(orgQ.getAverageOverDay());
+                        arrayVOList.add(rIconVO);
+                    }
+
+                }
+            });
+        }
+        arrayVOList.sort(Comparator.comparing(rIconVO -> rIconVO.getRowName()));
+        return arrayVOList;
+    }
+
+    /**
+     * 便利赋值
+     *
+     * @param deptDTOList    部门信息集合
+     * @param statharmonicVO 暂态监测点
+     * @param arrayVO        初始化对象
+     */
+    private void assignDict(List<DeptDTO> deptDTOList, List<RStatHarmonicMVO> statharmonicVO, RArrayVO arrayVO) {
+        for (DeptDTO dictData : deptDTOList) {
+            RStatHarmonicMVO notStatHarmonicVO = new RStatHarmonicMVO();
+            notStatHarmonicVO.setHarmonicName(dictData.getName());
+            notStatHarmonicVO.setOverLimitMeasurementAverage(0);
+            notStatHarmonicVO.setOverLimitMeasurementAccrued(0);
+            notStatHarmonicVO.setOverDay(0);
+            notStatHarmonicVO.setOverLimitMeasurementRatioAverage(0.0F);
+            notStatHarmonicVO.setOverLimitMeasurementRatioAccrued(0.0F);
+            notStatHarmonicVO.setAverageOverDay(0.0F);
+            statharmonicVO.add(notStatHarmonicVO);
+        }
+        arrayVO.setColumns(statharmonicVO);
+    }
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatHarmonicOrgYServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatHarmonicOrgYServiceImpl.java
@@ -0,0 +1,352 @@
+package com.njcn.harmonic.service.majornetwork.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.lang.Assert;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.param.RStatHarmonicMParam;
+import com.njcn.harmonic.pojo.po.RStatHarmonicOrgY;
+import com.njcn.harmonic.mapper.StatHarmonicOrgYMapper;
+import com.njcn.harmonic.pojo.vo.RArrayVO;
+import com.njcn.harmonic.pojo.vo.RIconVO;
+import com.njcn.harmonic.pojo.vo.RStatHarmonicMVO;
+import com.njcn.harmonic.service.majornetwork.RStatHarmonicOrgYService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataEnum;
+import com.njcn.system.enums.DicDataTypeEnum;
+import com.njcn.system.pojo.po.DictData;
+import com.njcn.user.api.DeptFeignClient;
+import com.njcn.user.pojo.dto.DeptDTO;
+import com.njcn.web.utils.WebUtil;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ *  服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-14
+ */
+@Service
+@RequiredArgsConstructor
+public class RStatHarmonicOrgYServiceImpl extends ServiceImpl<StatHarmonicOrgYMapper, RStatHarmonicOrgY> implements RStatHarmonicOrgYService {
+
+    private final DicDataFeignClient dicDataFeignClient;
+    private final DeptFeignClient deptFeignClient;
+    private final StatHarmonicOrgYMapper statHarmonicOrgYMapper;
+
+    @Override
+    public List<RArrayVO> getRStatHarmonicYAll(StatisticsBizBaseParam param) {
+        //子节点 获取所有得各单位类型
+        List<DeptDTO> deptDTOList = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        //获取部门id集合
+        List<String> deptIds = deptDTOList.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        Map<String, DeptDTO> deptMap = deptDTOList.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+
+        //对象主节点 获取所有得指标类型
+        List<DictData> lineTypeData = dicDataFeignClient.getDicDataByTypeCode
+                (DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+        Map<String, DictData> lineTypeMap = lineTypeData.stream()
+                .collect(Collectors.toMap(DictData::getId, Function.identity()));
+        //获取主网id信息
+        DictData mainnetData = dicDataFeignClient.getDicDataByCode(DicDataEnum.MAINNET_POINT.getCode()).getData();
+
+        //数据库查询
+        List<RStatHarmonicOrgY> list = statHarmonicOrgYMapper.selectList(new LambdaQueryWrapper<RStatHarmonicOrgY>()
+                .eq(RStatHarmonicOrgY::getDataType,mainnetData.getId())
+                .in(RStatHarmonicOrgY::getOrgNo,deptIds)
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatHarmonicOrgY::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatHarmonicOrgY::getDataDate, param.getEndTime()));
+
+        //初始化指标类型（横向）
+        List<RArrayVO> arrayVOList=new ArrayList<>();
+        List<RStatHarmonicMVO> rm=new ArrayList<>();
+        for (DeptDTO deptDTO : deptDTOList) {
+            RStatHarmonicMVO r = new RStatHarmonicMVO();
+            r.setHarmonicName(deptDTO.getName());
+            r.setOverLimitMeasurementAverage(0);
+            r.setOverLimitMeasurementAccrued(0);
+            r.setAverageOverDay(0.0F);
+            r.setOverDay(0);
+            r.setOverLimitMeasurementRatioAverage(0.0F);
+            r.setOverLimitMeasurementRatioAccrued(0.0F);
+            rm.add(r);
+        }
+        for (DictData lineTypeDatum : lineTypeData) {
+            RArrayVO r = new RArrayVO();
+            r.setRowName(lineTypeDatum.getName());
+            r.setColumns(rm);
+            r.setSort(lineTypeDatum.getSort());
+            arrayVOList.add(r);
+        }
+        //根据检测点对象分组
+        Map<String, List<RStatHarmonicOrgY>> MeasurementTypeClassMap = list.stream().collect(Collectors.groupingBy(RStatHarmonicOrgY::getHarmonicType));
+        //重新生成数据结构
+        MeasurementTypeClassMap.forEach((key, value) -> {
+            if(lineTypeMap.containsKey(key)){
+                RArrayVO arrayVO=new RArrayVO();
+                DictData data = lineTypeMap.get(key);
+                arrayVO.setRowName(data.getName());
+                arrayVO.setSort(data.getSort());
+                List<RStatHarmonicMVO> b=new ArrayList<>();
+                b.addAll(rm);
+                for (RStatHarmonicOrgY orgY : value) {
+                    RStatHarmonicMVO r = BeanUtil.copyProperties(orgY, RStatHarmonicMVO.class);
+                    DeptDTO data1 = deptMap.get(orgY.getOrgNo());
+                    if (ObjectUtil.isNotNull(data1)){
+                        r.setHarmonicName(data1.getName());
+                        r.setOverDay(0);
+                        b.add(r);
+                    }
+                }
+                Map<String,RStatHarmonicMVO> linkedHashMap=new LinkedHashMap<>();
+                for (RStatHarmonicMVO harmonicMVO : b) {
+                    linkedHashMap.put(harmonicMVO.getHarmonicName(),harmonicMVO);
+                }
+                List<RStatHarmonicMVO> aa=new ArrayList<>(linkedHashMap.values());
+                aa.sort(Comparator.comparing(rStatHarmonicMVO -> rStatHarmonicMVO.getHarmonicName()));
+                arrayVO.setColumns(aa);
+                arrayVOList.add(arrayVO);
+            }
+
+        });
+        Map<String,RArrayVO> linkedHashMap=new LinkedHashMap<>();
+        for (RArrayVO rStatHarmonicMVO : arrayVOList) {
+            linkedHashMap.put(rStatHarmonicMVO.getRowName(),rStatHarmonicMVO);
+        }
+        List<RArrayVO> aa=new ArrayList<>(linkedHashMap.values());
+        arrayVOList.sort(Comparator.comparing(rArrayVO -> rArrayVO.getRowName()));
+        return aa;
+    }
+
+    @Override
+    public List<RIconVO> getRStatHarmonicOrgYIcon(RStatHarmonicMParam param) {
+        //各单位类型
+        List<DeptDTO> deptDTOList = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        Map<String, DeptDTO> deptMap = deptDTOList.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+        //获取部门id集合
+        List<String> deptIds = deptDTOList.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        //指标对象类型属性
+        DictData harmonicData;
+        //判断是是否传入检测点信息值（电压）
+        if(StrUtil.isBlank(param.getStasisID())&&StrUtil.isBlank(param.getMonitorID())){
+            //指标对象类型
+            List<DictData> indicatorTypeDate = dicDataFeignClient.getDicDataByTypeCode(
+                    DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+            indicatorTypeDate.sort(Comparator.comparing(data -> data.getSort()));
+            harmonicData =indicatorTypeDate.get(0);
+        }else{
+            //获取指标对象（频率偏差）
+            harmonicData= dicDataFeignClient.getDicDataById(
+                    param.getStasisID()).getData();
+        }
+        //反防止参数查询数据报错
+        Assert.isTrue(
+                CollUtil.isNotEmpty(deptDTOList)||ObjectUtil.isNotNull(harmonicData)
+                , "各单位或者指标类型为空,请检查入参是否准确");
+
+        //获取主网id信息
+        DictData mainnetData = dicDataFeignClient.getDicDataByCode(DicDataEnum.MAINNET_POINT.getCode()).getData();
+
+        //初始化对象
+        List<RIconVO> arrayVOList=new ArrayList<>();
+        List<RStatHarmonicOrgY> rStatHarmonicVoltageMS = statHarmonicOrgYMapper.selectList(new LambdaQueryWrapper<RStatHarmonicOrgY>()
+                .eq(RStatHarmonicOrgY::getDataType,mainnetData.getId())
+                .in(RStatHarmonicOrgY::getOrgNo,deptIds)
+                .eq(RStatHarmonicOrgY::getHarmonicType, harmonicData.getId())
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatHarmonicOrgY::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatHarmonicOrgY::getDataDate, param.getEndTime())
+        );
+        //将数据转换为map进行便利
+        Map<String, List<RStatHarmonicOrgY>> voltageMMap = rStatHarmonicVoltageMS.stream()
+                .collect(Collectors.groupingBy(RStatHarmonicOrgY::getOrgNo));
+        //对象
+        if (CollUtil.isNotEmpty(rStatHarmonicVoltageMS)){
+            voltageMMap.forEach((key, value) -> {
+                if(deptMap.containsKey(key)){
+                    DeptDTO data = deptMap.get(key);
+                    for (RStatHarmonicOrgY orgY : value) {
+                        RIconVO rIconVO = new RIconVO();
+                        rIconVO.setRowName(data.getName());
+                        rIconVO.setOverLimitMeasurementAccrued(orgY.getOverLimitMeasurementAccrued());
+                        rIconVO.setOverLimitMeasurementAverage(orgY.getOverLimitMeasurementAverage());
+                        rIconVO.setOverLimitMeasurementRatioAccrued(orgY.getOverLimitMeasurementRatioAccrued());
+                        rIconVO.setOverLimitMeasurementRatioAverage(orgY.getOverLimitMeasurementRatioAverage());
+                        rIconVO.setAverageOverDay(orgY.getAverageOverDay());
+                        arrayVOList.add(rIconVO);
+                    }
+
+                }
+            });
+        }
+        arrayVOList.sort(Comparator.comparing(rIconVO -> rIconVO.getRowName()));
+        return arrayVOList;
+    }
+
+    @Override
+    public List<RArrayVO> getPwRStatHarmonicYAll(StatisticsBizBaseParam param) {
+        //对象主节点 获取所有的稳态类型
+        List<DictData> steadyData = dicDataFeignClient.getDicDataByTypeCode(
+                DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+        Map<String, DictData> steadyMap = steadyData.stream()
+                .collect(Collectors.toMap(DictData::getId, Function.identity()));
+
+        //子节点 获取所有得各单位类型
+        List<DeptDTO> deptDTOList = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        //获取部门id集合
+        List<String> deptIds = deptDTOList.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        Map<String, DeptDTO> deptMap = deptDTOList.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+
+        //获取配网信息
+        DictData distributionData = dicDataFeignClient.getDicDataByCode(DicDataEnum.DISTRIBUTION_POINT.getCode()).getData();
+        //初始化指标类型（横向）
+        List<RArrayVO> arrayVOList = new ArrayList<>();
+        //数据库查询
+        List<RStatHarmonicOrgY> list = statHarmonicOrgYMapper.selectList(new LambdaQueryWrapper<RStatHarmonicOrgY>()
+                .eq(RStatHarmonicOrgY::getDataType, distributionData.getId())
+                .in(RStatHarmonicOrgY::getOrgNo,deptIds)
+                .ge(param.getStartTime() != null, RStatHarmonicOrgY::getDataDate, param.getStartTime())
+                .le(param.getEndTime() != null, RStatHarmonicOrgY::getDataDate, param.getEndTime()));
+        //根据稳态指标分组
+        Map<String, List<RStatHarmonicOrgY>> measurementMap = list.stream().collect(Collectors.groupingBy(RStatHarmonicOrgY::getHarmonicType));
+        //判断对象是否为空
+        if(CollUtil.isNotEmpty(list)){
+            //重新生成数据结构
+            measurementMap.forEach((key, value) -> {
+                List<RStatHarmonicMVO> eventVO = new ArrayList<>();
+                if (steadyMap.containsKey(key)) {
+                    RArrayVO arrayVO = new RArrayVO();
+                    DictData data = steadyMap.get(key);
+                    arrayVO.setRowName(data.getName());
+                    arrayVO.setSort(data.getSort());
+                    for (RStatHarmonicOrgY statHarmonic : value) {
+                        if(deptMap.containsKey(statHarmonic.getOrgNo())){
+                            RStatHarmonicMVO r = BeanUtil.copyProperties(statHarmonic, RStatHarmonicMVO.class);
+                            DeptDTO deptDTO = deptMap.get(statHarmonic.getOrgNo());
+                            r.setHarmonicName(deptDTO.getName());
+                            eventVO.add(r);
+                        }
+                    }
+                    //根据监测点类别获取差集
+                    Map<String, List<RStatHarmonicOrgY>> listMap = value.stream().collect(Collectors.groupingBy(RStatHarmonicOrgY::getOrgNo));
+                    List<DeptDTO> notDeptDTOS = deptDTOList.stream().filter(r -> !listMap.containsKey(r.getId()))
+                            .collect(Collectors.toList());
+                    this.assignDict(notDeptDTOS, eventVO, arrayVO);
+                    eventVO.sort(Comparator.comparing(statHarmonic -> statHarmonic.getHarmonicName()));
+                    arrayVOList.add(arrayVO);
+                }
+            });
+        }
+        //处理主节点不存在的集合
+        List<DictData> notMeasurementList = steadyData.stream().filter(r -> !measurementMap.containsKey(r.getId()))
+                .collect(Collectors.toList());
+        for (DictData notData : notMeasurementList) {
+            List<RStatHarmonicMVO> statharmonicVO = new ArrayList<>();
+            RArrayVO arrayVO = new RArrayVO();
+            arrayVO.setRowName(notData.getName());
+            arrayVO.setSort(notData.getSort());
+            this.assignDict(deptDTOList, statharmonicVO, arrayVO);
+            statharmonicVO.sort(Comparator.comparing(statHarmonic -> statHarmonic.getHarmonicName()));
+            arrayVOList.add(arrayVO);
+        }
+        arrayVOList.sort(Comparator.comparing(rArrayVO -> rArrayVO.getSort()));
+        return arrayVOList;
+    }
+
+    @Override
+    public List<RIconVO> getPwRStatHarmonicOrgYIcon(RStatHarmonicMParam param) {
+        //各单位类型
+        List<DeptDTO> deptDTOList = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        Map<String, DeptDTO> deptMap = deptDTOList.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+        //获取部门id集合
+        List<String> deptIds = deptDTOList.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        //指标对象类型属性
+        DictData harmonicData;
+        //判断是是否传入检测点信息值（电压）
+        if(StrUtil.isBlank(param.getStasisID())&&StrUtil.isBlank(param.getMonitorID())){
+            //指标对象类型
+            List<DictData> indicatorTypeDate = dicDataFeignClient.getDicDataByTypeCode(
+                    DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+            indicatorTypeDate.sort(Comparator.comparing(data -> data.getSort()));
+            harmonicData =indicatorTypeDate.get(0);
+        }else{
+            //获取指标对象（频率偏差）
+            harmonicData= dicDataFeignClient.getDicDataById(
+                    param.getStasisID()).getData();
+        }
+        //反防止参数查询数据报错
+        Assert.isTrue(
+                CollUtil.isNotEmpty(deptDTOList)||ObjectUtil.isNotNull(harmonicData)
+                , "各单位或者指标类型为空,请检查入参是否准确");
+
+        //获取配网信息
+        DictData distributionData = dicDataFeignClient.getDicDataByCode(DicDataEnum.DISTRIBUTION_POINT.getCode()).getData();
+
+        //初始化对象
+        List<RIconVO> arrayVOList=new ArrayList<>();
+        List<RStatHarmonicOrgY> rStatHarmonicVoltageMS = statHarmonicOrgYMapper.selectList(new LambdaQueryWrapper<RStatHarmonicOrgY>()
+                .eq(RStatHarmonicOrgY::getDataType,distributionData.getId())
+                .in(RStatHarmonicOrgY::getOrgNo,deptIds)
+                .eq(RStatHarmonicOrgY::getHarmonicType, harmonicData.getId())
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatHarmonicOrgY::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatHarmonicOrgY::getDataDate, param.getEndTime())
+        );
+        //将数据转换为map进行便利
+        Map<String, List<RStatHarmonicOrgY>> voltageMMap = rStatHarmonicVoltageMS.stream()
+                .collect(Collectors.groupingBy(RStatHarmonicOrgY::getOrgNo));
+        //对象
+        if (CollUtil.isNotEmpty(rStatHarmonicVoltageMS)){
+            voltageMMap.forEach((key, value) -> {
+                if(deptMap.containsKey(key)){
+                    DeptDTO data = deptMap.get(key);
+                    for (RStatHarmonicOrgY orgY : value) {
+                        RIconVO rIconVO = new RIconVO();
+                        rIconVO.setRowName(data.getName());
+                        rIconVO.setOverLimitMeasurementAccrued(orgY.getOverLimitMeasurementAccrued());
+                        rIconVO.setOverLimitMeasurementAverage(orgY.getOverLimitMeasurementAverage());
+                        rIconVO.setOverLimitMeasurementRatioAccrued(orgY.getOverLimitMeasurementRatioAccrued());
+                        rIconVO.setOverLimitMeasurementRatioAverage(orgY.getOverLimitMeasurementRatioAverage());
+                        rIconVO.setAverageOverDay(orgY.getAverageOverDay());
+                        arrayVOList.add(rIconVO);
+                    }
+
+                }
+            });
+        }
+        arrayVOList.sort(Comparator.comparing(rIconVO -> rIconVO.getRowName()));
+        return arrayVOList;
+    }
+
+    /**
+     * 便利赋值
+     *
+     * @param deptDTOList   部门信息集合
+     * @param statharmonicVO 暂态监测点
+     * @param arrayVO        初始化对象
+     */
+    private void assignDict(List<DeptDTO> deptDTOList, List<RStatHarmonicMVO> statharmonicVO, RArrayVO arrayVO) {
+        for (DeptDTO dictData : deptDTOList) {
+            RStatHarmonicMVO notStatHarmonicVO = new RStatHarmonicMVO();
+            notStatHarmonicVO.setHarmonicName(dictData.getName());
+            notStatHarmonicVO.setOverLimitMeasurementAverage(0);
+            notStatHarmonicVO.setOverLimitMeasurementAccrued(0);
+            notStatHarmonicVO.setOverDay(0);
+            notStatHarmonicVO.setOverLimitMeasurementRatioAverage(0.0F);
+            notStatHarmonicVO.setOverLimitMeasurementRatioAccrued(0.0F);
+            notStatHarmonicVO.setAverageOverDay(0.0F);
+            statharmonicVO.add(notStatHarmonicVO);
+        }
+        arrayVO.setColumns(statharmonicVO);
+    }
+
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatHarmonicQServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatHarmonicQServiceImpl.java
@@ -0,0 +1,222 @@
+package com.njcn.harmonic.service.majornetwork.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.mapper.majornetwork.RStatHarmonicQMapper;
+import com.njcn.harmonic.pojo.po.RStatHarmonicQ;
+import com.njcn.harmonic.pojo.vo.RArrayVO;
+import com.njcn.harmonic.pojo.vo.RStatHarmonicMVO;
+import com.njcn.harmonic.service.majornetwork.RStatHarmonicQService;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataEnum;
+import com.njcn.system.enums.DicDataTypeEnum;
+import com.njcn.system.pojo.po.DictData;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-12
+ */
+@Service
+@RequiredArgsConstructor
+public class RStatHarmonicQServiceImpl extends ServiceImpl<RStatHarmonicQMapper, RStatHarmonicQ> implements RStatHarmonicQService {
+
+    private final RStatHarmonicQMapper rStatHarmonicQMapper;
+    private final DicDataFeignClient dicDataFeignClient;
+
+    @Override
+    public List<RArrayVO> getRStatHarmonicQAll(StatisticsBizBaseParam param) {
+        //子节点 获取所有得干扰源类型（监测点类型）
+        List<DictData> interferenceSourceTypeData = dicDataFeignClient.getDicDataByTypeCode(
+                DicDataTypeEnum.MONITORING_LABELS.getCode()).getData();
+        Map<String, DictData> interferenceMap = interferenceSourceTypeData.stream().collect(Collectors.toMap(DictData::getId, Function.identity()));
+
+        //对象主节点 获取所有得指标类型
+        List<DictData> lineTypeData = dicDataFeignClient.getDicDataByTypeCode(
+                DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+        Map<String, DictData> lineTypeMap = lineTypeData.stream()
+                .collect(Collectors.toMap(DictData::getId, Function.identity()));
+
+        //获取主网id信息
+        DictData mainnetData = dicDataFeignClient.getDicDataByCode(DicDataEnum.MAINNET_POINT.getCode()).getData();
+
+        //数据库查询
+        List<RStatHarmonicQ> list = rStatHarmonicQMapper.selectList(new LambdaQueryWrapper<RStatHarmonicQ>()
+                .eq(RStatHarmonicQ::getDataType, mainnetData.getId())
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatHarmonicQ::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatHarmonicQ::getDataDate, param.getEndTime()));
+
+        //初始化指标类型（横向）
+        List<RArrayVO> arrayVOList = new ArrayList<>();
+        List<RStatHarmonicMVO> rm = new ArrayList<>();
+        for (DictData lineTypeDatum : interferenceSourceTypeData) {
+            RStatHarmonicMVO r = new RStatHarmonicMVO();
+            r.setHarmonicName(lineTypeDatum.getName());
+            r.setSort(lineTypeDatum.getSort());
+            r.setOverLimitMeasurementAverage(0);
+            r.setOverLimitMeasurementAccrued(0);
+            r.setAverageOverDay(0.0F);
+            r.setOverDay(0);
+            r.setOverLimitMeasurementRatioAverage(0.0F);
+            r.setOverLimitMeasurementRatioAccrued(0.0F);
+            rm.add(r);
+        }
+        for (DictData lineTypeDatum : lineTypeData) {
+            RArrayVO r = new RArrayVO();
+            r.setRowName(lineTypeDatum.getName());
+            r.setSort(lineTypeDatum.getSort());
+            r.setColumns(rm);
+            arrayVOList.add(r);
+        }
+        //根据稳态指标分组
+        Map<String, List<RStatHarmonicQ>> MeasurementTypeClassMap = list.stream().collect(Collectors.groupingBy(RStatHarmonicQ::getHarmonicType));
+        //重新生成数据结构
+        MeasurementTypeClassMap.forEach((key, value) -> {
+
+            if (lineTypeMap.containsKey(key)) {
+                RArrayVO arrayVO = new RArrayVO();
+                DictData data = lineTypeMap.get(key);
+                arrayVO.setRowName(data.getName());
+                arrayVO.setSort(data.getSort());
+                List<RStatHarmonicMVO> b = new ArrayList<>();
+                b.addAll(rm);
+                for (RStatHarmonicQ rStatHarmonicQ : value) {
+                    if(interferenceMap.containsKey(rStatHarmonicQ.getMeasurementTypeClass())){
+                        RStatHarmonicMVO r = BeanUtil.copyProperties(rStatHarmonicQ, RStatHarmonicMVO.class);
+                        DictData data1 = interferenceMap.get(rStatHarmonicQ.getMeasurementTypeClass());
+                        r.setHarmonicName(data1.getName());
+                        r.setSort(data1.getSort());
+                        r.setOverDay(0);
+                        b.add(r);
+                    }
+
+                }
+                Map<String, RStatHarmonicMVO> linkedHashMap = new LinkedHashMap<>();
+                for (RStatHarmonicMVO harmonicMVO : b) {
+                    linkedHashMap.put(harmonicMVO.getHarmonicName(), harmonicMVO);
+                }
+                List<RStatHarmonicMVO> aa = new ArrayList<>(linkedHashMap.values());
+                aa.sort(Comparator.comparing(rStatHarmonicMVO -> rStatHarmonicMVO.getSort()));
+                arrayVO.setColumns(aa);
+                arrayVOList.add(arrayVO);
+            }
+
+        });
+        Map<String, RArrayVO> linkedHashMap = new LinkedHashMap<>();
+        for (RArrayVO rStatHarmonicMVO : arrayVOList) {
+            linkedHashMap.put(rStatHarmonicMVO.getRowName(), rStatHarmonicMVO);
+        }
+        List<RArrayVO> aa = new ArrayList<>(linkedHashMap.values());
+        arrayVOList.sort(Comparator.comparing(rArrayVO -> rArrayVO.getSort()));
+        return aa;
+    }
+
+    @Override
+    public List<RArrayVO> getPwRStatHarmonicQAll(StatisticsBizBaseParam param) {
+        //对象主节点 获取所有的稳态类型
+        List<DictData> eventData = dicDataFeignClient.getDicDataByTypeCode(
+                DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+        Map<String, DictData> eventMap = eventData.stream()
+                .collect(Collectors.toMap(DictData::getId, Function.identity()));
+
+        //子节点获取监测点类别
+        List<DictData> lineData = dicDataFeignClient.getDicDataByTypeCode(
+                DicDataTypeEnum.LINE_SORT.getCode()).getData();
+        Map<String, DictData> lineMap = lineData.stream()
+                .collect(Collectors.toMap(DictData::getId, Function.identity()));
+
+        //获取配网id信息
+        DictData distributionData = dicDataFeignClient.getDicDataByCode(DicDataEnum.DISTRIBUTION_POINT.getCode()).getData();
+        //初始化指标类型（横向）
+        List<RArrayVO> arrayVOList = new ArrayList<>();
+        //数据库查询
+        List<RStatHarmonicQ> list = rStatHarmonicQMapper.selectList(new LambdaQueryWrapper<RStatHarmonicQ>()
+                .eq(RStatHarmonicQ::getDataType, distributionData.getId())
+                .ge(param.getStartTime() != null, RStatHarmonicQ::getDataDate, param.getStartTime())
+                .le(param.getEndTime() != null, RStatHarmonicQ::getDataDate, param.getEndTime()));
+
+        //根据稳态指标分组
+        Map<String, List<RStatHarmonicQ>> measurementMap = list.stream().collect(Collectors.groupingBy(RStatHarmonicQ::getHarmonicType));
+
+        //判断对象是否为空
+        if (CollUtil.isNotEmpty(list)) {
+            //重新生成数据结构
+            measurementMap.forEach((key, value) -> {
+                List<RStatHarmonicMVO> eventVO = new ArrayList<>();
+                if (eventMap.containsKey(key)) {
+                    RArrayVO arrayVO = new RArrayVO();
+                    DictData data = eventMap.get(key);
+                    arrayVO.setRowName(data.getName());
+                    arrayVO.setSort(data.getSort());
+                    for (RStatHarmonicQ statHarmonic : value) {
+                        if(lineMap.containsKey(statHarmonic.getMeasurementTypeClass())){
+                            RStatHarmonicMVO r = BeanUtil.copyProperties(statHarmonic, RStatHarmonicMVO.class);
+                            DictData data1 = lineMap.get(statHarmonic.getMeasurementTypeClass());
+                            r.setHarmonicName(data1.getName());
+                            r.setSort(data1.getSort());
+                            eventVO.add(r);
+                        }
+
+                    }
+                    //根据监测点类别获取差集
+                    Map<String, List<RStatHarmonicQ>> listMap = value.stream().collect(Collectors.groupingBy(RStatHarmonicQ::getMeasurementTypeClass));
+                    List<DictData> differenceList = lineData.stream().filter(r -> !listMap.containsKey(r.getId()))
+                            .collect(Collectors.toList());
+                    this.assignDict(differenceList, eventVO, arrayVO);
+                    eventVO.sort(Comparator.comparing(statHarmonic -> statHarmonic.getSort()));
+                    arrayVOList.add(arrayVO);
+                }
+            });
+        }
+        //处理主节点不存在的集合
+        List<DictData> notMeasurementList = eventData.stream().filter(r -> !measurementMap.containsKey(r.getId()))
+                .collect(Collectors.toList());
+        for (DictData notData : notMeasurementList) {
+            List<RStatHarmonicMVO> statharmonicVO = new ArrayList<>();
+            RArrayVO arrayVO = new RArrayVO();
+            arrayVO.setRowName(notData.getName());
+            arrayVO.setSort(notData.getSort());
+            this.assignDict(lineData, statharmonicVO, arrayVO);
+            statharmonicVO.sort(Comparator.comparing(statHarmonic -> statHarmonic.getSort()));
+            arrayVOList.add(arrayVO);
+        }
+        arrayVOList.sort(Comparator.comparing(rArrayVO -> rArrayVO.getSort()));
+        return arrayVOList;
+    }
+
+    /**
+     * 便利赋值
+     *
+     * @param DictDataList   稳态指标类型集合
+     * @param statharmonicVO 暂态监测点
+     * @param arrayVO        初始化对象
+     */
+    private void assignDict(List<DictData> DictDataList, List<RStatHarmonicMVO> statharmonicVO, RArrayVO arrayVO) {
+        for (DictData dictData : DictDataList) {
+            RStatHarmonicMVO notStatHarmonicVO = new RStatHarmonicMVO();
+            notStatHarmonicVO.setHarmonicName(dictData.getName());
+            notStatHarmonicVO.setSort(dictData.getSort());
+            notStatHarmonicVO.setOverLimitMeasurementAverage(0);
+            notStatHarmonicVO.setOverLimitMeasurementAccrued(0);
+            notStatHarmonicVO.setOverDay(0);
+            notStatHarmonicVO.setOverLimitMeasurementRatioAverage(0.0F);
+            notStatHarmonicVO.setOverLimitMeasurementRatioAccrued(0.0F);
+            notStatHarmonicVO.setAverageOverDay(0.0F);
+            statharmonicVO.add(notStatHarmonicVO);
+        }
+        arrayVO.setColumns(statharmonicVO);
+    }
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatHarmonicYServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatHarmonicYServiceImpl.java
@@ -0,0 +1,220 @@
+package com.njcn.harmonic.service.majornetwork.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.mapper.majornetwork.RStatHarmonicYMapper;
+import com.njcn.harmonic.pojo.po.RStatHarmonicY;
+import com.njcn.harmonic.pojo.vo.RArrayVO;
+import com.njcn.harmonic.pojo.vo.RStatHarmonicMVO;
+import com.njcn.harmonic.service.majornetwork.RStatHarmonicYService;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataEnum;
+import com.njcn.system.enums.DicDataTypeEnum;
+import com.njcn.system.pojo.po.DictData;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-12
+ */
+@Service
+@RequiredArgsConstructor
+public class RStatHarmonicYServiceImpl extends ServiceImpl<RStatHarmonicYMapper, RStatHarmonicY> implements RStatHarmonicYService {
+
+    private final RStatHarmonicYMapper rStatHarmonicYMapper;
+    private final DicDataFeignClient dicDataFeignClient;
+
+    @Override
+    public List<RArrayVO> getRStatHarmonicYAll(StatisticsBizBaseParam param) {
+        //子节点 获取所有得干扰源类型（监测点类型）
+        List<DictData> interferenceSourceTypeData = dicDataFeignClient.getDicDataByTypeCode(
+                DicDataTypeEnum.MONITORING_LABELS.getCode()).getData();
+        Map<String, DictData> interferenceMap = interferenceSourceTypeData.stream().collect(Collectors.toMap(DictData::getId, Function.identity()));
+
+        //对象主节点 获取所有得指标类型
+        List<DictData> lineTypeData = dicDataFeignClient.getDicDataByTypeCode
+                (DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+        Map<String, DictData> lineTypeMap = lineTypeData.stream()
+                .collect(Collectors.toMap(DictData::getId, Function.identity()));
+        //获取主网id信息
+        DictData mainnetData = dicDataFeignClient.getDicDataByCode(DicDataEnum.MAINNET_POINT.getCode()).getData();
+
+        //数据库查询
+        List<RStatHarmonicY> list = rStatHarmonicYMapper.selectList(new LambdaQueryWrapper<RStatHarmonicY>()
+                .eq(RStatHarmonicY::getDataType, mainnetData.getId())
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatHarmonicY::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatHarmonicY::getDataDate, param.getEndTime()));
+
+        //初始化指标类型（横向）
+        List<RArrayVO> arrayVOList = new ArrayList<>();
+
+
+        List<RStatHarmonicMVO> rm = new ArrayList<>();
+        for (DictData lineTypeDatum : interferenceSourceTypeData) {
+            RStatHarmonicMVO r = new RStatHarmonicMVO();
+            r.setHarmonicName(lineTypeDatum.getName());
+            r.setSort(lineTypeDatum.getSort());
+            r.setOverLimitMeasurementAverage(0);
+            r.setOverLimitMeasurementAccrued(0);
+            r.setAverageOverDay(0.0F);
+            r.setOverDay(0);
+            r.setOverLimitMeasurementRatioAverage(0.0F);
+            r.setOverLimitMeasurementRatioAccrued(0.0F);
+            rm.add(r);
+        }
+        for (DictData lineTypeDatum : lineTypeData) {
+            RArrayVO r = new RArrayVO();
+            r.setRowName(lineTypeDatum.getName());
+            r.setColumns(rm);
+            r.setSort(lineTypeDatum.getSort());
+            arrayVOList.add(r);
+        }
+        //根据稳态指标分组
+        Map<String, List<RStatHarmonicY>> MeasurementTypeClassMap = list.stream().collect(Collectors.groupingBy(RStatHarmonicY::getHarmonicType));
+        //重新生成数据结构
+        MeasurementTypeClassMap.forEach((key, value) -> {
+            if (lineTypeMap.containsKey(key)) {
+                RArrayVO arrayVO = new RArrayVO();
+                DictData data = lineTypeMap.get(key);
+                arrayVO.setRowName(data.getName());
+                arrayVO.setSort(data.getSort());
+                List<RStatHarmonicMVO> b = new ArrayList<>();
+                b.addAll(rm);
+                for (RStatHarmonicY rStatHarmonicY : value) {
+                    if(interferenceMap.containsKey(rStatHarmonicY.getMeasurementTypeClass())){
+                        RStatHarmonicMVO r = BeanUtil.copyProperties(rStatHarmonicY, RStatHarmonicMVO.class);
+                        DictData data1 = interferenceMap.get(rStatHarmonicY.getMeasurementTypeClass());
+                        r.setHarmonicName(data1.getName());
+                        r.setSort(data1.getSort());
+                        r.setOverDay(0);
+                        b.add(r);
+                    }
+
+                }
+                Map<String, RStatHarmonicMVO> linkedHashMap = new LinkedHashMap<>();
+                for (RStatHarmonicMVO harmonicMVO : b) {
+                    linkedHashMap.put(harmonicMVO.getHarmonicName(), harmonicMVO);
+                }
+                List<RStatHarmonicMVO> aa = new ArrayList<>(linkedHashMap.values());
+                aa.sort(Comparator.comparing(rStatHarmonicMVO -> rStatHarmonicMVO.getSort()));
+                arrayVO.setColumns(aa);
+                arrayVOList.add(arrayVO);
+            }
+
+        });
+        Map<String, RArrayVO> linkedHashMap = new LinkedHashMap<>();
+        for (RArrayVO rStatHarmonicMVO : arrayVOList) {
+            linkedHashMap.put(rStatHarmonicMVO.getRowName(), rStatHarmonicMVO);
+        }
+        List<RArrayVO> aa = new ArrayList<>(linkedHashMap.values());
+        arrayVOList.sort(Comparator.comparing(rArrayVO -> rArrayVO.getSort()));
+        return aa;
+    }
+
+    @Override
+    public List<RArrayVO> getPwRStatHarmonicYAll(StatisticsBizBaseParam param) {
+        //对象主节点 获取所有的稳态类型
+        List<DictData> steadyData = dicDataFeignClient.getDicDataByTypeCode(
+                DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+        Map<String, DictData> steadyMap = steadyData.stream()
+                .collect(Collectors.toMap(DictData::getId, Function.identity()));
+
+        //子节点获取监测点类别
+        List<DictData> lineData = dicDataFeignClient.getDicDataByTypeCode(
+                DicDataTypeEnum.LINE_SORT.getCode()).getData();
+        Map<String, DictData> lineMap = lineData.stream()
+                .collect(Collectors.toMap(DictData::getId, Function.identity()));
+
+        //获取配网id信息
+        DictData distributionData = dicDataFeignClient.getDicDataByCode(DicDataEnum.DISTRIBUTION_POINT.getCode()).getData();
+        //初始化指标类型（横向）
+        List<RArrayVO> arrayVOList = new ArrayList<>();
+        //数据库查询
+        List<RStatHarmonicY> list = rStatHarmonicYMapper.selectList(new LambdaQueryWrapper<RStatHarmonicY>()
+                .eq(RStatHarmonicY::getDataType, distributionData.getId())
+                .ge(param.getStartTime() != null, RStatHarmonicY::getDataDate, param.getStartTime())
+                .le(param.getEndTime() != null, RStatHarmonicY::getDataDate, param.getEndTime()));
+        //根据稳态指标分组
+        Map<String, List<RStatHarmonicY>> measurementMap = list.stream().collect(Collectors.groupingBy(RStatHarmonicY::getHarmonicType));
+
+        //判断对象是否为空
+        if(CollUtil.isNotEmpty(list)){
+            //重新生成数据结构
+            measurementMap.forEach((key, value) -> {
+                List<RStatHarmonicMVO> eventVO = new ArrayList<>();
+                if (steadyMap.containsKey(key)) {
+                    RArrayVO arrayVO = new RArrayVO();
+                    DictData data = steadyMap.get(key);
+                    arrayVO.setRowName(data.getName());
+                    arrayVO.setSort(data.getSort());
+                    for (RStatHarmonicY statHarmonic : value) {
+                        if(lineMap.containsKey(statHarmonic.getMeasurementTypeClass())){
+                            RStatHarmonicMVO r = BeanUtil.copyProperties(statHarmonic, RStatHarmonicMVO.class);
+                            DictData data1 = lineMap.get(statHarmonic.getMeasurementTypeClass());
+                            r.setHarmonicName(data1.getName());
+                            r.setSort(data1.getSort());
+                            eventVO.add(r);
+                        }
+                    }
+                    //根据监测点类别获取差集
+                    Map<String, List<RStatHarmonicY>> listMap = value.stream().collect(Collectors.groupingBy(RStatHarmonicY::getMeasurementTypeClass));
+                    List<DictData> differenceList = lineData.stream().filter(r -> !listMap.containsKey(r.getId()))
+                            .collect(Collectors.toList());
+                    this.assignDict(differenceList, eventVO, arrayVO);
+                    eventVO.sort(Comparator.comparing(statHarmonic -> statHarmonic.getSort()));
+                    arrayVOList.add(arrayVO);
+                }
+            });
+        }
+        //处理主节点不存在的集合
+        List<DictData> notMeasurementList = steadyData.stream().filter(r -> !measurementMap.containsKey(r.getId()))
+                .collect(Collectors.toList());
+        for (DictData notData : notMeasurementList) {
+            List<RStatHarmonicMVO> statharmonicVO = new ArrayList<>();
+            RArrayVO arrayVO = new RArrayVO();
+            arrayVO.setRowName(notData.getName());
+            arrayVO.setSort(notData.getSort());
+            this.assignDict(lineData, statharmonicVO, arrayVO);
+            statharmonicVO.sort(Comparator.comparing(statHarmonic -> statHarmonic.getSort()));
+            arrayVOList.add(arrayVO);
+        }
+        arrayVOList.sort(Comparator.comparing(rArrayVO -> rArrayVO.getSort()));
+        return arrayVOList;
+    }
+
+    /**
+     * 便利赋值
+     *
+     * @param DictDataList   稳态指标类型集合
+     * @param statharmonicVO 暂态监测点
+     * @param arrayVO        初始化对象
+     */
+    private void assignDict(List<DictData> DictDataList, List<RStatHarmonicMVO> statharmonicVO, RArrayVO arrayVO) {
+        for (DictData dictData : DictDataList) {
+            RStatHarmonicMVO notStatHarmonicVO = new RStatHarmonicMVO();
+            notStatHarmonicVO.setHarmonicName(dictData.getName());
+            notStatHarmonicVO.setSort(dictData.getSort());
+            notStatHarmonicVO.setOverLimitMeasurementAverage(0);
+            notStatHarmonicVO.setOverLimitMeasurementAccrued(0);
+            notStatHarmonicVO.setOverDay(0);
+            notStatHarmonicVO.setOverLimitMeasurementRatioAverage(0.0F);
+            notStatHarmonicVO.setOverLimitMeasurementRatioAccrued(0.0F);
+            notStatHarmonicVO.setAverageOverDay(0.0F);
+            statharmonicVO.add(notStatHarmonicVO);
+        }
+        arrayVO.setColumns(statharmonicVO);
+    }
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatLoadTypeServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatLoadTypeServiceImpl.java
@@ -0,0 +1,138 @@
+package com.njcn.harmonic.service.majornetwork.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollectionUtil;
+import com.njcn.common.pojo.constant.BizParamConstant;
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.mapper.majornetwork.RStatLoadTypeMMapper;
+import com.njcn.harmonic.mapper.majornetwork.RStatLoadTypeQMapper;
+import com.njcn.harmonic.mapper.majornetwork.RStatLoadTypeYMapper;
+import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
+import com.njcn.harmonic.pojo.po.*;
+import com.njcn.harmonic.pojo.vo.RArrayVO;
+import com.njcn.harmonic.pojo.vo.RStatLoadTypeVO;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.harmonic.service.majornetwork.RStatLoadTypeService;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataTypeEnum;
+import com.njcn.system.pojo.po.DictData;
+import com.njcn.user.api.DeptFeignClient;
+import com.njcn.user.pojo.dto.DeptDTO;
+import com.njcn.web.utils.WebUtil;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-19
+ */
+@Service
+@RequiredArgsConstructor
+public class RStatLoadTypeServiceImpl extends ServiceImpl<RStatLoadTypeMMapper, RStatLoadTypeM> implements RStatLoadTypeService {
+
+    private final DeptFeignClient deptFeignClient;
+    private final DicDataFeignClient dicDataFeignClient;
+    private final RStatLoadTypeYMapper rStatLoadTypeYMapper;
+    private final RStatLoadTypeQMapper rStatLoadTypeQMapper;
+    private final RStatLoadTypeMMapper rStatLoadTypeMMapper;
+
+    @Override
+    public List<RArrayVO> getRStatLoadType(StatisticsBizBaseParam param) {
+        //获取部门信息
+        List<DeptDTO> data = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        List<String> deptIds = data.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        //获取字典信息
+        List<DictData> data1 = dicDataFeignClient.getDicDataByTypeCode(
+                DicDataTypeEnum.MONITORING_LABELS.getCode()).getData();
+        List<DictData> dictData = data1.stream().filter(dictdatas -> dictdatas.getLevel() == 1).collect(Collectors.toList());
+        dictData.sort(Comparator.comparing(r -> r.getSort()));
+        //初始化对象
+        List<RArrayVO> info = new ArrayList<>();
+        List<RStatLoadTypeVO> temp = new ArrayList<>();
+        //根据部门进行筛选
+        StatSubstationBizBaseParam baseParam = BeanUtil.copyProperties(param, StatSubstationBizBaseParam.class);
+        baseParam.setIds(deptIds);
+        if (CollectionUtil.isNotEmpty(data)) {
+            // 类型（1年 2季度 3月份
+            switch (param.getType().toString()) {
+                case BizParamConstant.STAT_BIZ_YEAR:
+                    // 获取年区域暂态指标分类统计表
+                    temp = rStatLoadTypeYMapper.getYearStatLoadType(baseParam);
+                    break;
+                case BizParamConstant.STAT_BIZ_QUARTER:
+                    // 获取季区域暂态指标分类统计表
+                    temp = rStatLoadTypeQMapper.getQuarterStatLoadType(baseParam);
+                    break;
+                case BizParamConstant.STAT_BIZ_MONTH:
+                    // 获取月区域暂态指标分类统计表
+                    temp = rStatLoadTypeMMapper.getMonthStatLoadType(baseParam);
+                    break;
+                default:
+                    break;
+
+            }
+            // 匹配单位名称
+            for (DeptDTO dto : data) {
+                for (RStatLoadTypeVO vo : temp) {
+                    if (dto.getId().equals(vo.getOrgNo())) {
+                        vo.setOrgName(dto.getName());
+                    }
+                }
+            }
+            //根据部门id进行分组
+            Map<String, List<RStatLoadTypeVO>> map = temp
+                    .stream().collect(Collectors.groupingBy(RStatLoadTypeVO::getOrgNo));
+            map.forEach((key, value) -> {
+                RArrayVO arrayVO = new RArrayVO();
+                arrayVO.setRowName(value.get(0).getOrgName());
+                //属性赋值监测点名称
+                for (DictData dictDatum : dictData) {
+                    for (RStatLoadTypeVO rStatLoadTypeVO : value) {
+                        if (dictDatum.getId().equals(rStatLoadTypeVO.getLoadType())) {
+                            rStatLoadTypeVO.setLoadName(dictDatum.getName());
+                            rStatLoadTypeVO.setSort(dictDatum.getSort());
+
+                        }
+                    }
+                }
+                //获取差集（数据在字典里面没有的集合）
+                Map<String, List<RStatLoadTypeVO>> listMap = value.stream().collect(Collectors.groupingBy(RStatLoadTypeVO::getLoadType));
+                List<DictData> differenceList = dictData.stream().filter(r -> !listMap.containsKey(r.getId()))
+                        .collect(Collectors.toList());
+                for (DictData data4 : differenceList) {
+                    RStatLoadTypeVO vo = new RStatLoadTypeVO();
+                    vo.setSort(data4.getSort());
+                    vo.setOrgNo(key);
+                    vo.setOrgName(value.get(0).getOrgName());
+                    vo.setLoadType(data4.getId());
+                    vo.setLoadName(data4.getName());
+                    vo.setVAverage(0.0f);
+                    vo.setVAccrued(0.0f);
+                    vo.setIAverage(0.0f);
+                    vo.setIAccrued(0.0f);
+                    vo.setUnbalanceAverage(0.0f);
+                    vo.setUnbalanceAccrued(0.0f);
+                    vo.setINegAverage(0.0f);
+                    vo.setINegAccrued(0.0f);
+                    vo.setFlickerAverage(0.0f);
+                    vo.setFlickerAccrued(0.0f);
+                    value.add(vo);
+                }
+                value.sort(Comparator.comparing(r -> r.getSort()));
+                arrayVO.setColumns(value);
+                info.add(arrayVO);
+            });
+        }
+        return info;
+    }
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatOrgBusbarVoltageServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatOrgBusbarVoltageServiceImpl.java
@@ -0,0 +1,104 @@
+package com.njcn.harmonic.service.majornetwork.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollectionUtil;
+import com.njcn.common.pojo.constant.BizParamConstant;
+import com.njcn.device.pms.api.PmsGeneratrixClient;
+import com.njcn.device.pms.pojo.dto.GeneratrixAndPowerStationDTO;
+import com.njcn.device.pms.pojo.param.PmsGeneratrixParam;
+import com.njcn.harmonic.mapper.majornetwork.RStatOrgBusbarVoltageQMapper;
+import com.njcn.harmonic.mapper.majornetwork.RStatOrgBusbarVoltageYMapper;
+import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatOrgBusbarVoltageM;
+import com.njcn.harmonic.mapper.majornetwork.RStatOrgBusbarVoltageMMapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.harmonic.pojo.vo.RStatOrgBusbarVoltageVO;
+import com.njcn.harmonic.service.majornetwork.RStatOrgBusbarVoltageService;
+import com.njcn.user.api.DeptFeignClient;
+import com.njcn.user.pojo.dto.DeptDTO;
+import com.njcn.web.utils.WebUtil;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-19
+ */
+@Service
+@RequiredArgsConstructor
+public class RStatOrgBusbarVoltageServiceImpl extends ServiceImpl<RStatOrgBusbarVoltageMMapper, RStatOrgBusbarVoltageM> implements RStatOrgBusbarVoltageService {
+
+    private final DeptFeignClient deptFeignClient;
+    private final RStatOrgBusbarVoltageYMapper rStatOrgBusbarVoltageYMapper;
+    private final RStatOrgBusbarVoltageQMapper rStatOrgBusbarVoltageQMapper;
+    private final RStatOrgBusbarVoltageMMapper rStatOrgBusbarVoltageMMapper;
+    private final PmsGeneratrixClient pmsGeneratrixClient;
+
+    @Override
+    public List<RStatOrgBusbarVoltageVO> getRStatOrgBusbarVoltage(StatSubstationBizBaseParam param) {
+        //获取部门信息
+        List<DeptDTO> data = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        Map<String, DeptDTO> deptMap = data.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+
+        //获取部门id集合
+        List<String> deptIds = data.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        List<RStatOrgBusbarVoltageVO> info = new ArrayList<>();
+        List<RStatOrgBusbarVoltageVO> temp = new ArrayList<>();
+        if (CollectionUtil.isNotEmpty(data)) {
+            StatSubstationBizBaseParam baseParam = BeanUtil.copyProperties(param, StatSubstationBizBaseParam.class);
+            baseParam.setIds(deptIds);
+            // 类型（1年 2季度 3月份)
+            switch (param.getType().toString()) {
+                case BizParamConstant.STAT_BIZ_YEAR:
+                    // 获取年区域电站母线电压类指标超标计
+                    temp = rStatOrgBusbarVoltageYMapper.getYstatOrgBusbarVoltageVO(baseParam);
+                    break;
+                case BizParamConstant.STAT_BIZ_QUARTER:
+                    // 获取季区域电站母线电压类指标超标计
+                    temp = rStatOrgBusbarVoltageQMapper.getQstatOrgBusbarVoltageVO(baseParam);
+                    break;
+                case BizParamConstant.STAT_BIZ_MONTH:
+                    // 获取月区域电站母线电压类指标超标计
+                    temp = rStatOrgBusbarVoltageMMapper.getMstatOrgBusbarVoltageVO(baseParam);
+                    break;
+                default:
+                    break;
+            }
+        }
+        if (CollectionUtil.isNotEmpty(temp)) {
+            //获取母线集合
+            List<String> busbarIds = temp.stream().map(RStatOrgBusbarVoltageVO::getBusbarId).collect(Collectors.toList());
+            PmsGeneratrixParam generatrixParam=new PmsGeneratrixParam();
+            generatrixParam.setGeneratrixIds(busbarIds);
+            generatrixParam.setGeneratrixVoltageLevel(param.getIds());
+            List<GeneratrixAndPowerStationDTO> generatrixDTO = pmsGeneratrixClient.getGeneratrixAndPowerStationInfo(generatrixParam).getData();
+            Map<String, GeneratrixAndPowerStationDTO> generatrixMap = generatrixDTO.stream().collect(
+                    Collectors.toMap(GeneratrixAndPowerStationDTO::getGeneratrixId, Function.identity()));
+            Map<String, RStatOrgBusbarVoltageVO> orgMap = temp.stream().collect(Collectors.toMap(RStatOrgBusbarVoltageVO::getOrgNo, Function.identity()));
+            orgMap.forEach((key, value) -> {
+                if (deptMap.containsKey(key)) {
+                    DeptDTO deptDTO = deptMap.get(key);
+                    value.setOrgName(deptDTO.getName());
+                    if(generatrixMap.containsKey(value.getBusbarId())){
+                        GeneratrixAndPowerStationDTO dto = generatrixMap.get(value.getBusbarId());
+                        value.setBusbarVoltageLevel(dto.getGeneratrixVoltageLevel());
+                        value.setPowerStationName(dto.getPowerName());
+                        info.add(value);
+                    }
+                }
+            });
+        }
+        return info;
+    }
+
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatOrgMServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatOrgMServiceImpl.java
@@ -0,0 +1,86 @@
+package com.njcn.harmonic.service.majornetwork.impl;
+
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatOrgM;
+import com.njcn.harmonic.mapper.majornetwork.RStatOrgMMapper;
+import com.njcn.harmonic.pojo.vo.RStatOrgVO;
+import com.njcn.harmonic.service.majornetwork.RStatOrgMService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataEnum;
+import com.njcn.system.pojo.po.DictData;
+import com.njcn.user.api.DeptFeignClient;
+import com.njcn.user.pojo.dto.DeptDTO;
+import com.njcn.web.utils.WebUtil;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 区域分类统计月表 服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-17
+ */
+@Service
+@RequiredArgsConstructor
+public class RStatOrgMServiceImpl extends ServiceImpl<RStatOrgMMapper, RStatOrgM> implements RStatOrgMService {
+
+    private final DeptFeignClient deptFeignClient;
+    private final DicDataFeignClient dicDataFeignClient;
+    private final RStatOrgMMapper rStatOrgMMapper;
+
+    @Override
+    public List<RStatOrgVO> getRStatHarmonicMAll(StatisticsBizBaseParam param) {
+        List<DeptDTO> deptDTOList = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        //获取部门id集合
+        List<String> deptIds = deptDTOList.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        Map<String, DeptDTO> deptMap = deptDTOList.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+        //获取主网id信息
+        DictData mainnetData = dicDataFeignClient.getDicDataByCode(DicDataEnum.MAINNET_POINT.getCode()).getData();
+        //数据库查询
+        List<RStatOrgM> list = rStatOrgMMapper.selectList(new LambdaQueryWrapper<RStatOrgM>()
+                .eq(RStatOrgM::getDataType, mainnetData.getId())
+                .in(RStatOrgM::getOrgNo, deptIds)
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatOrgM::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatOrgM::getDataDate, param.getEndTime()));
+        Map<String, List<RStatOrgM>> collect = list.stream().collect(Collectors.groupingBy(RStatOrgM::getOrgNo));
+
+        List<RStatOrgVO> newList = new ArrayList<>();
+        collect.forEach((key, value) -> {
+            if (deptMap.containsKey(key)) {
+                for (RStatOrgM rStatOrgM : value) {
+                    DecimalFormat df = new DecimalFormat("###.00");
+                    DeptDTO deptDTO = deptMap.get(key);
+                    RStatOrgVO rStatOrgVO = new RStatOrgVO();
+                    rStatOrgVO.setOrgName(deptDTO.getName());
+                    Float averageOverDay = Float.parseFloat(
+                            df.format(rStatOrgM.getOverDayAccrued() / (rStatOrgM.getEffectiveMeasurementAccrued() * 1.0)));
+                    rStatOrgVO.setAverageOverDay(averageOverDay);
+                    rStatOrgVO.setEffectiveMeasurementAverage(rStatOrgM.getEffectiveMeasurementAverage());
+                    rStatOrgVO.setEffectiveMeasurementAccrued(rStatOrgM.getEffectiveMeasurementAccrued());
+                    rStatOrgVO.setOverLimitMeasurementAverage(rStatOrgM.getHarmonicMeasurementAverage());
+                    rStatOrgVO.setOverLimitMeasurementAccrued(rStatOrgM.getHarmonicMeasurementAccrued());
+                    Float harmonicMeasurementRatioAverage = Float.parseFloat(
+                            df.format(rStatOrgM.getHarmonicMeasurementAverage() / (rStatOrgM.getEffectiveMeasurementAverage() * 1.0)));
+                    rStatOrgVO.setHarmonicMeasurementRatioAverage(harmonicMeasurementRatioAverage);
+                    Float harmonicMeasurementRatioAccrued = Float.parseFloat(
+                            df.format(rStatOrgM.getHarmonicMeasurementAccrued() / (rStatOrgM.getEffectiveMeasurementAccrued() * 1.0)));
+                    rStatOrgVO.setHarmonicMeasurementRatioAccrued(harmonicMeasurementRatioAccrued);
+                    newList.add(rStatOrgVO);
+                }
+            }
+        });
+        return newList;
+    }
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatOrgQServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatOrgQServiceImpl.java
@@ -0,0 +1,86 @@
+package com.njcn.harmonic.service.majornetwork.impl;
+
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatOrgQ;
+import com.njcn.harmonic.mapper.majornetwork.RStatOrgQMapper;
+import com.njcn.harmonic.pojo.vo.RStatOrgVO;
+import com.njcn.harmonic.service.majornetwork.RStatOrgQService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataEnum;
+import com.njcn.system.pojo.po.DictData;
+import com.njcn.user.api.DeptFeignClient;
+import com.njcn.user.pojo.dto.DeptDTO;
+import com.njcn.web.utils.WebUtil;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 区域分类统计季表 服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-17
+ */
+@Service
+@RequiredArgsConstructor
+public class RStatOrgQServiceImpl extends ServiceImpl<RStatOrgQMapper, RStatOrgQ> implements RStatOrgQService {
+
+    private final DeptFeignClient deptFeignClient;
+    private final DicDataFeignClient dicDataFeignClient;
+    private final RStatOrgQMapper rStatOrgQMapper;
+
+    @Override
+    public List<RStatOrgVO> getRStatHarmonicQAll(StatisticsBizBaseParam param) {
+        List<DeptDTO> deptDTOList = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        //获取部门id集合
+        List<String> deptIds = deptDTOList.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        Map<String, DeptDTO> deptMap = deptDTOList.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+
+        //获取主网id信息
+        DictData mainnetData = dicDataFeignClient.getDicDataByCode(DicDataEnum.MAINNET_POINT.getCode()).getData();
+
+        //数据库查询
+        List<RStatOrgQ> list = rStatOrgQMapper.selectList(new LambdaQueryWrapper<RStatOrgQ>()
+                .eq(RStatOrgQ::getDataType, mainnetData.getId())
+                .in(RStatOrgQ::getOrgNo, deptIds)
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatOrgQ::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatOrgQ::getDataDate, param.getEndTime()));
+        Map<String, List<RStatOrgQ>> collect = list.stream().collect(Collectors.groupingBy(RStatOrgQ::getOrgNo));
+
+        List<RStatOrgVO> newList = new ArrayList<>();
+        collect.forEach((key, value) -> {
+            if (deptMap.containsKey(key)) {
+                for (RStatOrgQ rStatOrgQ : value) {
+                    DeptDTO deptDTO = deptMap.get(key);
+                    RStatOrgVO rStatOrgVO = new RStatOrgVO();
+                    rStatOrgVO.setOrgName(deptDTO.getName());
+                    rStatOrgVO.setAverageOverDay(rStatOrgQ.getAverageOverDay());
+                    rStatOrgVO.setEffectiveMeasurementAverage(rStatOrgQ.getEffectiveMeasurementAverage());
+                    rStatOrgVO.setEffectiveMeasurementAccrued(rStatOrgQ.getEffectiveMeasurementAccrued());
+                    rStatOrgVO.setOverLimitMeasurementAverage(rStatOrgQ.getHarmonicMeasurementAverage());
+                    rStatOrgVO.setOverLimitMeasurementAccrued(rStatOrgQ.getHarmonicMeasurementAccrued());
+                    DecimalFormat df = new DecimalFormat("###.00");
+                    Float harmonicMeasurementRatioAverage = Float.parseFloat(
+                            df.format(rStatOrgQ.getHarmonicMeasurementAverage() / (rStatOrgQ.getEffectiveMeasurementAverage() * 1.0)));
+                    rStatOrgVO.setHarmonicMeasurementRatioAverage(harmonicMeasurementRatioAverage);
+                    Float harmonicMeasurementRatioAccrued = Float.parseFloat(
+                            df.format(rStatOrgQ.getHarmonicMeasurementAccrued() / (rStatOrgQ.getEffectiveMeasurementAccrued() * 1.0)));
+                    rStatOrgVO.setHarmonicMeasurementRatioAccrued(harmonicMeasurementRatioAccrued);
+                    newList.add(rStatOrgVO);
+                }
+            }
+        });
+        return newList;
+    }
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatOrgYServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatOrgYServiceImpl.java
@@ -0,0 +1,386 @@
+package com.njcn.harmonic.service.majornetwork.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.njcn.common.pojo.constant.BizParamConstant;
+import com.njcn.common.pojo.dto.SimpleDTO;
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.device.pms.api.MonitorClient;
+import com.njcn.device.pms.api.PmsGeneralDeviceInfoClient;
+import com.njcn.device.pms.pojo.dto.PmsGeneralDeviceDTO;
+import com.njcn.device.pms.pojo.dto.PmsMonitorDTO;
+import com.njcn.device.pms.pojo.param.PmsDeviceInfoParam;
+import com.njcn.device.pms.pojo.param.PmsMonitorParam;
+import com.njcn.harmonic.mapper.majornetwork.RStatOrgMMapper;
+import com.njcn.harmonic.mapper.majornetwork.RStatOrgQMapper;
+import com.njcn.harmonic.mapper.majornetwork.RStatOrgYMapper;
+import com.njcn.harmonic.mapper.majornetwork.RStatSubstationMMapper;
+import com.njcn.harmonic.mapper.majornetwork.RStatSubstationQMapper;
+import com.njcn.harmonic.mapper.majornetwork.RStatSubstationYMapper;
+import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatOrgY;
+import com.njcn.harmonic.pojo.vo.*;
+import com.njcn.harmonic.service.majornetwork.RStatOrgYService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataEnum;
+import com.njcn.system.enums.DicDataTypeEnum;
+import com.njcn.system.pojo.po.DictData;
+import com.njcn.user.api.DeptFeignClient;
+import com.njcn.user.pojo.dto.DeptDTO;
+import com.njcn.web.utils.WebUtil;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 区域分类统计年表 服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-17
+ */
+@Service
+@RequiredArgsConstructor
+public class RStatOrgYServiceImpl extends ServiceImpl<RStatOrgYMapper, RStatOrgY> implements RStatOrgYService {
+
+    private final DeptFeignClient deptFeignClient;
+    private final DicDataFeignClient dicDataFeignClient;
+    private final RStatOrgYMapper rStatOrgYMapper;
+    private final RStatOrgQMapper rStatOrgQMapper;
+    private final RStatOrgMMapper rStatOrgMMapper;
+    private final RStatSubstationMMapper rStatSubstationMMapper;
+    private final RStatSubstationQMapper rStatSubstationQMapper;
+    private final RStatSubstationYMapper rStatSubstationYMapper;
+    private final MonitorClient monitorClient;
+    private final PmsGeneralDeviceInfoClient pmsGeneralDeviceInfoClient;
+
+    @Override
+    public List<RStatOrgVO> getRStatHarmonicYAll(StatisticsBizBaseParam param) {
+        List<DeptDTO> deptDTOList = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        //获取部门id集合
+        List<String> deptIds = deptDTOList.stream().map(DeptDTO::getId).collect(Collectors.toList());
+        Map<String, DeptDTO> deptMap = deptDTOList.stream().collect(Collectors.toMap(DeptDTO::getId, Function.identity()));
+
+        //获取主网id信息
+        DictData mainnetData = dicDataFeignClient.getDicDataByCode(DicDataEnum.MAINNET_POINT.getCode()).getData();
+
+        //数据库查询
+        List<RStatOrgY> list = rStatOrgYMapper.selectList(new LambdaQueryWrapper<RStatOrgY>()
+                .eq(RStatOrgY::getDataType, mainnetData.getId())
+                .in(RStatOrgY::getOrgNo, deptIds)
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatOrgY::getDataDate, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatOrgY::getDataDate, param.getEndTime()));
+        Map<String, List<RStatOrgY>> collect = list.stream().collect(Collectors.groupingBy(RStatOrgY::getOrgNo));
+
+        List<RStatOrgVO> newList = new ArrayList<>();
+        collect.forEach((key, value) -> {
+            if (deptMap.containsKey(key)) {
+                for (RStatOrgY rStatOrgY : value) {
+                    DeptDTO deptDTO = deptMap.get(key);
+                    RStatOrgVO rStatOrgVO = new RStatOrgVO();
+                    rStatOrgVO.setOrgName(deptDTO.getName());
+                    rStatOrgVO.setAverageOverDay(rStatOrgY.getAverageOverDay());
+                    rStatOrgVO.setEffectiveMeasurementAverage(rStatOrgY.getEffectiveMeasurementAverage());
+                    rStatOrgVO.setEffectiveMeasurementAccrued(rStatOrgY.getEffectiveMeasurementAccrued());
+                    rStatOrgVO.setOverLimitMeasurementAverage(rStatOrgY.getOverLimitMeasurementAverage());
+                    rStatOrgVO.setOverLimitMeasurementAccrued(rStatOrgY.getOverLimitMeasurementAccrued());
+                    DecimalFormat df = new DecimalFormat("###.00");
+                    Float harmonicMeasurementRatioAverage = Float.parseFloat(
+                            df.format(rStatOrgY.getOverLimitMeasurementAverage() / (rStatOrgY.getEffectiveMeasurementAverage() * 1.0)));
+                    rStatOrgVO.setHarmonicMeasurementRatioAverage(harmonicMeasurementRatioAverage);
+                    Float harmonicMeasurementRatioAccrued = Float.parseFloat(
+                            df.format(rStatOrgY.getOverLimitMeasurementAccrued() / (rStatOrgY.getEffectiveMeasurementAccrued() * 1.0)));
+                    rStatOrgVO.setHarmonicMeasurementRatioAccrued(harmonicMeasurementRatioAccrued);
+                    newList.add(rStatOrgVO);
+                }
+            }
+        });
+        return newList;
+    }
+
+    @Override
+    public List<RStatSubstationOrg2VO> getRStatSubstationOrg(StatisticsBizBaseParam param) {
+        // 获取当前用户的部门的子部门信息
+        List<DeptDTO> data = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        List<RStatSubstationOrg2VO> info = new ArrayList<>();
+        if (CollectionUtil.isNotEmpty(data)) {
+            // 根据暂态指标枚举查询暂态指标
+            List<DictData> eventStatis = dicDataFeignClient.getDicDataByTypeCode(
+                    DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
+            List<RStatSubstationOrgVO> temp = new ArrayList<>();
+            // 过滤出部门id
+            List<String> deptIds = data.stream().map(DeptDTO::getId).collect(Collectors.toList());
+            StatSubstationBizBaseParam baseParam = BeanUtil.copyProperties(param, StatSubstationBizBaseParam.class);
+            baseParam.setIds(deptIds);
+            //获取主网id信息
+            DictData mainnetData = dicDataFeignClient.getDicDataByCode(DicDataEnum.MAINNET_POINT.getCode()).getData();
+
+            // 类型（1年 2季度 3月份 4日
+            switch (param.getType().toString()) {
+                case BizParamConstant.STAT_BIZ_YEAR:
+                    // 获取年区域暂态指标分类统计表
+                    temp = rStatOrgYMapper.getYearRStatHarmonicOrgInfo(baseParam, mainnetData.getId());
+                    break;
+                case BizParamConstant.STAT_BIZ_QUARTER:
+                    // 获取季区域暂态指标分类统计表
+                    temp = rStatOrgQMapper.getQuarterRStatHarmonicOrgInfo(baseParam, mainnetData.getId());
+                    break;
+                case BizParamConstant.STAT_BIZ_MONTH:
+                    // 获取月区域暂态指标分类统计表
+                    temp = rStatOrgMMapper.getMonthRStatHarmonicOrgInfo(baseParam, mainnetData.getId());
+                    break;
+                default:
+                    break;
+            }
+            Map<String, List<RStatSubstationOrgVO>> map = temp
+                    .stream().collect(Collectors.groupingBy(RStatSubstationOrgVO::getOrgNo));
+            map.forEach((key, value) -> {
+                RStatSubstationOrg2VO vo = new RStatSubstationOrg2VO();
+                vo.setOrgNo(value.get(0).getOrgNo());
+                vo.setOrgName(value.get(0).getOrgName());
+                vo.setDataDate(value.get(0).getDataDate());
+                vo.setEffectiveMeasurementAverage(value.get(0).getEffectiveMeasurementAverage());
+                vo.setEffectiveMeasurementAccrued(value.get(0).getEffectiveMeasurementAccrued());
+                vo.setHarmonicMeasurementAverage(value.get(0).getHarmonicMeasurementAverage());
+                vo.setHarmonicMeasurementAccrued(value.get(0).getHarmonicMeasurementAccrued());
+                vo.setHarmonicMeasurementRatioAverage(value.get(0).getHarmonicMeasurementRatioAverage());
+                vo.setHarmonicMeasurementRatioAccrued(value.get(0).getHarmonicMeasurementRatioAccrued());
+                //遍历赋值
+                for (RStatSubstationOrgVO orgVO : value) {
+                    for (DictData eventStati : eventStatis) {
+                        if (eventStati.getId().equals(orgVO.getHarmonicType())) {
+                            if (eventStati.getCode().equals(RStatSubstationOrg2VO.FREQUENCY_DEV)) {
+                                vo.setTAverage(orgVO.getOverLimitMeasurementAverage());
+                                vo.setTAccrued(orgVO.getOverLimitMeasurementAccrued());
+                                vo.setOAverage(orgVO.getOverLimitMeasurementRatioAverage());
+                                vo.setOAccrued(orgVO.getOverLimitMeasurementRatioAccrued());
+                                vo.setChainAverage(orgVO.getChainAverage());
+                                vo.setChainAccrued(orgVO.getChainAccrued());
+                                vo.setSameAverage(orgVO.getSameAverage());
+                                vo.setSameAccrued(orgVO.getSameAccrued());
+                                vo.setAverageOverDay(orgVO.getAverageOverDay());
+                            }
+                            if (eventStati.getCode().equals(RStatSubstationOrg2VO.VOLTAGE_DEV)) {
+                                vo.setTAverage1(orgVO.getOverLimitMeasurementAverage());
+                                vo.setTAccrued1(orgVO.getOverLimitMeasurementAccrued());
+                                vo.setOAverage1(orgVO.getOverLimitMeasurementRatioAverage());
+                                vo.setOAccrued1(orgVO.getOverLimitMeasurementRatioAccrued());
+                                vo.setChainAverage1(orgVO.getChainAverage());
+                                vo.setChainAccrued1(orgVO.getChainAccrued());
+                                vo.setSameAverage1(orgVO.getSameAverage());
+                                vo.setSameAccrued1(orgVO.getSameAccrued());
+                                vo.setAverageOverDay1(orgVO.getAverageOverDay());
+                            }
+                            if (eventStati.getCode().equals(RStatSubstationOrg2VO.FLICKER)) {
+                                vo.setTAverage2(orgVO.getOverLimitMeasurementAverage());
+                                vo.setTAccrued2(orgVO.getOverLimitMeasurementAccrued());
+                                vo.setOAverage2(orgVO.getOverLimitMeasurementRatioAverage());
+                                vo.setOAccrued2(orgVO.getOverLimitMeasurementRatioAccrued());
+                                vo.setChainAverage2(orgVO.getChainAverage());
+                                vo.setChainAccrued2(orgVO.getChainAccrued());
+                                vo.setSameAverage2(orgVO.getSameAverage());
+                                vo.setSameAccrued2(orgVO.getSameAccrued());
+                                vo.setAverageOverDay2(orgVO.getAverageOverDay());
+                            }
+                            if (eventStati.getCode().equals(RStatSubstationOrg2VO.HARMONIC_VOLTAGE)) {
+                                vo.setTAverage3(orgVO.getOverLimitMeasurementAverage());
+                                vo.setTAccrued3(orgVO.getOverLimitMeasurementAccrued());
+                                vo.setOAverage3(orgVO.getOverLimitMeasurementRatioAverage());
+                                vo.setOAccrued3(orgVO.getOverLimitMeasurementRatioAccrued());
+                                vo.setChainAverage3(orgVO.getChainAverage());
+                                vo.setChainAccrued3(orgVO.getChainAccrued());
+                                vo.setSameAverage3(orgVO.getSameAverage());
+                                vo.setSameAccrued3(orgVO.getSameAccrued());
+                                vo.setAverageOverDay3(orgVO.getAverageOverDay());
+                            }
+                            if (eventStati.getCode().equals(RStatSubstationOrg2VO.HARMONIC_CURRENT)) {
+                                vo.setTAverage4(orgVO.getOverLimitMeasurementAverage());
+                                vo.setTAccrued4(orgVO.getOverLimitMeasurementAccrued());
+                                vo.setOAverage4(orgVO.getOverLimitMeasurementRatioAverage());
+                                vo.setOAccrued4(orgVO.getOverLimitMeasurementRatioAccrued());
+                                vo.setChainAverage4(orgVO.getChainAverage());
+                                vo.setChainAccrued4(orgVO.getChainAccrued());
+                                vo.setSameAverage4(orgVO.getSameAverage());
+                                vo.setSameAccrued4(orgVO.getSameAccrued());
+                                vo.setAverageOverDay4(orgVO.getAverageOverDay());
+                            }
+                            if (eventStati.getCode().equals(RStatSubstationOrg2VO.INTERHARMONIC_VOLTAGE)) {
+                                vo.setTAverage5(orgVO.getOverLimitMeasurementAverage());
+                                vo.setTAccrued5(orgVO.getOverLimitMeasurementAccrued());
+                                vo.setOAverage5(orgVO.getOverLimitMeasurementRatioAverage());
+                                vo.setOAccrued5(orgVO.getOverLimitMeasurementRatioAccrued());
+                                vo.setChainAverage5(orgVO.getChainAverage());
+                                vo.setChainAccrued5(orgVO.getChainAccrued());
+                                vo.setSameAverage5(orgVO.getSameAverage());
+                                vo.setSameAccrued5(orgVO.getSameAccrued());
+                                vo.setAverageOverDay5(orgVO.getAverageOverDay());
+                            }
+                            if (eventStati.getCode().equals(RStatSubstationOrg2VO.PHASE_VOLTAGE)) {
+                                vo.setTAverage6(orgVO.getOverLimitMeasurementAverage());
+                                vo.setTAccrued6(orgVO.getOverLimitMeasurementAccrued());
+                                vo.setOAverage6(orgVO.getOverLimitMeasurementRatioAverage());
+                                vo.setOAccrued6(orgVO.getOverLimitMeasurementRatioAccrued());
+                                vo.setChainAverage6(orgVO.getChainAverage());
+                                vo.setChainAccrued6(orgVO.getChainAccrued());
+                                vo.setSameAverage6(orgVO.getSameAverage());
+                                vo.setSameAccrued6(orgVO.getSameAccrued());
+                                vo.setAverageOverDay6(orgVO.getAverageOverDay());
+                            }
+                            if (eventStati.getCode().equals(RStatSubstationOrg2VO.NEG_CURRENT)) {
+                                vo.setTAverage7(orgVO.getOverLimitMeasurementAverage());
+                                vo.setTAccrued7(orgVO.getOverLimitMeasurementAccrued());
+                                vo.setOAverage7(orgVO.getOverLimitMeasurementRatioAverage());
+                                vo.setOAccrued7(orgVO.getOverLimitMeasurementRatioAccrued());
+                                vo.setChainAverage7(orgVO.getChainAverage());
+                                vo.setChainAccrued7(orgVO.getChainAccrued());
+                                vo.setSameAverage7(orgVO.getSameAverage());
+                                vo.setSameAccrued7(orgVO.getSameAccrued());
+                                vo.setAverageOverDay7(orgVO.getAverageOverDay());
+                            }
+                            if (eventStati.getCode().equals(RStatSubstationOrg2VO.TOTAL_INDICATOR)) {
+                                vo.setTAverage8(orgVO.getOverLimitMeasurementAverage());
+                                vo.setTAccrued8(orgVO.getOverLimitMeasurementAccrued());
+                                vo.setOAverage8(orgVO.getOverLimitMeasurementRatioAverage());
+                                vo.setOAccrued8(orgVO.getOverLimitMeasurementRatioAccrued());
+                                vo.setChainAverage8(orgVO.getChainAverage());
+                                vo.setChainAccrued8(orgVO.getChainAccrued());
+                                vo.setSameAverage8(orgVO.getSameAverage());
+                                vo.setSameAccrued8(orgVO.getSameAccrued());
+                                vo.setAverageOverDay8(orgVO.getAverageOverDay());
+                            }
+
+                        }
+
+                    }
+                }
+                info.add(vo);
+            });
+            // 匹配单位名称
+            for (DeptDTO dto : data) {
+                for (RStatSubstationOrg2VO vo : info) {
+                    if (dto.getId().equals(vo.getOrgNo())) {
+                        vo.setOrgName(dto.getName());
+                    }
+                }
+            }
+        }
+        return info;
+    }
+
+    @Override
+    public List<RSubstationIcon2VO.RSubstationInfoVO> getRStatSubstation(StatSubstationBizBaseParam param) {
+        PmsDeviceInfoParam pms = new PmsDeviceInfoParam();
+        pms.setDeptIndex(param.getId());
+        pms.setStatisticalType(new SimpleDTO());
+        List<PmsGeneralDeviceDTO> data = pmsGeneralDeviceInfoClient.getPmsDeviceInfoWithInOrg(pms).getData();
+        //生成变电站id集合
+        List<String> pAddIds = new ArrayList<>();
+        data.stream().forEach(e -> pAddIds.addAll(e.getPowerrIdList()));
+        List<RSubstationIcon2VO> rSubstationIconVO = new ArrayList<>();
+        //根据监测点id获取变电站信息
+        PmsMonitorParam dto = new PmsMonitorParam();
+        List<String> mAddIds = new ArrayList<>();
+        data.stream().forEach(e -> mAddIds.addAll(e.getMonitorIdList()));
+        dto.setMonitorIds(mAddIds);
+        dto.setPowerrIds(param.getIds());
+        //根据变电站分组
+        List<PmsMonitorDTO> pmsMonitorDTOS = monitorClient.getMonitorInfoListByCond(dto).getData();
+        Map<String, PmsMonitorDTO> pmsMonitorDTOMap = pmsMonitorDTOS.stream()
+                .collect(Collectors.toMap(PmsMonitorDTO::getPowerrId, Function.identity()));
+
+        if (CollUtil.isNotEmpty(pmsMonitorDTOS)) {
+            //获取最新过滤的变电站id
+            List<String> ids = pmsMonitorDTOS.stream().map(PmsMonitorDTO::getPowerrId).collect(Collectors.toList());
+            //根据id进行筛选
+            StatSubstationBizBaseParam baseParam = BeanUtil.copyProperties(param, StatSubstationBizBaseParam.class);
+            baseParam.setIds(ids);
+            String string = param.getType().toString();
+            switch (string) {
+                //查询变电站稳态指标平均超标天数-年数据
+                case BizParamConstant.STAT_BIZ_YEAR:
+                    rSubstationIconVO = rStatSubstationYMapper.getStatSubstationIcon2Y(baseParam);
+                    break;
+                //查询变电站稳态指标平均超标天数-季数据
+                case BizParamConstant.STAT_BIZ_QUARTER:
+                    rSubstationIconVO = rStatSubstationQMapper.getStatSubstationIcon2Q(baseParam);
+                    break;
+                //查询变电站稳态指标平均超标天数-月数据
+                case BizParamConstant.STAT_BIZ_MONTH:
+                    rSubstationIconVO = rStatSubstationMMapper.getStatSubstationIcon2M(baseParam);
+                    break;
+                default:
+                    break;
+            }
+            List<RSubstationIcon2VO.RSubstationInfoVO> rSubstationInfoVOS = BeanUtil.copyToList(rSubstationIconVO, RSubstationIcon2VO.RSubstationInfoVO.class);
+            if (CollectionUtil.isNotEmpty(rSubstationInfoVOS)) {
+                Map<String, RSubstationIcon2VO.RSubstationInfoVO> detailVOMap = rSubstationInfoVOS.stream()
+                        .collect(Collectors.toMap(RSubstationIcon2VO.RSubstationInfoVO::getSubstationId, Function.identity()));
+                detailVOMap.forEach((Key, value) -> {
+                    if (pmsMonitorDTOMap.containsKey(Key)) {
+                        PmsMonitorDTO dto1 = pmsMonitorDTOMap.get(Key);
+                        value.setCityName(dto1.getOrgName());
+                        value.setSubstationName(dto1.getPowerrName());
+                    }
+                });
+            }
+            return rSubstationInfoVOS;
+        }
+        return null;
+    }
+
+    @Override
+    public List<RStatOrgIndexVO.RStatOrgIndexInfoVO> getRStatOrgIndex(StatisticsBizBaseParam param) {
+        // 获取当前用户的部门的子部门信息
+        List<DeptDTO> data = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        List<RStatOrgIndexVO.RStatOrgIndexInfoVO> info = new ArrayList<>();
+        //获取主网id信息
+        DictData mainnetData = dicDataFeignClient.getDicDataByCode(DicDataEnum.MAINNET_POINT.getCode()).getData();
+
+        if (CollectionUtil.isNotEmpty(data)) {
+            // 过滤出部门id
+            List<String> deptIds = data.stream().map(DeptDTO::getId).collect(Collectors.toList());
+            StatSubstationBizBaseParam baseParam = BeanUtil.copyProperties(param, StatSubstationBizBaseParam.class);
+            baseParam.setIds(deptIds);
+            // 类型（1年 2季度 3月份 4日
+            switch (param.getType().toString()) {
+                case BizParamConstant.STAT_BIZ_YEAR:
+                    // 获取年区域稳态指标合格率统计表
+                    info = rStatOrgYMapper.getYearRStatOrgIndex(baseParam, mainnetData.getId());
+                    break;
+                case BizParamConstant.STAT_BIZ_QUARTER:
+                    // 获取季区域稳态指标合格率统计表
+                    info = rStatOrgQMapper.getQuarterRStatOrgIndex(baseParam, mainnetData.getId());
+                    break;
+                case BizParamConstant.STAT_BIZ_MONTH:
+                    // 获取月区域稳态指标合格率统计表
+                    info = rStatOrgMMapper.getMonthRStatOrgIndex(baseParam, mainnetData.getId());
+                    break;
+                default:
+                    break;
+            }
+        }
+        //匹配名称
+        for (DeptDTO dto : data) {
+            for (RStatOrgIndexVO vo : info) {
+                if (dto.getId().equals(vo.getOrgNo())) {
+                    vo.setOrgNo(dto.getId());
+                    vo.setOrgName(dto.getName());
+                }
+            }
+        }
+        return info;
+    }
+
+
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatSubstationMServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatSubstationMServiceImpl.java
@@ -0,0 +1,130 @@
+package com.njcn.harmonic.service.majornetwork.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
+import com.njcn.common.pojo.constant.BizParamConstant;
+import com.njcn.common.pojo.dto.SimpleDTO;
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.device.pms.api.PmsGeneralDeviceInfoClient;
+import com.njcn.device.pms.api.StatationStatClient;
+import com.njcn.device.pms.pojo.dto.PmsGeneralDeviceDTO;
+import com.njcn.device.pms.pojo.dto.PmsStatationStatInfoDTO;
+import com.njcn.device.pms.pojo.param.PmsDeviceInfoParam;
+import com.njcn.device.pms.pojo.param.PmsStatationStatInfoParam;
+import com.njcn.harmonic.mapper.majornetwork.RStatSubstationQMapper;
+import com.njcn.harmonic.mapper.majornetwork.RStatSubstationYMapper;
+import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatSubstationM;
+import com.njcn.harmonic.mapper.majornetwork.RStatSubstationMMapper;
+import com.njcn.harmonic.pojo.vo.RSubstationIcon2VO;
+import com.njcn.harmonic.pojo.vo.RSubstationIconVO;
+import com.njcn.harmonic.service.majornetwork.RStatSubstationMService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-18
+ */
+@Service
+@RequiredArgsConstructor
+public class RStatSubstationMServiceImpl extends ServiceImpl<RStatSubstationMMapper, RStatSubstationM> implements RStatSubstationMService {
+
+    private final RStatSubstationMMapper rStatSubstationMMapper;
+    private final RStatSubstationQMapper rStatSubstationQMapper;
+    private final RStatSubstationYMapper rStatSubstationYMapper;
+    private final StatationStatClient statationStatClient;
+    private final PmsGeneralDeviceInfoClient pmsGeneralDeviceInfoClient;
+
+    @Override
+    public RSubstationIconVO getStatSubstationIcon(StatisticsBizBaseParam param) {
+        RSubstationIconVO rSubstationIconVO = new RSubstationIconVO();
+        StatSubstationBizBaseParam baseParam = BeanUtil.copyProperties(param, StatSubstationBizBaseParam.class);
+        //根据部门获取变电站信息
+//        baseParam.setIds(this.powerrIdList(param.getId()));
+        String string = param.getType().toString();
+        switch (string) {
+            //查询变电站稳态指标超标分布（按超标天数）-年数据
+            case BizParamConstant.STAT_BIZ_YEAR:
+                rSubstationIconVO = rStatSubstationYMapper.getStatSubstationIconY(baseParam);
+                break;
+            //查询变电站稳态指标超标分布（按超标天数）-季数据
+            case BizParamConstant.STAT_BIZ_QUARTER:
+                rSubstationIconVO = rStatSubstationQMapper.getStatSubstationIconQ(baseParam);
+                break;
+            //查询变电站稳态指标超标分布（按超标天数）-月数据
+            case BizParamConstant.STAT_BIZ_MONTH:
+                rSubstationIconVO = rStatSubstationMMapper.getStatSubstationIconM(baseParam);
+                break;
+            default:
+                break;
+        }
+        return rSubstationIconVO;
+    }
+
+    @Override
+    public List<RSubstationIcon2VO> getStatSubstationIcon2(StatisticsBizBaseParam param) {
+        //生成变电站id集合
+        List<RSubstationIcon2VO> rSubstationIconVO = new ArrayList<>();
+        StatSubstationBizBaseParam baseParam = BeanUtil.copyProperties(param, StatSubstationBizBaseParam.class);
+        //根据id进行筛选
+//        baseParam.setIds(this.powerrIdList(param.getId()));
+        String string = param.getType().toString();
+        switch (string) {
+            //查询变电站稳态指标平均超标天数-年数据
+            case BizParamConstant.STAT_BIZ_YEAR:
+                rSubstationIconVO = rStatSubstationYMapper.getStatSubstationIcon2Y(baseParam);
+                break;
+            //查询变电站稳态指标平均超标天数-季数据
+            case BizParamConstant.STAT_BIZ_QUARTER:
+                rSubstationIconVO = rStatSubstationQMapper.getStatSubstationIcon2Q(baseParam);
+                break;
+            //查询变电站稳态指标平均超标天数-月数据
+            case BizParamConstant.STAT_BIZ_MONTH:
+                rSubstationIconVO = rStatSubstationMMapper.getStatSubstationIcon2M(baseParam);
+                break;
+            default:
+                break;
+        }
+
+        //获取变电站名称属性替换
+        if (CollUtil.isNotEmpty(rSubstationIconVO)) {
+            List<String> ids = rSubstationIconVO.stream().map(RSubstationIcon2VO::getSubstationId).collect(Collectors.toList());
+            if (CollUtil.isNotEmpty(ids)) {
+                PmsStatationStatInfoParam pmsParam = new PmsStatationStatInfoParam();
+                pmsParam.setPowerIds(ids);
+                List<PmsStatationStatInfoDTO> data1 = statationStatClient.getStatationStatInfo(pmsParam).getData();
+                if (CollUtil.isNotEmpty(data1)) {
+                    for (PmsStatationStatInfoDTO dto : data1) {
+                        for (RSubstationIcon2VO vo : rSubstationIconVO) {
+                            if (dto.getPowerId().equals(vo.getSubstationId())) {
+                                vo.setSubstationName(dto.getPowerName());
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return rSubstationIconVO;
+    }
+
+    private List<String> powerrIdList(String id) {
+        //获取部门下面监测点信息
+        PmsDeviceInfoParam pms = new PmsDeviceInfoParam();
+        pms.setDeptIndex(id);
+        pms.setStatisticalType(new SimpleDTO());
+        List<PmsGeneralDeviceDTO> data = pmsGeneralDeviceInfoClient.getPmsDeviceInfoWithInOrg(pms).getData();
+        List<String> addids = new ArrayList<>();
+        data.stream().forEach(e -> addids.addAll(e.getPowerrIdList()));
+        return addids;
+    }
+}
--- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatSubstationVoltageMServiceImpl.java
+++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatSubstationVoltageMServiceImpl.java
@@ -0,0 +1,56 @@
+package com.njcn.harmonic.service.majornetwork.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import com.njcn.common.pojo.dto.SimpleDTO;
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.device.pms.api.PmsGeneralDeviceInfoClient;
+import com.njcn.device.pms.pojo.dto.PmsGeneralDeviceDTO;
+import com.njcn.device.pms.pojo.param.PmsDeviceInfoParam;
+import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatSubstationVoltageM;
+import com.njcn.harmonic.mapper.majornetwork.RStatSubstationVoltageMMapper;
+import com.njcn.harmonic.pojo.vo.RVoltageIconVO;
+import com.njcn.harmonic.service.majornetwork.RStatSubstationVoltageMService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.user.api.DeptFeignClient;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * <p>
+ *  服务实现类
+ * </p>
+ *
+ * @author rui.wu
+ * @since 2022-10-18
+ */
+@Service
+@RequiredArgsConstructor
+public class RStatSubstationVoltageMServiceImpl extends ServiceImpl<RStatSubstationVoltageMMapper, RStatSubstationVoltageM> implements RStatSubstationVoltageMService {
+
+    private final DeptFeignClient deptFeignClient;
+    private final RStatSubstationVoltageMMapper rStatSubstationVoltageMMapper;
+    private final PmsGeneralDeviceInfoClient pmsGeneralDeviceInfoClient;
+
+    @Override
+    public List<RVoltageIconVO> getStatSubstationIcon(StatisticsBizBaseParam param) {
+        //获取部门id集合
+        StatSubstationBizBaseParam baseParam= BeanUtil.copyProperties(param,StatSubstationBizBaseParam.class);
+//        baseParam.setIds(this.powerrIdList(param.getId()));
+        return rStatSubstationVoltageMMapper.getStatSubstationIcon(baseParam);
+    }
+    //根据部门获取监测点id信息
+    private List<String> powerrIdList(String id){
+        //获取部门下面监测点信息
+        PmsDeviceInfoParam pms=new PmsDeviceInfoParam();
+        pms.setDeptIndex(id);
+        pms.setStatisticalType(new SimpleDTO());
+        List<PmsGeneralDeviceDTO> data = pmsGeneralDeviceInfoClient.getPmsDeviceInfoWithInOrg(pms).getData();
+        List<String> addids=new ArrayList<>();
+        data.stream().forEach(e-> addids.addAll(e.getPowerrIdList()));
+        return addids;
+    }
+}