代码调整

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/DataExceptionService.java

@@ -0,0 +1,20 @@
+package com.njcn.harmonic.service;
+
+import com.njcn.harmonic.pojo.param.AlgorithmSearchParam;
+
+/**
+ * 数据是否异常
+ *
+ * @author qijian
+ * @version 1.0.0
+ * @createTime 2022/10/26 - 10:09
+ */
+public interface DataExceptionService {
+
+    /**
+     * 监测点数据是否异常
+     * @author qijian
+     * @date 2022/10/26
+     */
+    boolean lineDataException(AlgorithmSearchParam algorithmSearchParam);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/DataIntegrityRateService.java

@@ -0,0 +1,20 @@
+package com.njcn.harmonic.service;
+
+import com.njcn.harmonic.pojo.param.AlgorithmSearchParam;
+
+/**
+ * 数据完整率算法
+ *
+ * @author qijian
+ * @version 1.0.0
+ * @createTime 2022/10/26 - 10:09
+ */
+public interface DataIntegrityRateService {
+
+    /**
+     * 监测点日数据完整率
+     * @author qijian
+     * @date 2022/10/26
+     */
+    boolean lineDataIntegrityRate(AlgorithmSearchParam algorithmSearchParam);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RMpBenchmarkLevelMService.java

@@ -0,0 +1,25 @@
+package com.njcn.harmonic.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.param.RMpBenchmarkLevelParam;
+import com.njcn.harmonic.pojo.po.RMpBenchmarkLevelM;
+import com.njcn.harmonic.pojo.vo.RMpBenchmarkLevelVO;
+
+import java.util.List;
+
+/**
+* @author jianghf
+* @description 针对表【r_mp_benchmark_level_m】的数据库操作Service
+* @createDate 2022-10-11 10:32:18
+*/
+public interface RMpBenchmarkLevelMService extends IService<RMpBenchmarkLevelM> {
+
+    /***
+     * 查询区域稳态电能质量水平(月)
+     * @author jianghaifei
+     * @date 2022-10-11 11:26
+     * @param rMpBenchmarkLevelParam
+     * @return java.util.List<com.njcn.device.pms.pojo.po.RMpBenchmarkLevelM>
+     */
+    List<RMpBenchmarkLevelVO> getRMpBenchmarkLevelList(RMpBenchmarkLevelParam rMpBenchmarkLevelParam);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RMpBenchmarkLevelQService.java

@@ -0,0 +1,18 @@
+package com.njcn.harmonic.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.param.RMpBenchmarkLevelParam;
+import com.njcn.harmonic.pojo.po.RMpBenchmarkLevelQ;
+import com.njcn.harmonic.pojo.vo.RMpBenchmarkLevelVO;
+
+import java.util.List;
+
+/**
+* @author jianghf
+* @description 针对表【r_mp_benchmark_level_q】的数据库操作Service
+* @createDate 2022-10-11 10:32:18
+*/
+public interface RMpBenchmarkLevelQService extends IService<RMpBenchmarkLevelQ> {
+
+    List<RMpBenchmarkLevelVO> getRMpBenchmarkLevelList(RMpBenchmarkLevelParam rMpBenchmarkLevelParam);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RMpBenchmarkLevelYService.java

@@ -0,0 +1,18 @@
+package com.njcn.harmonic.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.param.RMpBenchmarkLevelParam;
+import com.njcn.harmonic.pojo.po.RMpBenchmarkLevelY;
+import com.njcn.harmonic.pojo.vo.RMpBenchmarkLevelVO;
+
+import java.util.List;
+
+/**
+* @author jianghf
+* @description 针对表【r_mp_benchmark_level_y】的数据库操作Service
+* @createDate 2022-10-11 10:32:18
+*/
+public interface RMpBenchmarkLevelYService extends IService<RMpBenchmarkLevelY> {
+
+    List<RMpBenchmarkLevelVO> getRMpBenchmarkLevelList(RMpBenchmarkLevelParam rMpBenchmarkLevelParam);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RMpHarmonicIMagReportDService.java

@@ -0,0 +1,17 @@
+package com.njcn.harmonic.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.po.RMpHarmonicIMagReportD;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+* @author Administrator
+* @description 针对表【r_mp_harmonic_i_mag_report_d(稳态监测点指标日报-日表(主配网表)  /各次谐波电流有效值)】的数据库操作Service
+* @createDate 2022-10-20 18:38:15
+*/
+public interface RMpHarmonicIMagReportDService extends IService<RMpHarmonicIMagReportD> {
+
+    List<RMpHarmonicIMagReportD> getListByCond(Map<String, Object> condMap);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RMpHarmonicIRateReportDService.java

@@ -0,0 +1,18 @@
+package com.njcn.harmonic.service;
+
+import com.njcn.harmonic.pojo.po.RMpHarmonicIRateReportD;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+* @author Administrator
+* @description 针对表【r_mp_harmonic_i_rate_report_d(稳态监测点指标日报-日表(主网表)  /各次谐波电流含有率)】的数据库操作Service
+* @createDate 2022-10-20 18:43:52
+*/
+public interface RMpHarmonicIRateReportDService extends IService<RMpHarmonicIRateReportD> {
+
+    List<RMpHarmonicIRateReportD> getListByCond(Map<String, Object> condMap);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RMpHarmonicReportDService.java

@@ -0,0 +1,18 @@
+package com.njcn.harmonic.service;
+
+import com.njcn.harmonic.pojo.param.RMpHarmonicReportDParam;
+import com.njcn.harmonic.pojo.vo.RMpHarmonicReportDVO;
+
+import java.util.List;
+
+/**
+ * @Title RMpHarmonicReportDService
+ * @Package com.njcn.harmonic.service
+ * @Author jianghaifei
+ * @Date 2022-10-20 19:18
+ * @Version V1.0
+ */
+public interface RMpHarmonicReportDService {
+
+    List<RMpHarmonicReportDVO> getMonitorStatisticsD(RMpHarmonicReportDParam rMpHarmonicReportDParam);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RMpHarmonicVRateReportDService.java

@@ -0,0 +1,17 @@
+package com.njcn.harmonic.service;
+
+import com.njcn.harmonic.pojo.po.RMpHarmonicVRateReportD;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+* @author jianghf
+* @description 针对表【r_mp_harmonic_v_rate_report_d(稳态监测点指标日报-日表(主配网表)  /各次谐波电压含有率 )】的数据库操作Service
+* @createDate 2022-10-20 18:34:05
+*/
+public interface RMpHarmonicVRateReportDService extends IService<RMpHarmonicVRateReportD> {
+
+    List<RMpHarmonicVRateReportD> getListByCond(Map<String, Object> map);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RMpInharmonicIRateReportDService.java

@@ -0,0 +1,18 @@
+package com.njcn.harmonic.service;
+
+import com.njcn.harmonic.pojo.po.RMpInharmonicIRateReportD;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+* @author Administrator
+* @description 针对表【r_mp_inharmonic_i_rate_report_d(稳态监测点指标日报-日表(主网表)  /各次间谐波电流含有率)】的数据库操作Service
+* @createDate 2022-10-20 18:45:58
+*/
+public interface RMpInharmonicIRateReportDService extends IService<RMpInharmonicIRateReportD> {
+
+    List<RMpInharmonicIRateReportD> getListByCond(Map<String, Object> condMap);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RMpInharmonicVRateReportDService.java

@@ -0,0 +1,18 @@
+package com.njcn.harmonic.service;
+
+import com.njcn.harmonic.pojo.po.RMpInharmonicVRateReportD;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+* @author Administrator
+* @description 针对表【r_mp_inharmonic_v_rate_report_d】的数据库操作Service
+* @createDate 2022-10-20 18:45:36
+*/
+public interface RMpInharmonicVRateReportDService extends IService<RMpInharmonicVRateReportD> {
+
+    List<RMpInharmonicVRateReportD> getListByCond(Map<String, Object> condMap);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RMpMeasurePhaseReportDService.java

@@ -0,0 +1,17 @@
+package com.njcn.harmonic.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.po.RMpMeasurePhaseReportD;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+* @author Administrator
+* @description 针对表【r_mp_measure_phase_report_d】的数据库操作Service
+* @createDate 2022-10-20 18:20:08
+*/
+public interface RMpMeasurePhaseReportDService extends IService<RMpMeasurePhaseReportD> {
+
+    List<RMpMeasurePhaseReportD> getListByCond(Map<String, Object> condMap);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RMpMeasureReportDService.java

@@ -0,0 +1,17 @@
+package com.njcn.harmonic.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.harmonic.pojo.po.RMpMeasureReportD;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+* @author jianghf
+* @description 针对表【r_mp_measure_report_d】的数据库操作Service
+* @createDate 2022-10-20 16:32:37
+*/
+public interface RMpMeasureReportDService extends IService<RMpMeasureReportD> {
+
+    List<RMpMeasureReportD> getListByCond(Map<String, Object> condMap);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RMpPartHarmonicDetailDService.java

@@ -0,0 +1,26 @@
+package com.njcn.harmonic.service;
+
+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);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RMpPartHarmonicDetailMService.java

@@ -0,0 +1,28 @@
+package com.njcn.harmonic.service;
+
+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);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RMpPassRateService.java

@@ -0,0 +1,28 @@
+package com.njcn.harmonic.service;
+
+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);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RStatHarmonicMService.java

@@ -0,0 +1,42 @@
+package com.njcn.harmonic.service;
+
+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);
+
+    /**
+     * 稳态电铁-频率偏差-电压统计图
+     * @return
+     */
+    List<RIconVO> getRStatHarmonicIcon(RStatHarmonicMParam param);
+
+    /**
+     * 稳态电铁-频率偏差-越线日期统计图
+     * @return
+     */
+    List<RHarmonicPolylineVO> getRStatHarmonicIcon2(RStatHarmonicMParam param);
+
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RStatHarmonicOrgMService.java

@@ -0,0 +1,35 @@
+package com.njcn.harmonic.service;
+
+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);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RStatHarmonicOrgQService.java

@@ -0,0 +1,35 @@
+package com.njcn.harmonic.service;
+
+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);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RStatHarmonicOrgYService.java

@@ -0,0 +1,35 @@
+package com.njcn.harmonic.service;
+
+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);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RStatHarmonicQService.java

@@ -0,0 +1,27 @@
+package com.njcn.harmonic.service;
+
+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);
+
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RStatHarmonicYService.java

@@ -0,0 +1,26 @@
+package com.njcn.harmonic.service;
+
+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);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RStatLoadTypeService.java

@@ -0,0 +1,26 @@
+package com.njcn.harmonic.service;
+
+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);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RStatOrgBusbarVoltageService.java

@@ -0,0 +1,26 @@
+package com.njcn.harmonic.service;
+
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+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(StatisticsBizBaseParam param);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RStatOrgMService.java

@@ -0,0 +1,26 @@
+package com.njcn.harmonic.service;
+
+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);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RStatOrgQService.java

@@ -0,0 +1,26 @@
+package com.njcn.harmonic.service;
+
+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);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RStatOrgYService.java

@@ -0,0 +1,50 @@
+package com.njcn.harmonic.service;
+
+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);
+
+
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RStatSubstationMService.java

@@ -0,0 +1,34 @@
+package com.njcn.harmonic.service;
+
+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);
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/RStatSubstationVoltageMService.java

@@ -0,0 +1,28 @@
+package com.njcn.harmonic.service;
+
+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);
+
+
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/CustomReportServiceImpl.java

@@ -314,18 +314,17 @@ public class CustomReportServiceImpl implements CustomReportService {
 
     @Override
     public List<ReportTreeVO> reportChooseTree() {
-        long a = System.currentTimeMillis();
         LambdaQueryWrapper<EleEpdPqd> lambdaQueryWrapper = new LambdaQueryWrapper<>();
         lambdaQueryWrapper.isNotNull(EleEpdPqd::getOtherName);
         lambdaQueryWrapper.orderByAsc(EleEpdPqd::getSort);
         List<EleEpdPqd> list = eleEpdMapper.selectList(lambdaQueryWrapper);
-        Map<String, List<EleEpdPqd>> map = list.stream().collect(Collectors.groupingBy(EleEpdPqd::getOtherName));
+        Map<String, List<EleEpdPqd>> map = list.stream().collect(Collectors.groupingBy(EleEpdPqd::getName));
 
         List<ReportTreeVO> tree = new ArrayList<>();
         map.forEach((key, value) -> {
 
             ReportTreeVO reportTreeVO = new ReportTreeVO();
-            reportTreeVO.setName(key);
+            reportTreeVO.setName(value.get(0).getOtherName());
             reportTreeVO.setShowName(value.get(0).getShowName());
 
             //存在1-50次 2-50次情况
@@ -341,13 +340,10 @@ public class CustomReportServiceImpl implements CustomReportService {
                 }
                 reportTreeVO.setChildren(reHarm);
             } else {
-                assPhase(value, reportTreeVO, key);
+                assPhase(value, reportTreeVO, value.get(0).getOtherName());
             }
             tree.add(reportTreeVO);
         });
-
-        long b = System.currentTimeMillis();
-        System.out.println(b - a);
         return tree;
     }
 
@@ -364,6 +360,7 @@ public class CustomReportServiceImpl implements CustomReportService {
                 assStatMethod(item, statTree, key, item.getPhase());
                 reportTreePhase.setChildren(statTree);
                 phaseTree.add(reportTreePhase);
+                reportTreeItem.setChildren(phaseTree);
 
             } else {
                 List<ReportTreeVO> statTree = new ArrayList<>();
@@ -371,7 +368,6 @@ public class CustomReportServiceImpl implements CustomReportService {
                 reportTreeItem.setChildren(statTree);
             }
         });
-        reportTreeItem.setChildren(phaseTree);
 
     }
 
@@ -430,7 +426,6 @@ public class CustomReportServiceImpl implements CustomReportService {
      * @return 结果
      */
     private void assSql(ReportTemplateDTO data, StringBuilder sql, List<ReportTemplateDTO> endList, String method, ReportSearchParam reportSearchParam) {
-        InfluxDbUtils influxDBUtil = new InfluxDbUtils(influxDbConfig.getUserName(), influxDbConfig.getPassword(), influxDbConfig.getInfluxDBUrl(), influxDbConfig.getDatabase(), "");
         //sql拼接示例：select MAX(IHA2) as IHA2 from power_quality_data where Phase = 'A' and LineId='1324564568' and Stat_Method='max' tz('Asia/Shanghai')
         if (InfluxDBTableConstant.NO_PHASE.equals(data.getPhase())) {
             sql.append(method).append(InfluxDBSqlConstant.LBK).append(data.getTemplateName()).append(InfluxDBSqlConstant.RBK).append(InfluxDBSqlConstant.AS_VALUE)
@@ -448,7 +443,7 @@ public class CustomReportServiceImpl implements CustomReportService {
         }
 
         //根据不同的库表赋值
-        QueryResult queryResult = influxDBUtil.query(String.valueOf(sql));
+        QueryResult queryResult = influxDbUtils.query(String.valueOf(sql));
 
         //剖析influx数据，填入value
         List<QueryResult.Result> results = queryResult.getResults();

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/DataExceptionServiceImpl.java

@@ -0,0 +1,182 @@
+package com.njcn.harmonic.service.impl;
+
+import cn.hutool.core.date.DateUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.njcn.common.pojo.exception.BusinessException;
+import com.njcn.device.pq.api.LineFeignClient;
+import com.njcn.device.pq.pojo.vo.LineDetailDataVO;
+import com.njcn.harmonic.constant.Param;
+import com.njcn.harmonic.enums.HarmonicResponseEnum;
+import com.njcn.harmonic.mapper.PmsAbnormalRulesMapper;
+import com.njcn.harmonic.mapper.RStatAbnormalDMapper;
+import com.njcn.harmonic.pojo.param.AlgorithmSearchParam;
+import com.njcn.harmonic.pojo.po.DataV;
+import com.njcn.harmonic.pojo.po.PmsAbnormalRules;
+import com.njcn.harmonic.pojo.po.RStatAbnormalD;
+import com.njcn.harmonic.service.DataExceptionService;
+import com.njcn.influxdb.config.InfluxDbConfig;
+import com.njcn.influxdb.param.InfluxDBPublicParam;
+import com.njcn.influxdb.param.InfluxDBSqlConstant;
+import com.njcn.influxdb.param.InfluxDBTableConstant;
+import com.njcn.influxdb.utils.InfluxDbUtils;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.influxdb.dto.QueryResult;
+import org.influxdb.impl.InfluxDBResultMapper;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * 数据是否异常
+ *
+ * @author qijian
+ * @version 1.0.0
+ * @createTime 2022/10/26 - 10:09
+ */
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class DataExceptionServiceImpl implements DataExceptionService {
+
+    private final InfluxDbUtils influxDbUtils;
+
+    private final LineFeignClient lineFeignClient;
+
+    private final PmsAbnormalRulesMapper pmsAbnormalRulesMapper;
+
+    private final RStatAbnormalDMapper rStatAbnormalDMapper;
+
+    @Resource
+    private InfluxDbConfig influxDbConfig;
+
+    /**
+     * 监测点数据是否异常
+     * @author qijian
+     * @date 2022/10/26
+     */
+    @Override
+    public boolean lineDataException(AlgorithmSearchParam algorithmSearchParam) {
+        //测试
+//        InfluxDbUtils influxDBUtil = new InfluxDbUtils("admin", "njcnpqs", "http://192.168.1.18:8086", "pqsbase", "");
+        //初始化
+        InfluxDBResultMapper resultMapper = new InfluxDBResultMapper();
+        String searchSql;
+        String sql;
+        QueryResult query;
+        DataV dataV;
+        Date date = DateUtil.parse(algorithmSearchParam.getDatadate());
+        String lineId = algorithmSearchParam.getId();
+
+        //入库数据初始化
+        RStatAbnormalD rStatAbnormalD = new RStatAbnormalD();
+        rStatAbnormalD.setDataDate(date);
+        rStatAbnormalD.setMeasurementPointId(lineId);
+        rStatAbnormalD.setValueAlarm(0);
+
+        //1、取出规则
+        List<PmsAbnormalRules> pmsAbnormalRules = pmsAbnormalRulesMapper.selectList(null);
+
+        //2、取出电压
+        List<String> lineIds = new ArrayList<>();
+        lineIds.add(lineId);
+        List<LineDetailDataVO> lineDetailList = lineFeignClient.getLineDetailList(lineIds).getData();
+        if (lineDetailList.size() == 0){
+            throw new BusinessException(HarmonicResponseEnum.ALGORITHM_LINE_EMPTY);
+        }
+        String scale = lineDetailList.get(0).getScale().replace("kV","");
+
+        //3、根据规则表进行判断
+        //取前四项进行比较（相别为A）
+        searchSql = "MAX(freq) as freq_max,MIN(freq) as freq_min,MAX(rms) as rms_max,MIN(rms) as rms_min,MAX(rms_lvr) as rms_lvr_max,MIN(rms_lvr) as rms_lvr_min,MAX(v_thd) as v_thd_max,MIN(v_thd) as v_thd_min ";
+        sql = getAppend(lineId, date, searchSql, "A");
+        query = influxDbUtils.query(sql);
+        dataV = resultMapper.toPOJO(query, DataV.class).get(0);
+
+        //开始判断业务
+        HarmonicResponseEnum harmonicResponseEnum = null;
+        for (PmsAbnormalRules pmsAbnormalRule : pmsAbnormalRules) {
+            //每项数据进行上下限比较（MAX和MIN），若有一项不在数据范围内，则为异常
+            switch (pmsAbnormalRule.getTarget()) {
+                case Param.TARGET_FREQ:
+                    //频率：正常比较
+                    if (dataV.getFrepMIN() < pmsAbnormalRule.getLowerLimit() || dataV.getFrepMAX() > pmsAbnormalRule.getUpperLimit()){
+                        harmonicResponseEnum = HarmonicResponseEnum.ALGORITHM_FREP_RULE;
+                    }
+                    break;
+                case Param.TARGET_RMS:
+                    //相电压有效值特殊处理：在【0.85p.u.，1.2p.u.】之间；p.u=电压等级/1.732
+                    pmsAbnormalRule.setLowerLimit((pmsAbnormalRule.getLowerLimit() * (Double.parseDouble(scale) / 1.732)));
+                    pmsAbnormalRule.setUpperLimit((pmsAbnormalRule.getUpperLimit() * (Double.parseDouble(scale) / 1.732)));
+                    if (dataV.getRmsMIN() < pmsAbnormalRule.getLowerLimit() || dataV.getRmsMAX() > pmsAbnormalRule.getUpperLimit()){
+                        harmonicResponseEnum = HarmonicResponseEnum.ALGORITHM_RMS_RULE;
+                    }
+                    break;
+                case Param.TARGET_RMS_LVR:
+                    //线电压有效值特殊处理：在【0.85p.u.，1.2p.u.】之间；p.u=电压等级
+                    pmsAbnormalRule.setLowerLimit((pmsAbnormalRule.getLowerLimit() * Double.parseDouble(scale)));
+                    pmsAbnormalRule.setUpperLimit((pmsAbnormalRule.getUpperLimit() * Double.parseDouble(scale)));
+                    if (dataV.getRmsLvrMIN() < pmsAbnormalRule.getLowerLimit() || dataV.getRmsLvrMAX() > pmsAbnormalRule.getUpperLimit()){
+                        harmonicResponseEnum = HarmonicResponseEnum.ALGORITHM_RMS_LVR_RULE;
+                    }
+                    break;
+                case Param.TARGET_V_THD:
+                    //电压总谐波畸变率：正常比较
+                    if (dataV.getVThdMIN() < pmsAbnormalRule.getLowerLimit() || dataV.getVThdMAX() > pmsAbnormalRule.getUpperLimit()){
+                        harmonicResponseEnum = HarmonicResponseEnum.ALGORITHM_V_THD_RULE;
+                    }
+                    break;
+                case Param.TARGET_V_UNBALANCE:
+                    //三相不平衡度：正常比较（相别为T）
+                    searchSql = "MAX(v_unbalance) as v_unbalance_max,MIN(v_unbalance) as v_unbalance_min ";
+                    sql = getAppend(lineId, date, searchSql, "T");
+                    query = influxDbUtils.query(sql);
+                    dataV = resultMapper.toPOJO(query, DataV.class).get(0);
+                    if (dataV.getVUnbalanceMIN() < pmsAbnormalRule.getLowerLimit() || dataV.getVUnbalanceMAX() > pmsAbnormalRule.getUpperLimit()){
+                        harmonicResponseEnum = HarmonicResponseEnum.ALGORITHM_V_UNBALANCE_RULE;
+                    }
+                    break;
+                default:
+                    break;
+            }
+
+            if (harmonicResponseEnum != null){
+                //入库
+                LambdaQueryWrapper<RStatAbnormalD> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+                lambdaQueryWrapper.eq(RStatAbnormalD::getMeasurementPointId, lineId).eq(RStatAbnormalD::getDataDate, date);
+                RStatAbnormalD rStatAbnormalDOne = rStatAbnormalDMapper.selectOne(lambdaQueryWrapper);
+                if (Objects.isNull(rStatAbnormalDOne)){
+                    rStatAbnormalDMapper.insert(rStatAbnormalD);
+                }
+                throw new BusinessException(harmonicResponseEnum);
+            }
+
+        }
+        return true;
+    }
+
+    /**
+     * 拼装sql
+     * @param id,date,searchSql,tableName 参数
+     * @return 结果
+     */
+    private String getAppend(String id, Date date, String searchSql,String type) {
+        StringBuilder stringBuilder = new StringBuilder();
+        stringBuilder.append(InfluxDBSqlConstant.SELECT).append(searchSql)
+                .append(InfluxDBSqlConstant.FROM).append(InfluxDBPublicParam.DATA_V)
+                .append(InfluxDBSqlConstant.WHERE).append(InfluxDBPublicParam.TIME).append(InfluxDBSqlConstant.GE).append(InfluxDBSqlConstant.QM).append(DateUtil.beginOfDay(date)).append(InfluxDBSqlConstant.QM)
+                .append(InfluxDBSqlConstant.AND).append(InfluxDBPublicParam.TIME).append(InfluxDBSqlConstant.LE).append(InfluxDBSqlConstant.QM).append(DateUtil.endOfDay(date)).append(InfluxDBSqlConstant.QM)
+                .append(InfluxDBSqlConstant.AND).append(InfluxDBPublicParam.LINE_ID).append(InfluxDBSqlConstant.EQ).append(InfluxDBSqlConstant.QM).append(id).append(InfluxDBSqlConstant.QM)
+                .append(InfluxDBSqlConstant.AND).append(InfluxDBPublicParam.VALUE_TYPE).append(InfluxDBSqlConstant.EQ).append(InfluxDBSqlConstant.QM).append(InfluxDBTableConstant.AVG).append(InfluxDBSqlConstant.QM);
+        if (InfluxDBTableConstant.PHASE_TYPE_T.equals(type)){
+            stringBuilder.append(InfluxDBSqlConstant.AND).append(InfluxDBPublicParam.PHASIC_TYPE).append(InfluxDBSqlConstant.EQ).append(InfluxDBSqlConstant.QM).append(InfluxDBTableConstant.PHASE_TYPE_T).append(InfluxDBSqlConstant.QM);
+        }else{
+            stringBuilder.append(InfluxDBSqlConstant.AND).append(InfluxDBPublicParam.PHASIC_TYPE).append(InfluxDBSqlConstant.EQ).append(InfluxDBSqlConstant.QM).append(InfluxDBTableConstant.PHASE_TYPE_A).append(InfluxDBSqlConstant.QM);
+        }
+        return stringBuilder.toString();
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/DataIntegrityRateServiceImpl.java

@@ -0,0 +1,192 @@
+package com.njcn.harmonic.service.impl;
+
+import cn.hutool.core.date.DateUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.njcn.common.pojo.exception.BusinessException;
+import com.njcn.device.pq.api.LineFeignClient;
+import com.njcn.device.pq.pojo.vo.LineDetailDataVO;
+import com.njcn.harmonic.enums.HarmonicResponseEnum;
+import com.njcn.harmonic.mapper.RMpIntegrityDMapper;
+import com.njcn.harmonic.pojo.param.AlgorithmSearchParam;
+import com.njcn.harmonic.pojo.po.RMpIntegrityD;
+import com.njcn.harmonic.service.DataIntegrityRateService;
+import com.njcn.influxdb.config.InfluxDbConfig;
+import com.njcn.influxdb.param.InfluxDBPublicParam;
+import com.njcn.influxdb.param.InfluxDBSqlConstant;
+import com.njcn.influxdb.param.InfluxDBTableConstant;
+import com.njcn.influxdb.utils.InfluxDbUtils;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.influxdb.dto.QueryResult;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * 数据完整率算法
+ *
+ * @author qijian
+ * @version 1.0.0
+ * @createTime 2022/10/26 - 10:09
+ */
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class DataIntegrityRateServiceImpl implements DataIntegrityRateService {
+
+    private final InfluxDbUtils influxDbUtils;
+
+    private final RMpIntegrityDMapper rMpIntegrityDMapper;
+
+    private final LineFeignClient lineFeignClient;
+
+    @Resource
+    private InfluxDbConfig influxDbConfig;
+
+    /**
+     * 监测点日数据完整率
+     * @author qijian
+     * @date 2022/10/26
+     */
+    @Override
+    public boolean lineDataIntegrityRate(AlgorithmSearchParam algorithmSearchParam) {
+        //测试
+//        InfluxDbUtils influxDBUtil = new InfluxDbUtils("admin", "njcnpqs", "http://192.168.1.18:8086", "pqsbase", "");
+        //初始化
+        String searchSql;
+        String tableName;
+        String sql;
+        QueryResult query;
+        QueryResult.Series series;
+        List<String> columns;
+        List<List<Object>> values;
+        RMpIntegrityD rMpIntegrityD = new RMpIntegrityD();
+        Date date = DateUtil.parse(algorithmSearchParam.getDatadate());
+
+        //1、有效接入分钟数量：根据监测点编号获取统计间隔，1440 / 统计间隔 = 有效接入分钟数量
+        List<String> lineIds = new ArrayList<>();
+        lineIds.add(algorithmSearchParam.getId());
+        List<LineDetailDataVO> lineDetailList = lineFeignClient.getLineDetailList(lineIds).getData();
+        if (lineDetailList.size() == 0){
+            throw new BusinessException(HarmonicResponseEnum.ALGORITHM_LINE_EMPTY);
+        }
+        Integer effectiveMinuteCount = 1440 / lineDetailList.get(0).getTimeInterval();
+        rMpIntegrityD.setEffectiveMinuteCount(effectiveMinuteCount);
+
+        //2、根据data_v表获取五项稳态指标日数量（count）
+        searchSql = "count(freq) as freqCount,count(rms) as phaseVoltageCount,count(rms_lvr) as lineVoltageCount,count(v_thd) as vThdCount,count(v_unbalance) as unbalanceCount ";
+        tableName = InfluxDBPublicParam.DATA_V;
+        sql = getAppend(algorithmSearchParam.getId(), date, searchSql, tableName);
+        query = influxDbUtils.query(sql);
+        series = getSeries(query);
+
+        if (Objects.nonNull(series.getColumns())){
+            columns = series.getColumns();
+            values = series.getValues();
+            for (List<Object> columnValue : values) {
+                for (int i = 0; i < columnValue.size(); i++) {
+                    if (columns.get(i).equals("freqCount")) {
+                        rMpIntegrityD.setFreqCount(Integer.parseInt(convertDoubleToString(columnValue.get(i))));
+                    }else if (columns.get(i).equals("phaseVoltageCount")) {
+                        rMpIntegrityD.setPhaseVoltageCount(Integer.parseInt(convertDoubleToString(columnValue.get(i))));
+                    }else if (columns.get(i).equals("lineVoltageCount")) {
+                        rMpIntegrityD.setLineVoltageCount(Integer.parseInt(convertDoubleToString(columnValue.get(i))));
+                    }else if (columns.get(i).equals("vThdCount")) {
+                        rMpIntegrityD.setVThdCount(Integer.parseInt(convertDoubleToString(columnValue.get(i))));
+                    }else if (columns.get(i).equals("unbalanceCount")) {
+                        rMpIntegrityD.setUnbalanceCount(Integer.parseInt(convertDoubleToString(columnValue.get(i))));
+                    }
+                }
+            }
+        }
+
+        //3、根据day_flicker表获取两项闪变指标数量（count）
+        searchSql = "count(pst) as pstCount,count(plt) as pltCount ";
+        tableName = InfluxDBPublicParam.DATA_FLICKER;
+        sql = getAppend(algorithmSearchParam.getId(), date, searchSql, tableName);
+        query = influxDbUtils.query(sql);
+        series = getSeries(query);
+
+        if (Objects.nonNull(series.getColumns())){
+            columns = series.getColumns();
+            values = series.getValues();
+            for (List<Object> columnValue : values) {
+                for (int i = 0; i < columnValue.size(); i++) {
+                    if (columns.get(i).equals("pstCount")) {
+                        rMpIntegrityD.setPstCount(Integer.parseInt(convertDoubleToString(columnValue.get(i))));
+                    }else if (columns.get(i).equals("pltCount")) {
+                        rMpIntegrityD.setPltCount(Integer.parseInt(convertDoubleToString(columnValue.get(i))));
+                    }
+                }
+            }
+        }
+
+        //4、存库
+        LambdaQueryWrapper<RMpIntegrityD> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.eq(RMpIntegrityD::getMeasurementPointId, algorithmSearchParam.getId()).eq(RMpIntegrityD::getDataDate, date);
+        RMpIntegrityD rMpIntegrityDOne = rMpIntegrityDMapper.selectOne(lambdaQueryWrapper);
+        if (Objects.nonNull(rMpIntegrityDOne)){
+            rMpIntegrityDMapper.update(rMpIntegrityD,lambdaQueryWrapper);
+        }else{
+            rMpIntegrityD.setMeasurementPointId(algorithmSearchParam.getId());
+            rMpIntegrityD.setDataDate(date);
+            rMpIntegrityDMapper.insert(rMpIntegrityD);
+        }
+
+        return true;
+    }
+
+    /**
+     * Double转String
+     * @param val 参数
+     * @return 结果
+     */
+    private String convertDoubleToString(Object val) {
+        DecimalFormat decimalFormat = new DecimalFormat("###################.###########");
+        return decimalFormat.format(val);
+    }
+
+    /**
+     * 取series
+     * @param query 参数
+     * @return 结果
+     */
+    private QueryResult.Series getSeries(QueryResult query) {
+        QueryResult.Series series = new QueryResult.Series();
+        List<QueryResult.Result> results = query.getResults();
+        if (results.size() != 0) {
+            QueryResult.Result result = results.get(0);
+            if (result.getSeries() != null){
+                List<QueryResult.Series> seriess = result.getSeries();
+                if (seriess.size() != 0) {
+                    series = seriess.get(0);
+                }
+            }
+        }
+        return series;
+    }
+
+    /**
+     * 拼装sql
+     * @param id,date,searchSql,tableName 参数
+     * @return 结果
+     */
+    private String getAppend(String id, Date date, String searchSql,String tableName) {
+        StringBuilder stringBuilder = new StringBuilder();
+        stringBuilder.append(InfluxDBSqlConstant.SELECT).append(searchSql)
+                .append(InfluxDBSqlConstant.FROM).append(tableName)
+                .append(InfluxDBSqlConstant.WHERE).append(InfluxDBPublicParam.TIME).append(InfluxDBSqlConstant.GE).append(InfluxDBSqlConstant.QM).append(DateUtil.beginOfDay(date)).append(InfluxDBSqlConstant.QM)
+                .append(InfluxDBSqlConstant.AND).append(InfluxDBPublicParam.TIME).append(InfluxDBSqlConstant.LE).append(InfluxDBSqlConstant.QM).append(DateUtil.endOfDay(date)).append(InfluxDBSqlConstant.QM)
+                .append(InfluxDBSqlConstant.AND).append(InfluxDBPublicParam.LINE_ID).append(InfluxDBSqlConstant.EQ).append(InfluxDBSqlConstant.QM).append(id).append(InfluxDBSqlConstant.QM)
+                .append(InfluxDBSqlConstant.AND).append(InfluxDBPublicParam.PHASIC_TYPE).append(InfluxDBSqlConstant.EQ).append(InfluxDBSqlConstant.QM).append(InfluxDBTableConstant.PHASE_TYPE_A).append(InfluxDBSqlConstant.QM);
+        if (InfluxDBPublicParam.DATA_V.equals(tableName)){
+            stringBuilder.append(InfluxDBSqlConstant.AND).append(InfluxDBPublicParam.VALUE_TYPE).append(InfluxDBSqlConstant.EQ).append(InfluxDBSqlConstant.QM).append(InfluxDBTableConstant.AVG).append(InfluxDBSqlConstant.QM);
+        }
+        return stringBuilder.toString();
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/HistoryResultServiceImpl.java

@@ -78,7 +78,7 @@ public class HistoryResultServiceImpl implements HistoryResultService {
             List<EventDetailVO> eventDetailVOList = new ArrayList<>();
             if (!eventDetailList.isEmpty()) {
                 for (EventDetail eventdetail : eventDetailList) {
-                    Instant now = eventdetail.getTimeId();
+                    Instant now = eventdetail.getTimeId().plusMillis(TimeUnit.HOURS.toMillis(8));
                     Long time = now.toEpochMilli();
                     String timeText = format.format(time);
                     EventDetailVO eventDetailVO = new EventDetailVO();

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/PollutionSubstationServiceImpl.java

@@ -3,6 +3,8 @@ package com.njcn.harmonic.service.impl;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.njcn.common.config.GeneralInfo;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.exception.BusinessException;
 import com.njcn.device.pq.api.GeneralDeviceInfoClient;
 import com.njcn.device.pq.api.LineFeignClient;
 import com.njcn.device.pq.api.SubstationFeignClient;
@@ -19,11 +21,13 @@ import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
 
 import java.util.*;
 import java.util.stream.Collectors;
 
 /**
+ * 
  * Description:
  * 接口文档访问地址：http://serverIP:port/swagger-ui.html
  * Date: 2022/10/13  8:56【需求编号】
@@ -59,58 +63,62 @@ public class PollutionSubstationServiceImpl extends ServiceImpl<RStatPollutionSu
     @Override
     public List<PollutionSubstationVO> getPollutionSubstationData(PollutionSubstationQuryParam pollutionSubstationQuryParam) {
 
-        List<PollutionSubstationVO> pollutionSubstationVOList = new ArrayList<>();
+        List<PollutionSubstationVO> pollutionSubstationVOList = new ArrayList<> ();
         /*根据部门获取变电站详情*/
         HarmonicPublicParam harmonicPublicParam = new HarmonicPublicParam();
-        BeanUtils.copyProperties(pollutionSubstationQuryParam, harmonicPublicParam);
+        BeanUtils.copyProperties (pollutionSubstationQuryParam, harmonicPublicParam);
         harmonicPublicParam.setServerName(generalInfo.getMicroServiceName());
         List<PollutionSubstationDTO> pollutionSubstationDTOList = new ArrayList<>();
         List<GeneralDeviceDTO> sub = generalDeviceInfoClient.getPracticalRunDeviceInfoAsSubstation(harmonicPublicParam).getData();
-
-        sub.forEach(item -> {
+        
+        sub.forEach(item->{
             PollutionSubstationDTO pollutionSubstationDTO = lineFeignClient.getSubstationInfo(item.getIndex()).getData();
 
             pollutionSubstationDTOList.add(pollutionSubstationDTO);
         });
-        List<String> collect = pollutionSubstationDTOList.stream().map(PollutionSubstationDTO::getId).collect(Collectors.toList());
-        List<SubstationDTO> locationData = substationFeignClient.getSubstationById(collect).getData();
+        List<String> collect = pollutionSubstationDTOList.stream ( ).map (PollutionSubstationDTO::getId).collect (Collectors.toList ( ));
+        List<SubstationDTO> locationData = substationFeignClient.getSubstationById (collect).getData ( );
         /*todo 后期可以把locationData存入redis*/
         /*把所有的变电站的污染指数查出来*/
-        QueryWrapper<RStatPollutionSubstationM> wrapper = new QueryWrapper<>();
-        wrapper.in("substation_id", collect).
-                eq("pollution_type", pollutionSubstationQuryParam.getPollutionStatis().getId()).
-                apply("DATE_FORMAT( data_date ,'%Y-%m') = '" + pollutionSubstationQuryParam.getLocalDate() + "'");
-        List<RStatPollutionSubstationM> rStatPollutionSubstationMList = pollutionSubstationMMapper.selectList(wrapper);
+        QueryWrapper<RStatPollutionSubstationM> wrapper = new QueryWrapper<> ();
+        wrapper.in ("substation_id",collect).
+                eq ("pollution_type", pollutionSubstationQuryParam.getPollutionStatis ().getId ()).
+                apply("DATE_FORMAT( data_date ,'%Y-%m') = '"+pollutionSubstationQuryParam.getLocalDate ()+"'");
+        List<RStatPollutionSubstationM> rStatPollutionSubstationMList = pollutionSubstationMMapper.selectList (wrapper);
 
-        pollutionSubstationDTOList.forEach(substationInfo -> {
+        pollutionSubstationDTOList.forEach (substationInfo ->{
 
-            PollutionSubstationVO pollutionSubstationVO = new PollutionSubstationVO();
-            pollutionSubstationVO.setSubstationId(substationInfo.getId());
-            pollutionSubstationVO.setSubstationName(substationInfo.getName());
+            PollutionSubstationVO pollutionSubstationVO =new PollutionSubstationVO ();
+            pollutionSubstationVO.setSubstationId (substationInfo.getId ());
+            pollutionSubstationVO.setSubstationName (substationInfo.getName ());
             /*todo 添加经纬度接口返回数据暂时没有*/
-            SubstationDTO substationDTO = locationData
-                    .stream()
-                    .filter(temp -> Objects.equals(substationInfo.getId(), temp.getId()))
-                    .collect(Collectors.toList())
-                    .get(0);
+            List<SubstationDTO> substationDTOList = locationData.stream ( )
+                    .filter (temp -> Objects.equals (substationInfo.getId ( ), temp.getId ( )))
+                    .collect (Collectors.toList ( ));
 
-            pollutionSubstationVO.setLatitude(substationDTO.getLat());
-            pollutionSubstationVO.setLongitude(substationDTO.getLng());
+            SubstationDTO substationDTO = new SubstationDTO ();
+            if(CollectionUtils.isEmpty (substationDTOList)){
+                throw new BusinessException (CommonResponseEnum.INTERNAL_ERROR);
+            }else{
+                substationDTO = substationDTOList.get (0);
+            }
 
+            pollutionSubstationVO.setLatitude (substationDTO.getLat ());
+            pollutionSubstationVO.setLongitude (substationDTO.getLng ());
 
-            Double value = Optional.ofNullable(
-                    rStatPollutionSubstationMList
-                            .stream()
-                            .filter(temp -> Objects.equals(substationInfo.getId(), temp.getSubstationId()))
-                            .collect(Collectors.toList())
-                            .get(0)
-                            .getValue()
-            ).orElse(new Double("0.00"));
-            pollutionSubstationVO.setPollutionData(value);
-            pollutionSubstationVO.setPollutionStatis(pollutionSubstationQuryParam.getStatisticalType().getName());
-            pollutionSubstationVOList.add(pollutionSubstationVO);
+            List<RStatPollutionSubstationM> rStatPollutionSubstationMS = rStatPollutionSubstationMList.stream ( ).
+                    filter (temp -> Objects.equals (substationInfo.getId ( ), temp.getSubstationId ( )))
+                    .collect (Collectors.toList ( ));
+
+            Double value = 3.14159;
+            if(!CollectionUtils.isEmpty (rStatPollutionSubstationMS)){
+                value = rStatPollutionSubstationMS.get (0).getValue ();
+            }
+            pollutionSubstationVO.setPollutionData (value);
+            pollutionSubstationVO.setPollutionStatis ( pollutionSubstationQuryParam.getStatisticalType ().getName ());
+            pollutionSubstationVOList.add (pollutionSubstationVO);
         });
-        List<PollutionSubstationVO> result = pollutionSubstationVOList.stream().sorted(Comparator.comparing(PollutionSubstationVO::getPollutionData).reversed()).collect(Collectors.toList());
+        List<PollutionSubstationVO> result = pollutionSubstationVOList.stream ( ).sorted (Comparator.comparing (PollutionSubstationVO::getPollutionData).reversed ( )).collect (Collectors.toList ( ));
 
         return result;
     }

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RMpBenchmarkLevelMServiceImpl.java

@@ -0,0 +1,129 @@
+package com.njcn.harmonic.service.impl;
+
+import cn.hutool.core.collection.CollUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.common.pojo.dto.SimpleDTO;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.exception.BusinessException;
+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.PmsMonitorInfoDTO;
+import com.njcn.device.pms.pojo.param.PmsDeviceInfoParam;
+import com.njcn.device.pms.pojo.param.PmsMonitorInfoParam;
+import com.njcn.harmonic.mapper.RMpBenchmarkLevelMMapper;
+import com.njcn.harmonic.pojo.param.RMpBenchmarkLevelParam;
+import com.njcn.harmonic.pojo.po.RMpBenchmarkLevelM;
+import com.njcn.harmonic.pojo.vo.RMpBenchmarkLevelVO;
+import com.njcn.harmonic.service.RMpBenchmarkLevelMService;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataTypeEnum;
+import com.njcn.system.pojo.po.DictData;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang.StringUtils;
+import org.springframework.beans.BeanUtils;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+* @author jianghf
+* @description 针对表【r_mp_benchmark_level_m】的数据库操作Service实现
+* @createDate 2022-10-11 10:32:18
+*/
+@Service
+@RequiredArgsConstructor
+public class RMpBenchmarkLevelMServiceImpl extends ServiceImpl<RMpBenchmarkLevelMMapper, RMpBenchmarkLevelM>
+implements RMpBenchmarkLevelMService {
+
+    private final DicDataFeignClient dicDataFeignClient;
+
+    private final PmsGeneralDeviceInfoClient pmsGeneralDeviceInfoClient;
+
+    private final MonitorClient monitorClient;
+
+    @Override
+    public List<RMpBenchmarkLevelVO> getRMpBenchmarkLevelList(RMpBenchmarkLevelParam rMpBenchmarkLevelParam) {
+        //提取查询条件
+        String id = rMpBenchmarkLevelParam.getId(); //单位id
+        if (StringUtils.isBlank(id)) {
+            throw new BusinessException(CommonResponseEnum.NO_DATA, "单位id不可为空");
+        }
+        String startTime = rMpBenchmarkLevelParam.getStartTime(); //开始时间
+        String endTime = rMpBenchmarkLevelParam.getEndTime(); //截止时间
+        String benchmarkIndicator = rMpBenchmarkLevelParam.getBenchmarkIndicator(); //评价指标
+        List <String> voltageLevelParamList = StringUtils.isNotBlank(rMpBenchmarkLevelParam.getVoltageLevel()) ? Arrays.asList(rMpBenchmarkLevelParam.getVoltageLevel().split(",")) : null; //电压等级
+
+        //获取电压等级的字典
+        List<DictData> voltageLevelList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.DEV_VOLTAGE.getCode()).getData();
+        //将电压信息转成map，key：id  value：name
+        Map<String, String> voltageLevelMap = voltageLevelList.stream().collect(Collectors.toMap(DictData::getId, DictData::getName));
+        //获取基准水平评价指标字典
+        List<DictData> benchmarkIndicatorList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.BENCHMARK_INDICATORS.getCode()).getData();
+        //将基准水平评价指标信息转成map，key：id  value：name
+        Map<String, String> benchmarkIndicatorMap = benchmarkIndicatorList.stream().collect(Collectors.toMap(DictData::getId, DictData::getName));
+
+        //查询所有子单位下的所有监测点
+        PmsDeviceInfoParam pmsDeviceInfoParam = new PmsDeviceInfoParam(id);
+        pmsDeviceInfoParam.setStatisticalType(new SimpleDTO());
+        if (CollUtil.isNotEmpty(voltageLevelParamList)) {
+            //查询条件：电压等级（筛选电压等级为voltageLevel的监测点）
+            List<SimpleDTO> simpleDTOList = voltageLevelParamList.stream().map(item -> {
+                SimpleDTO simpleDTO = new SimpleDTO();
+                simpleDTO.setId(item);
+                return simpleDTO;
+            }).collect(Collectors.toList());
+            pmsDeviceInfoParam.setVoltageLevel(simpleDTOList);
+        }
+        //获取到该部门的所有子部门的监测点idList
+        List<PmsGeneralDeviceDTO> pmsDeviceInfoWithInOrg = pmsGeneralDeviceInfoClient.getPmsDeviceInfoWithInOrg(pmsDeviceInfoParam).getData();
+        //过滤出业务需要的监测点id集合
+        List<String> firstMonitorIdList = new ArrayList<>(); //只用于合并多个部门的监测点id
+        pmsDeviceInfoWithInOrg.forEach(item -> firstMonitorIdList.addAll(item.getMonitorIdList()));
+        List<String> lastMonitorIdList = firstMonitorIdList.stream().distinct().collect(Collectors.toList()); //最终的监测点id集合
+        //如果没有监测点id信息，直接返回空集合
+        if (CollUtil.isEmpty(lastMonitorIdList)) {
+            return new ArrayList<>();
+        }
+        //查询对应的监测点完整信息 并转为key：监测点id value：监测点实体的map集合
+//        LambdaQueryWrapper<Monitor> monitorWrapper = new LambdaQueryWrapper<>();
+//        monitorWrapper.in(Monitor::getId, lastMonitorIdList);
+        PmsMonitorInfoParam pmsMonitorInfoParam = new PmsMonitorInfoParam();
+        pmsMonitorInfoParam.setMonitorIds(lastMonitorIdList);
+        Map<String, PmsMonitorInfoDTO> monitorMap = monitorClient.getMonitorInfo(pmsMonitorInfoParam).getData().stream().collect(Collectors.toMap(PmsMonitorInfoDTO::getMonitorId, monitor -> monitor));
+        //查询【基准水平-月】数据
+        /*组装条件：where measurement_point_id in (monitorIdList) and data_date >= startTime
+                   and data_date <= endTime and voltage_level
+        */
+        LambdaQueryWrapper<RMpBenchmarkLevelM> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.in(CollUtil.isNotEmpty(lastMonitorIdList), RMpBenchmarkLevelM::getMeasurementPointId, lastMonitorIdList)
+                .ge(StringUtils.isNotBlank(startTime), RMpBenchmarkLevelM::getDataDate, startTime)
+                .le(StringUtils.isNotBlank(endTime), RMpBenchmarkLevelM::getDataDate, endTime);
+        List<RMpBenchmarkLevelM> list = this.list(lambdaQueryWrapper);
+        List<RMpBenchmarkLevelVO> resultList = list.stream().map(item -> {
+            //封装前端需要的对象
+            RMpBenchmarkLevelVO rMpBenchmarkLevelVO = new RMpBenchmarkLevelVO();
+            BeanUtils.copyProperties(item, rMpBenchmarkLevelVO);
+            PmsGeneralDeviceDTO pmsGeneralDeviceDTO = pmsDeviceInfoWithInOrg.stream().filter(dto -> dto.getMonitorIdList().contains(item.getMeasurementPointId()))
+                    .collect(Collectors.toList()).get(0);
+            //单位信息
+            rMpBenchmarkLevelVO.setOrgNo(pmsGeneralDeviceDTO.getIndex()); //单位id
+            rMpBenchmarkLevelVO.setOrgName(pmsGeneralDeviceDTO.getName()); //单位名称
+            //基准水平评价指标
+            rMpBenchmarkLevelVO.setBenchmarkIndicator(benchmarkIndicator); //基准水平评价指标id
+            rMpBenchmarkLevelVO.setBenchmarkIndicatorName(benchmarkIndicatorMap.get(benchmarkIndicator)); //基准水平评价指标
+            //监测点信息
+            rMpBenchmarkLevelVO.setMeasurementPointName(monitorMap.get(item.getMeasurementPointId()).getMonitorName()); //监测点名称
+            //电压等级
+            rMpBenchmarkLevelVO.setVoltageLevel(monitorMap.get(item.getMeasurementPointId()).getMonitorVoltageLevel());
+            rMpBenchmarkLevelVO.setVoltageLevelName(voltageLevelMap.get(monitorMap.get(item.getMeasurementPointId()).getMonitorVoltageLevel()));
+            return rMpBenchmarkLevelVO;
+        }).collect(Collectors.toList());
+        return resultList;
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RMpBenchmarkLevelQServiceImpl.java

@@ -0,0 +1,129 @@
+package com.njcn.harmonic.service.impl;
+
+import cn.hutool.core.collection.CollUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.common.pojo.dto.SimpleDTO;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.exception.BusinessException;
+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.PmsMonitorInfoDTO;
+import com.njcn.device.pms.pojo.param.PmsDeviceInfoParam;
+import com.njcn.device.pms.pojo.param.PmsMonitorInfoParam;
+import com.njcn.harmonic.mapper.RMpBenchmarkLevelQMapper;
+import com.njcn.harmonic.pojo.param.RMpBenchmarkLevelParam;
+import com.njcn.harmonic.pojo.po.RMpBenchmarkLevelQ;
+import com.njcn.harmonic.pojo.vo.RMpBenchmarkLevelVO;
+import com.njcn.harmonic.service.RMpBenchmarkLevelQService;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataTypeEnum;
+import com.njcn.system.pojo.po.DictData;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang.StringUtils;
+import org.springframework.beans.BeanUtils;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+* @author jianghf
+* @description 针对表【r_mp_benchmark_level_q】的数据库操作Service实现
+* @createDate 2022-10-11 10:32:18
+*/
+@Service
+@RequiredArgsConstructor
+public class RMpBenchmarkLevelQServiceImpl extends ServiceImpl<RMpBenchmarkLevelQMapper, RMpBenchmarkLevelQ>
+implements RMpBenchmarkLevelQService {
+
+    private final DicDataFeignClient dicDataFeignClient;
+
+    private final PmsGeneralDeviceInfoClient pmsGeneralDeviceInfoClient;
+
+    private final MonitorClient monitorClient;
+
+    @Override
+    public List<RMpBenchmarkLevelVO> getRMpBenchmarkLevelList(RMpBenchmarkLevelParam rMpBenchmarkLevelParam) {
+        //提取查询条件
+        String id = rMpBenchmarkLevelParam.getId(); //单位id
+        if (StringUtils.isBlank(id)) {
+            throw new BusinessException(CommonResponseEnum.NO_DATA, "单位id不可为空");
+        }
+        String startTime = rMpBenchmarkLevelParam.getStartTime(); //开始时间
+        String endTime = rMpBenchmarkLevelParam.getEndTime(); //截止时间
+        String benchmarkIndicator = rMpBenchmarkLevelParam.getBenchmarkIndicator(); //评价指标
+        List <String> voltageLevelParamList = StringUtils.isNotBlank(rMpBenchmarkLevelParam.getVoltageLevel()) ? Arrays.asList(rMpBenchmarkLevelParam.getVoltageLevel().split(",")) : null; //电压等级
+
+        //获取电压等级的字典
+        List<DictData> voltageLevelList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.DEV_VOLTAGE.getCode()).getData();
+        //将电压信息转成map，key：id  value：name
+        Map<String, String> voltageLevelMap = voltageLevelList.stream().collect(Collectors.toMap(DictData::getId, DictData::getName));
+        //获取基准水平评价指标字典
+        List<DictData> benchmarkIndicatorList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.BENCHMARK_INDICATORS.getCode()).getData();
+        //将基准水平评价指标信息转成map，key：id  value：name
+        Map<String, String> benchmarkIndicatorMap = benchmarkIndicatorList.stream().collect(Collectors.toMap(DictData::getId, DictData::getName));
+
+        //查询所有子单位下的所有监测点
+        PmsDeviceInfoParam pmsDeviceInfoParam = new PmsDeviceInfoParam(id);
+        pmsDeviceInfoParam.setStatisticalType(new SimpleDTO());
+        if (CollUtil.isNotEmpty(voltageLevelParamList)) {
+            //查询条件：电压等级（筛选电压等级为voltageLevel的监测点）
+            List<SimpleDTO> simpleDTOList = voltageLevelParamList.stream().map(item -> {
+                SimpleDTO simpleDTO = new SimpleDTO();
+                simpleDTO.setId(item);
+                return simpleDTO;
+            }).collect(Collectors.toList());
+            pmsDeviceInfoParam.setVoltageLevel(simpleDTOList);
+        }
+        //获取到该部门的所有子部门的监测点idList
+        List<PmsGeneralDeviceDTO> pmsDeviceInfoWithInOrg = pmsGeneralDeviceInfoClient.getPmsDeviceInfoWithInOrg(pmsDeviceInfoParam).getData();
+        //过滤出业务需要的监测点id集合
+        List<String> firstMonitorIdList = new ArrayList<>(); //只用于合并多个部门的监测点id
+        pmsDeviceInfoWithInOrg.forEach(item -> firstMonitorIdList.addAll(item.getMonitorIdList()));
+        List<String> lastMonitorIdList = firstMonitorIdList.stream().distinct().collect(Collectors.toList()); //最终的监测点id集合
+        //如果没有监测点id信息，直接返回空集合
+        if (CollUtil.isEmpty(lastMonitorIdList)) {
+            return new ArrayList<>();
+        }
+        //查询对应的监测点完整信息 并转为key：监测点id value：监测点实体的map集合
+//        LambdaQueryWrapper<Monitor> monitorWrapper = new LambdaQueryWrapper<>();
+//        monitorWrapper.in(Monitor::getId, lastMonitorIdList);
+        PmsMonitorInfoParam pmsMonitorInfoParam = new PmsMonitorInfoParam();
+        pmsMonitorInfoParam.setMonitorIds(lastMonitorIdList);
+        Map<String, PmsMonitorInfoDTO> monitorMap = monitorClient.getMonitorInfo(pmsMonitorInfoParam).getData().stream().collect(Collectors.toMap(PmsMonitorInfoDTO::getMonitorId, monitor -> monitor));
+        //查询【基准水平-月】数据
+        /*组装条件：where measurement_point_id in (monitorIdList) and data_date >= startTime
+                   and data_date <= endTime and voltage_level
+        */
+        LambdaQueryWrapper<RMpBenchmarkLevelQ> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.in(CollUtil.isNotEmpty(lastMonitorIdList), RMpBenchmarkLevelQ::getMeasurementPointId, lastMonitorIdList)
+                .ge(StringUtils.isNotBlank(startTime), RMpBenchmarkLevelQ::getDataDate, startTime)
+                .le(StringUtils.isNotBlank(endTime), RMpBenchmarkLevelQ::getDataDate, endTime);
+        List<RMpBenchmarkLevelQ> list = this.list(lambdaQueryWrapper);
+        List<RMpBenchmarkLevelVO> resultList = list.stream().map(item -> {
+            //封装前端需要的对象
+            RMpBenchmarkLevelVO rMpBenchmarkLevelVO = new RMpBenchmarkLevelVO();
+            BeanUtils.copyProperties(item, rMpBenchmarkLevelVO);
+            PmsGeneralDeviceDTO pmsGeneralDeviceDTO = pmsDeviceInfoWithInOrg.stream().filter(dto -> dto.getMonitorIdList().contains(item.getMeasurementPointId()))
+                    .collect(Collectors.toList()).get(0);
+            //单位信息
+            rMpBenchmarkLevelVO.setOrgNo(pmsGeneralDeviceDTO.getIndex()); //单位id
+            rMpBenchmarkLevelVO.setOrgName(pmsGeneralDeviceDTO.getName()); //单位名称
+            //基准水平评价指标
+            rMpBenchmarkLevelVO.setBenchmarkIndicator(benchmarkIndicator); //基准水平评价指标id
+            rMpBenchmarkLevelVO.setBenchmarkIndicatorName(benchmarkIndicatorMap.get(benchmarkIndicator)); //基准水平评价指标
+            //监测点信息
+            rMpBenchmarkLevelVO.setMeasurementPointName(monitorMap.get(item.getMeasurementPointId()).getMonitorName()); //监测点名称
+            //电压等级
+            rMpBenchmarkLevelVO.setVoltageLevel(monitorMap.get(item.getMeasurementPointId()).getMonitorVoltageLevel());
+            rMpBenchmarkLevelVO.setVoltageLevelName(voltageLevelMap.get(monitorMap.get(item.getMeasurementPointId()).getMonitorVoltageLevel()));
+            return rMpBenchmarkLevelVO;
+        }).collect(Collectors.toList());
+        return resultList;
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RMpBenchmarkLevelYServiceImpl.java

@@ -0,0 +1,129 @@
+package com.njcn.harmonic.service.impl;
+
+import cn.hutool.core.collection.CollUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.common.pojo.dto.SimpleDTO;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.exception.BusinessException;
+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.PmsMonitorInfoDTO;
+import com.njcn.device.pms.pojo.param.PmsDeviceInfoParam;
+import com.njcn.device.pms.pojo.param.PmsMonitorInfoParam;
+import com.njcn.harmonic.mapper.RMpBenchmarkLevelYMapper;
+import com.njcn.harmonic.pojo.param.RMpBenchmarkLevelParam;
+import com.njcn.harmonic.pojo.po.RMpBenchmarkLevelY;
+import com.njcn.harmonic.pojo.vo.RMpBenchmarkLevelVO;
+import com.njcn.harmonic.service.RMpBenchmarkLevelYService;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataTypeEnum;
+import com.njcn.system.pojo.po.DictData;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang.StringUtils;
+import org.springframework.beans.BeanUtils;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+* @author jianghf
+* @description 针对表【r_mp_benchmark_level_y】的数据库操作Service实现
+* @createDate 2022-10-11 10:32:18
+*/
+@Service
+@RequiredArgsConstructor
+public class RMpBenchmarkLevelYServiceImpl extends ServiceImpl<RMpBenchmarkLevelYMapper, RMpBenchmarkLevelY>
+implements RMpBenchmarkLevelYService {
+
+    private final DicDataFeignClient dicDataFeignClient;
+
+    private final PmsGeneralDeviceInfoClient pmsGeneralDeviceInfoClient;
+
+    private final MonitorClient monitorClient;
+
+    @Override
+    public List<RMpBenchmarkLevelVO> getRMpBenchmarkLevelList(RMpBenchmarkLevelParam rMpBenchmarkLevelParam) {
+        //提取查询条件
+        String id = rMpBenchmarkLevelParam.getId(); //单位id
+        if (StringUtils.isBlank(id)) {
+            throw new BusinessException(CommonResponseEnum.NO_DATA, "单位id不可为空");
+        }
+        String startTime = rMpBenchmarkLevelParam.getStartTime(); //开始时间
+        String endTime = rMpBenchmarkLevelParam.getEndTime(); //截止时间
+        String benchmarkIndicator = rMpBenchmarkLevelParam.getBenchmarkIndicator(); //评价指标
+        List <String> voltageLevelParamList = StringUtils.isNotBlank(rMpBenchmarkLevelParam.getVoltageLevel()) ? Arrays.asList(rMpBenchmarkLevelParam.getVoltageLevel().split(",")) : null; //电压等级
+
+        //获取电压等级的字典
+        List<DictData> voltageLevelList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.DEV_VOLTAGE.getCode()).getData();
+        //将电压信息转成map，key：id  value：name
+        Map<String, String> voltageLevelMap = voltageLevelList.stream().collect(Collectors.toMap(DictData::getId, DictData::getName));
+        //获取基准水平评价指标字典
+        List<DictData> benchmarkIndicatorList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.BENCHMARK_INDICATORS.getCode()).getData();
+        //将基准水平评价指标信息转成map，key：id  value：name
+        Map<String, String> benchmarkIndicatorMap = benchmarkIndicatorList.stream().collect(Collectors.toMap(DictData::getId, DictData::getName));
+
+        //查询所有子单位下的所有监测点
+        PmsDeviceInfoParam pmsDeviceInfoParam = new PmsDeviceInfoParam(id);
+        pmsDeviceInfoParam.setStatisticalType(new SimpleDTO());
+        if (CollUtil.isNotEmpty(voltageLevelParamList)) {
+            //查询条件：电压等级（筛选电压等级为voltageLevel的监测点）
+            List<SimpleDTO> simpleDTOList = voltageLevelParamList.stream().map(item -> {
+                SimpleDTO simpleDTO = new SimpleDTO();
+                simpleDTO.setId(item);
+                return simpleDTO;
+            }).collect(Collectors.toList());
+            pmsDeviceInfoParam.setVoltageLevel(simpleDTOList);
+        }
+        //获取到该部门的所有子部门的监测点idList
+        List<PmsGeneralDeviceDTO> pmsDeviceInfoWithInOrg = pmsGeneralDeviceInfoClient.getPmsDeviceInfoWithInOrg(pmsDeviceInfoParam).getData();
+        //过滤出业务需要的监测点id集合
+        List<String> firstMonitorIdList = new ArrayList<>(); //只用于合并多个部门的监测点id
+        pmsDeviceInfoWithInOrg.forEach(item -> firstMonitorIdList.addAll(item.getMonitorIdList()));
+        List<String> lastMonitorIdList = firstMonitorIdList.stream().distinct().collect(Collectors.toList()); //最终的监测点id集合
+        //如果没有监测点id信息，直接返回空集合
+        if (CollUtil.isEmpty(lastMonitorIdList)) {
+            return new ArrayList<>();
+        }
+        //查询对应的监测点完整信息 并转为key：监测点id value：监测点实体的map集合
+//        LambdaQueryWrapper<Monitor> monitorWrapper = new LambdaQueryWrapper<>();
+//        monitorWrapper.in(Monitor::getId, lastMonitorIdList);
+        PmsMonitorInfoParam pmsMonitorInfoParam = new PmsMonitorInfoParam();
+        pmsMonitorInfoParam.setMonitorIds(lastMonitorIdList);
+        Map<String, PmsMonitorInfoDTO> monitorMap = monitorClient.getMonitorInfo(pmsMonitorInfoParam).getData().stream().collect(Collectors.toMap(PmsMonitorInfoDTO::getMonitorId, monitor -> monitor));
+        //查询【基准水平-月】数据
+        /*组装条件：where measurement_point_id in (monitorIdList) and data_date >= startTime
+                   and data_date <= endTime and voltage_level
+        */
+        LambdaQueryWrapper<RMpBenchmarkLevelY> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.in(CollUtil.isNotEmpty(lastMonitorIdList), RMpBenchmarkLevelY::getMeasurementPointId, lastMonitorIdList)
+                .ge(StringUtils.isNotBlank(startTime), RMpBenchmarkLevelY::getDataDate, startTime)
+                .le(StringUtils.isNotBlank(endTime), RMpBenchmarkLevelY::getDataDate, endTime);
+        List<RMpBenchmarkLevelY> list = this.list(lambdaQueryWrapper);
+        List<RMpBenchmarkLevelVO> resultList = list.stream().map(item -> {
+            //封装前端需要的对象
+            RMpBenchmarkLevelVO rMpBenchmarkLevelVO = new RMpBenchmarkLevelVO();
+            BeanUtils.copyProperties(item, rMpBenchmarkLevelVO);
+            PmsGeneralDeviceDTO pmsGeneralDeviceDTO = pmsDeviceInfoWithInOrg.stream().filter(dto -> dto.getMonitorIdList().contains(item.getMeasurementPointId()))
+                    .collect(Collectors.toList()).get(0);
+            //单位信息
+            rMpBenchmarkLevelVO.setOrgNo(pmsGeneralDeviceDTO.getIndex()); //单位id
+            rMpBenchmarkLevelVO.setOrgName(pmsGeneralDeviceDTO.getName()); //单位名称
+            //基准水平评价指标
+            rMpBenchmarkLevelVO.setBenchmarkIndicator(benchmarkIndicator); //基准水平评价指标id
+            rMpBenchmarkLevelVO.setBenchmarkIndicatorName(benchmarkIndicatorMap.get(benchmarkIndicator)); //基准水平评价指标
+            //监测点信息
+            rMpBenchmarkLevelVO.setMeasurementPointName(monitorMap.get(item.getMeasurementPointId()).getMonitorName()); //监测点名称
+            //电压等级
+            rMpBenchmarkLevelVO.setVoltageLevel(monitorMap.get(item.getMeasurementPointId()).getMonitorVoltageLevel());
+            rMpBenchmarkLevelVO.setVoltageLevelName(voltageLevelMap.get(monitorMap.get(item.getMeasurementPointId()).getMonitorVoltageLevel()));
+            return rMpBenchmarkLevelVO;
+        }).collect(Collectors.toList());
+        return resultList;
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RMpHarmonicIMagReportDServiceImpl.java

@@ -0,0 +1,29 @@
+package com.njcn.harmonic.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.harmonic.pojo.po.RMpHarmonicIMagReportD;
+import com.njcn.harmonic.service.RMpHarmonicIMagReportDService;
+import com.njcn.harmonic.mapper.RMpHarmonicIMagReportDMapper;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+* @author Administrator
+* @description 针对表【r_mp_harmonic_i_mag_report_d(稳态监测点指标日报-日表(主配网表)  /各次谐波电流有效值)】的数据库操作Service实现
+* @createDate 2022-10-20 18:38:15
+*/
+@Service
+public class RMpHarmonicIMagReportDServiceImpl extends ServiceImpl<RMpHarmonicIMagReportDMapper, RMpHarmonicIMagReportD>
+    implements RMpHarmonicIMagReportDService{
+
+    @Override
+    public List<RMpHarmonicIMagReportD> getListByCond(Map<String, Object> condMap) {
+        return this.baseMapper.getListByCond(condMap);
+    }
+}
+
+
+
+

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RMpHarmonicIRateReportDServiceImpl.java

@@ -0,0 +1,29 @@
+package com.njcn.harmonic.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.harmonic.pojo.po.RMpHarmonicIRateReportD;
+import com.njcn.harmonic.service.RMpHarmonicIRateReportDService;
+import com.njcn.harmonic.mapper.RMpHarmonicIRateReportDMapper;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+* @author Administrator
+* @description 针对表【r_mp_harmonic_i_rate_report_d(稳态监测点指标日报-日表(主网表)  /各次谐波电流含有率)】的数据库操作Service实现
+* @createDate 2022-10-20 18:43:52
+*/
+@Service
+public class RMpHarmonicIRateReportDServiceImpl extends ServiceImpl<RMpHarmonicIRateReportDMapper, RMpHarmonicIRateReportD>
+    implements RMpHarmonicIRateReportDService{
+
+    @Override
+    public List<RMpHarmonicIRateReportD> getListByCond(Map<String, Object> condMap) {
+        return this.baseMapper.getListByCond(condMap);
+    }
+}
+
+
+
+

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RMpHarmonicReportDServiceImpl.java

@@ -0,0 +1,241 @@
+package com.njcn.harmonic.service.impl;
+
+import com.njcn.device.pms.api.MonitorClient;
+import com.njcn.device.pms.api.StatationStatClient;
+import com.njcn.device.pms.pojo.dto.PmsMonitorDTO;
+import com.njcn.device.pms.pojo.dto.PmsStatationStatInfoDTO;
+import com.njcn.device.pms.pojo.param.PmsMonitorParam;
+import com.njcn.device.pms.pojo.param.PmsStatationStatInfoParam;
+import com.njcn.device.pq.pojo.po.Overlimit;
+import com.njcn.harmonic.pojo.param.RMpHarmonicReportDParam;
+import com.njcn.harmonic.pojo.po.*;
+import com.njcn.harmonic.pojo.vo.RMpHarmonicReportDVO;
+import com.njcn.harmonic.service.*;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.enums.DicDataTypeEnum;
+import com.njcn.system.pojo.po.DictData;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang.StringUtils;
+import org.springframework.stereotype.Service;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @Title RMpHarmonicReportDServiceImpl
+ * @Package com.njcn.harmonic.service.impl
+ * @Author jianghaifei
+ * @Date 2022-10-20 19:19
+ * @Version V1.0
+ */
+@Service
+@RequiredArgsConstructor
+public class RMpHarmonicReportDServiceImpl implements RMpHarmonicReportDService {
+
+    private final MonitorClient monitorClient; //监测点服务
+
+    private final DicDataFeignClient dicDataFeignClient; //字典服务
+
+    private final StatationStatClient statationStatClient; //变电站服务
+
+    private final RMpMeasureReportDService rMpMeasureReportDService; //【稳态监测点非谐波不带相位指标日报-日表(主配网表)】
+
+    private final RMpMeasurePhaseReportDService  rMpMeasurePhaseReportDService; //【稳态监测点非谐波带相位指标日报-日表(主配网表)】
+
+    //r_mp_harmonic_v_rate_report_d
+    private final RMpHarmonicVRateReportDService rMpHarmonicVRateReportDService; //【稳态监测点指标日报-日表(主配网表)  /各次谐波电压含有率】
+
+    //r_mp_harmonic_i_mag_report_d
+    private final RMpHarmonicIMagReportDService rMpHarmonicIMagReportDService; //【各相各次谐波电流有效值】
+
+    //r_mp_harmonic_i_rate_report_d
+    private final RMpHarmonicIRateReportDService rMpHarmonicIRateReportDService; //【各相各次谐波电流含有率】
+
+    //r_mp_inharmonic_v_rate_report_d
+    private final RMpInharmonicVRateReportDService rMpInharmonicVRateReportDService; //【各相各次间谐波电压含有率】
+
+    //r_mp_inharmonic_i_rate_report_d
+    private final RMpInharmonicIRateReportDService rMpInharmonicIRateReportDService; //【各相各次间谐波电流含有率】
+
+    @Override
+    public List<RMpHarmonicReportDVO> getMonitorStatisticsD(RMpHarmonicReportDParam rMpHarmonicReportDParam) {
+//
+//        Overlimit data = lineFeignClient.getOverLimitData("064b948a81090b80860483994f2a8e75").getData();
+//        System.out.println(data);
+        //提取查询参数
+//        String monitorName = rMpHarmonicReportDParam.getMonitorName(); //监测点名称
+        String startTime = rMpHarmonicReportDParam.getStartTime();
+        String endTime = rMpHarmonicReportDParam.getEndTime();
+        String monitorId = rMpHarmonicReportDParam.getMonitorId(); //监测点id
+        List<String> monitorIds = StringUtils.isNotBlank(monitorId) ? Arrays.asList(monitorId.split(",")) : null;
+        //获取所有的条件筛选后的监测点信息
+        PmsMonitorParam pmsMonitorParam = new PmsMonitorParam();
+//        pmsMonitorParam.setMonitorName(monitorName); //监测点名称(模糊查询)
+        pmsMonitorParam.setMonitorIds(monitorIds); //监测点id集合
+        List<PmsMonitorDTO> monitors = monitorClient.getMonitorInfoListByCond(pmsMonitorParam).getData();
+
+        //提取出监测点的id集合
+        List<String> monitorIdList = monitors.stream().map(PmsMonitorDTO::getId).collect(Collectors.toList());
+        //提取出变电站id集合
+        List<String> stationIdList = monitors.stream().map(PmsMonitorDTO::getPowerrId).collect(Collectors.toList());
+        PmsStatationStatInfoParam stationParam = new PmsStatationStatInfoParam();
+        stationParam.setPowerIds(stationIdList);
+        List<PmsStatationStatInfoDTO> stationList = statationStatClient.getStatationStatInfo(stationParam).getData();
+        Map<String, PmsStatationStatInfoDTO> stationMap = stationList.stream().collect(Collectors.toMap(PmsStatationStatInfoDTO::getPowerId, dto -> dto));
+
+        //获取电压等级的字典
+        List<DictData> voltageLevelList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.DEV_VOLTAGE.getCode()).getData();
+        //将电压信息转成map，key：id  value：name
+        Map<String, String> voltageLevelMap = voltageLevelList.stream().collect(Collectors.toMap(DictData::getId, DictData::getName));
+
+        //获取监测点的各相限值（不出意外的情况下前端只会传1个ID，这里防止有多个ID所以服务里都是用的id集合）
+        List<Overlimit> overlimitList = new ArrayList<>();
+        for (String id : monitorIdList) {
+            Overlimit overlimit = monitorClient.getOverLimitData(id).getData();
+            overlimitList.add(overlimit);
+        }
+        Map<String, Overlimit> overLimitMap = overlimitList.stream().collect(Collectors.toMap(Overlimit::getId, o -> o));
+
+        /************查询每个检测点的日统计信息**************/
+        //设置查询条件(通用于以下几张表的查询)
+        HashMap<String, Object> condMap = new HashMap<>();
+        condMap.put("startTime", startTime);
+        condMap.put("endTime", endTime);
+        condMap.put("monitorIdList", monitorIdList);
+        //1.r_mp_measure_report_d【稳态监测点非谐波不带相位指标日报-日表(主配网表)】
+//        LambdaQueryWrapper<RMpMeasureReportD> rMpMeasureReportDWrapper = new LambdaQueryWrapper<>();
+//        rMpMeasureReportDWrapper.in(RMpMeasureReportD::getMeasurementPointId, monitorIdList)
+//                .ge(RMpMeasureReportD::getDataDate, startTime).le(RMpMeasureReportD::getDataDate, endTime);
+        List<RMpMeasureReportD> RMpMeasureReportDList = rMpMeasureReportDService.getListByCond(condMap);
+        //1.1转成map，key：监测点id  value：实体
+        Map<String, RMpMeasureReportD> RMpMeasureReportDMap = RMpMeasureReportDList.stream().collect(Collectors.toMap(RMpMeasureReportD::getMeasurementPointId, entity -> entity));
+
+        //2.r_mp_measure_phase_report_d【稳态监测点非谐波带相位指标日报-日表(主配网表)】
+//        LambdaQueryWrapper<RMpMeasurePhaseReportD> rMpMeasurePhaseReportDWrapper = new LambdaQueryWrapper<>();
+//        rMpMeasurePhaseReportDWrapper.in(RMpMeasurePhaseReportD::getMeasurementPointId, monitorIdList)
+//                .ge(RMpMeasurePhaseReportD::getDataDate, startTime).le(RMpMeasurePhaseReportD::getDataDate, endTime);
+        List<RMpMeasurePhaseReportD> RMpMeasurePhaseReportDList = rMpMeasurePhaseReportDService.getListByCond(condMap);
+
+        //3.r_mp_harmonic_v_rate_report_d【稳态监测点指标日报-日表(主配网表)  /各次谐波电压含有率】
+//        LambdaQueryWrapper<RMpHarmonicVRateReportD> rMpHarmonicVRateReportWrapper = new LambdaQueryWrapper<>();
+//        rMpHarmonicVRateReportWrapper.in(RMpHarmonicVRateReportD::getMeasurementPointId, monitorIdList)
+//                .ge(RMpHarmonicVRateReportD::getDataDate, startTime).le(RMpHarmonicVRateReportD::getDataDate, endTime);
+
+        List<RMpHarmonicVRateReportD> rMpHarmonicVRateReportDList = rMpHarmonicVRateReportDService.getListByCond(condMap);
+
+        //4.r_mp_harmonic_i_mag_report_d【各相各次谐波电流有效值】
+//        LambdaQueryWrapper<RMpHarmonicIMagReportD> rMpHarmonicIMagReportDWrapper = new LambdaQueryWrapper<>();
+//        rMpHarmonicIMagReportDWrapper.in(RMpHarmonicIMagReportD::getMeasurementPointId, monitorIdList)
+//                .ge(RMpHarmonicIMagReportD::getDataDate, startTime).le(RMpHarmonicIMagReportD::getDataDate, endTime);
+        List<RMpHarmonicIMagReportD> rMpHarmonicIMagReportDList = rMpHarmonicIMagReportDService.getListByCond(condMap);
+
+        //5.r_mp_harmonic_i_rate_report_d【各相各次谐波电流含有率】
+//        LambdaQueryWrapper<RMpHarmonicIRateReportD> rMpHarmonicIRateReportDWrapper = new LambdaQueryWrapper<>();
+//        rMpHarmonicIRateReportDWrapper.in(RMpHarmonicIRateReportD::getMeasurementPointId, monitorIdList)
+//                .ge(RMpHarmonicIRateReportD::getDataDate, startTime).le(RMpHarmonicIRateReportD::getDataDate, endTime);
+        List<RMpHarmonicIRateReportD> rMpHarmonicIRateReportDList = rMpHarmonicIRateReportDService.getListByCond(condMap);
+
+        //6.r_mp_inharmonic_v_rate_report_d【各相各次间谐波电压含有率】
+//        LambdaQueryWrapper<RMpInharmonicVRateReportD> rMpInharmonicVRateReportDWrapper = new LambdaQueryWrapper<>();
+//        rMpInharmonicVRateReportDWrapper.in(RMpInharmonicVRateReportD::getMeasurementPointId, monitorIdList)
+//                .ge(RMpInharmonicVRateReportD::getDataDate, startTime).le(RMpInharmonicVRateReportD::getDataDate, endTime);
+        List<RMpInharmonicVRateReportD> rMpInharmonicVRateReportDList = rMpInharmonicVRateReportDService.getListByCond(condMap);
+
+        //7.r_mp_inharmonic_i_rate_report_d【各相各次间谐波电流含有率】
+//        LambdaQueryWrapper<RMpInharmonicIRateReportD> rMpInharmonicIRateReportDWrapper = new LambdaQueryWrapper<>();
+//        rMpInharmonicIRateReportDWrapper.in(RMpInharmonicIRateReportD::getMeasurementPointId, monitorIdList)
+//                .ge(RMpInharmonicIRateReportD::getDataDate, startTime).le(RMpInharmonicIRateReportD::getDataDate, endTime);
+        List<RMpInharmonicIRateReportD> rMpInharmonicIRateReportDList = rMpInharmonicIRateReportDService.getListByCond(condMap);
+
+        /*************整理返回数据**************/
+        List<RMpHarmonicReportDVO> RMpHarmonicReportDVOList = monitors.stream().map(item -> {
+            RMpHarmonicReportDVO rMpHarmonicReportDVO = new RMpHarmonicReportDVO();
+            rMpHarmonicReportDVO.setOrgNo(item.getOrgId()); //单位id
+            rMpHarmonicReportDVO.setOrgName(item.getOrgName()); //单位名称
+            rMpHarmonicReportDVO.setPowerId(item.getPowerrId()); //变电站id
+            rMpHarmonicReportDVO.setPowerName(item.getPowerrName()); //变电站名称
+            rMpHarmonicReportDVO.setMeasurementPointId(item.getId()); //监测点ID
+            rMpHarmonicReportDVO.setMeasurementPointName(item.getName()); //监测点名称
+            rMpHarmonicReportDVO.setMinShortCircuitCapacity(item.getMinShortCircuitCapacity()); //最小短路容量
+            rMpHarmonicReportDVO.setVoltageLevel(stationMap.get(item.getPowerrId()).getPowerVoltageLevel()); //变电站电压等级id
+            rMpHarmonicReportDVO.setVoltageLevelName(voltageLevelMap.get(stationMap.get(item.getPowerrId()).getPowerVoltageLevel()));//变电站电压等级
+            rMpHarmonicReportDVO.setDataDate(startTime); //监测日期
+            /****r_mp_measure_report_d数据****/
+            rMpHarmonicReportDVO.setRMpMeasureReportD(RMpMeasureReportDMap.get(item.getId()));
+//            //总有功功率
+//            rMpHarmonicReportDVO.setTotalActivePowerMax(RMpMeasureReportDMap.get(item.getId()).getTotalActivePowerMax());
+//            rMpHarmonicReportDVO.setTotalActivePowerMin(RMpMeasureReportDMap.get(item.getId()).getTotalActivePowerMin());
+//            rMpHarmonicReportDVO.setTotalActivePowerAvg(RMpMeasureReportDMap.get(item.getId()).getTotalActivePowerAvg());
+//            rMpHarmonicReportDVO.setTotalActivePower95(RMpMeasureReportDMap.get(item.getId()).getTotalActivePower95());
+            Double frequencyDeviationMax = RMpMeasureReportDMap.get(item.getId()).getFrequencyDeviationMax(); //频率偏差-最大值
+            Double freqDev = Double.parseDouble(String.valueOf(overLimitMap.get(item.getId()).getFreqDev())); //频率偏差限值
+            rMpHarmonicReportDVO.setFrequencyDeviationMaxResult((frequencyDeviationMax > freqDev) ? "越限" : "正常"); // 频率偏差-最大值限值结论
+//            //总无功功率
+//            rMpHarmonicReportDVO.setTotalReactivePowerMax(RMpMeasureReportDMap.get(item.getId()).getTotalReactivePowerMax());
+//            rMpHarmonicReportDVO.setTotalReactivePowerMin(RMpMeasureReportDMap.get(item.getId()).getTotalReactivePowerMin());
+//            rMpHarmonicReportDVO.setTotalReactivePowerAvg(RMpMeasureReportDMap.get(item.getId()).getTotalReactivePowerAvg());
+//            rMpHarmonicReportDVO.setTotalReactivePower95(RMpMeasureReportDMap.get(item.getId()).getTotalReactivePower95());
+//            //负序电压（三相电压）不平衡度
+//            rMpHarmonicReportDVO.setNegativeSequenceVoltageUnbalanceMax(RMpMeasureReportDMap.get(item.getId()).getNegativeSequenceVoltageUnbalanceMax());
+//            rMpHarmonicReportDVO.setNegativeSequenceVoltageUnbalanceMin(RMpMeasureReportDMap.get(item.getId()).getNegativeSequenceVoltageUnbalanceMin());
+//            rMpHarmonicReportDVO.setNegativeSequenceVoltageUnbalanceAvg(RMpMeasureReportDMap.get(item.getId()).getNegativeSequenceVoltageUnbalanceAvg());
+//            rMpHarmonicReportDVO.setNegativeSequenceVoltageUnbalance95(RMpMeasureReportDMap.get(item.getId()).getNegativeSequenceVoltageUnbalance95());
+            Double unb = Double.parseDouble(String.valueOf(overLimitMap.get(item.getId()).getUbalance())); //限值
+            Double unbalance95 = RMpMeasureReportDMap.get(item.getId()).getNegativeSequenceVoltageUnbalance95(); //负序电压不平衡度95值
+            rMpHarmonicReportDVO.setNegativeSequenceVoltageUnbalance95Result((unbalance95 > unb) ? "越限" : "正常"); //负序电压（三相电压）不平衡度-95值限值结论
+            Double unbalanceMax = RMpMeasureReportDMap.get(item.getId()).getNegativeSequenceVoltageUnbalanceMax();//负序电压不平衡度最大值
+            rMpHarmonicReportDVO.setNegativeSequenceVoltageUnbalanceMaxResult((unbalanceMax > unb) ? "越限" : "正常"); //负序电压（三相电压）不平衡度-95值限值结论
+
+//            //负序电流
+//            rMpHarmonicReportDVO.setNegativeSequenceCurrentMax(RMpMeasureReportDMap.get(item.getId()).getNegativeSequenceCurrentMax());
+//            rMpHarmonicReportDVO.setNegativeSequenceCurrentMin(RMpMeasureReportDMap.get(item.getId()).getNegativeSequenceCurrentMin());
+//            rMpHarmonicReportDVO.setNegativeSequenceCurrentAvg(RMpMeasureReportDMap.get(item.getId()).getNegativeSequenceCurrentAvg());
+//            rMpHarmonicReportDVO.setNegativeSequenceCurrent95(RMpMeasureReportDMap.get(item.getId()).getNegativeSequenceCurrent95());
+            Double iNeg = Double.parseDouble(String.valueOf(overLimitMap.get(item.getId()).getINeg()));//负序电流限值
+            Double current95 = RMpMeasureReportDMap.get(item.getId()).getNegativeSequenceCurrent95(); //负序电流95值
+            rMpHarmonicReportDVO.setNegativeSequenceCurrent95Result((current95 > iNeg) ? "越限" : "正常"); //负序电流-95值限值结论
+            Double currentMax = RMpMeasureReportDMap.get(item.getId()).getNegativeSequenceCurrentMax(); //负序电流值
+            rMpHarmonicReportDVO.setNegativeSequenceCurrentMaxResult((currentMax > iNeg) ? "越限" : "正常"); //负序电流最大值限值结论
+
+
+            /**********三相数据**********/
+            //r_mp_measure_phase_report_d
+            Map<String, RMpMeasurePhaseReportD> phaseReportDMap = RMpMeasurePhaseReportDList.stream().filter(phaseReportD -> phaseReportD.getMeasurementPointId().equals(item.getId()))
+                    .collect(Collectors.toMap(RMpMeasurePhaseReportD::getPhase, phaseReportD -> phaseReportD));
+            rMpHarmonicReportDVO.setPhaseReportD(phaseReportDMap);
+
+            //r_mp_harmonic_v_rate_report_d
+            Map<String, RMpHarmonicVRateReportD> vRateReportDMap = rMpHarmonicVRateReportDList.stream().filter(reportD -> reportD.getMeasurementPointId().equals(item.getId()))
+                    .collect(Collectors.toMap(RMpHarmonicVRateReportD::getPhase, reportD -> reportD));
+            rMpHarmonicReportDVO.setRMpHarmonicVRateReportDMap(vRateReportDMap);
+            //电压总谐波畸变率-95限值结论
+            Double uaberrance = Double.parseDouble(String.valueOf(overLimitMap.get(item.getId()).getUaberrance()));//电压总谐波畸变率限值
+            Map<String, String> wave95ResultMap = rMpHarmonicVRateReportDList.stream().filter(reportD -> reportD.getMeasurementPointId().equals(item.getId()))
+                    .collect(Collectors.toMap(RMpHarmonicVRateReportD::getPhase, reportD -> reportD.getVoltageHarmonicThd95() > uaberrance ? "越限" : "正常"));
+            rMpHarmonicReportDVO.setVoltageHarmonicWave95ResultMap(wave95ResultMap);
+
+            //r_mp_harmonic_i_mag_report_d
+            Map<String, RMpHarmonicIMagReportD> iMagReportDMap = rMpHarmonicIMagReportDList.stream().filter(reportD -> reportD.getMeasurementPointId().equals(item.getId()))
+                    .collect(Collectors.toMap(RMpHarmonicIMagReportD::getPhase, reportD -> reportD));
+            rMpHarmonicReportDVO.setRMpHarmonicIMagReportDMap(iMagReportDMap);
+
+            //r_mp_harmonic_i_rate_report_d
+            Map<String, RMpHarmonicIRateReportD> iRateReportDMap = rMpHarmonicIRateReportDList.stream().filter(reportD -> reportD.getMeasurementPointId().equals(item.getId()))
+                    .collect(Collectors.toMap(RMpHarmonicIRateReportD::getPhase, reportD -> reportD));
+            rMpHarmonicReportDVO.setRMpHarmonicIRateReportDMap(iRateReportDMap);
+
+            //r_mp_inharmonic_v_rate_report_d
+            Map<String, RMpInharmonicVRateReportD> rMpInharmonicVRateReportD = rMpInharmonicVRateReportDList.stream().filter(reportD -> reportD.getMeasurementPointId().equals(item.getId()))
+                    .collect(Collectors.toMap(RMpInharmonicVRateReportD::getPhase, reportD -> reportD));
+            rMpHarmonicReportDVO.setRMpInharmonicVRateReportDMap(rMpInharmonicVRateReportD);
+
+            //r_mp_inharmonic_i_rate_report_d
+            Map<String, RMpInharmonicIRateReportD> rMpInharmonicIRateReportD = rMpInharmonicIRateReportDList.stream().filter(reportD -> reportD.getMeasurementPointId().equals(item.getId()))
+                    .collect(Collectors.toMap(RMpInharmonicIRateReportD::getPhase, reportD -> reportD));
+            rMpHarmonicReportDVO.setRMpInharmonicIRateReportDMap(rMpInharmonicIRateReportD);
+
+            return rMpHarmonicReportDVO;
+        }).collect(Collectors.toList());
+        return RMpHarmonicReportDVOList;
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RMpHarmonicVRateReportDServiceImpl.java

@@ -0,0 +1,30 @@
+package com.njcn.harmonic.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.harmonic.pojo.po.RMpHarmonicVRateReportD;
+import com.njcn.harmonic.service.RMpHarmonicVRateReportDService;
+import com.njcn.harmonic.mapper.RMpHarmonicVRateReportDMapper;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+* @author jianghf
+* @description 针对表【r_mp_harmonic_v_rate_report_d(稳态监测点指标日报-日表(主配网表)  /各次谐波电压含有率 )】的数据库操作Service实现
+* @createDate 2022-10-20 18:34:05
+*/
+@Service
+public class RMpHarmonicVRateReportDServiceImpl extends ServiceImpl<RMpHarmonicVRateReportDMapper, RMpHarmonicVRateReportD>
+    implements RMpHarmonicVRateReportDService{
+
+    @Override
+    public List<RMpHarmonicVRateReportD> getListByCond(Map<String, Object> map) {
+        return this.baseMapper.getListByCond(map);
+    }
+}
+
+
+
+

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RMpInharmonicIRateReportDServiceImpl.java

@@ -0,0 +1,29 @@
+package com.njcn.harmonic.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.harmonic.pojo.po.RMpInharmonicIRateReportD;
+import com.njcn.harmonic.service.RMpInharmonicIRateReportDService;
+import com.njcn.harmonic.mapper.RMpInharmonicIRateReportDMapper;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+* @author Administrator
+* @description 针对表【r_mp_inharmonic_i_rate_report_d(稳态监测点指标日报-日表(主网表)  /各次间谐波电流含有率)】的数据库操作Service实现
+* @createDate 2022-10-20 18:45:58
+*/
+@Service
+public class RMpInharmonicIRateReportDServiceImpl extends ServiceImpl<RMpInharmonicIRateReportDMapper, RMpInharmonicIRateReportD>
+    implements RMpInharmonicIRateReportDService{
+
+    @Override
+    public List<RMpInharmonicIRateReportD> getListByCond(Map<String, Object> condMap) {
+        return this.baseMapper.getListByCond(condMap);
+    }
+}
+
+
+
+

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RMpInharmonicVRateReportDServiceImpl.java

@@ -0,0 +1,29 @@
+package com.njcn.harmonic.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.harmonic.pojo.po.RMpInharmonicVRateReportD;
+import com.njcn.harmonic.service.RMpInharmonicVRateReportDService;
+import com.njcn.harmonic.mapper.RMpInharmonicVRateReportDMapper;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+* @author Administrator
+* @description 针对表【r_mp_inharmonic_v_rate_report_d】的数据库操作Service实现
+* @createDate 2022-10-20 18:45:36
+*/
+@Service
+public class RMpInharmonicVRateReportDServiceImpl extends ServiceImpl<RMpInharmonicVRateReportDMapper, RMpInharmonicVRateReportD>
+    implements RMpInharmonicVRateReportDService{
+
+    @Override
+    public List<RMpInharmonicVRateReportD> getListByCond(Map<String, Object> condMap) {
+        return this.baseMapper.getListByCond(condMap);
+    }
+}
+
+
+
+

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RMpMeasurePhaseReportDServiceImpl.java

@@ -0,0 +1,29 @@
+package com.njcn.harmonic.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.harmonic.mapper.RMpMeasurePhaseReportDMapper;
+import com.njcn.harmonic.pojo.po.RMpMeasurePhaseReportD;
+import com.njcn.harmonic.service.RMpMeasurePhaseReportDService;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+* @author Administrator
+* @description 针对表【r_mp_measure_phase_report_d】的数据库操作Service实现
+* @createDate 2022-10-20 18:20:08
+*/
+@Service
+public class RMpMeasurePhaseReportDServiceImpl extends ServiceImpl<RMpMeasurePhaseReportDMapper, RMpMeasurePhaseReportD>
+    implements RMpMeasurePhaseReportDService{
+
+    @Override
+    public List<RMpMeasurePhaseReportD> getListByCond(Map<String, Object> condMap) {
+        return this.baseMapper.getListByCond(condMap);
+    }
+}
+
+
+
+

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RMpMeasureReportDServiceImpl.java

@@ -0,0 +1,25 @@
+package com.njcn.harmonic.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.harmonic.mapper.RMpMeasureReportDMapper;
+import com.njcn.harmonic.pojo.po.RMpMeasureReportD;
+import com.njcn.harmonic.service.RMpMeasureReportDService;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+* @author Administrator
+* @description 针对表【r_mp_measure_report_d】的数据库操作Service实现
+* @createDate 2022-10-20 16:32:37
+*/
+@Service
+public class RMpMeasureReportDServiceImpl extends ServiceImpl<RMpMeasureReportDMapper, RMpMeasureReportD>
+implements RMpMeasureReportDService{
+
+    @Override
+    public List<RMpMeasureReportD> getListByCond(Map<String, Object> condMap) {
+        return this.baseMapper.getListByCond(condMap);
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RMpPartHarmonicDetailDServiceImpl.java

@@ -0,0 +1,33 @@
+package com.njcn.harmonic.service.impl;
+
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.pojo.po.RMpPartHarmonicDetailD;
+import com.njcn.harmonic.mapper.RMpPartHarmonicDetailDMapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.harmonic.pojo.vo.RMpPartHarmonicDetailIconVO;
+import com.njcn.harmonic.service.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);
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RMpPartHarmonicDetailMServiceImpl.java

@@ -0,0 +1,106 @@
+package com.njcn.harmonic.service.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollectionUtil;
+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.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.RMpPartHarmonicDetailMMapper;
+import com.njcn.harmonic.pojo.vo.RMpPartHarmonicDetailVO;
+import com.njcn.harmonic.service.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;
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RMpPassRateServiceImpl.java

@@ -0,0 +1,131 @@
+package com.njcn.harmonic.service.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.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.RMpPassRateMMapper;
+import com.njcn.harmonic.mapper.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.RMpPassRateQMapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.harmonic.pojo.vo.RStatOrgIndexVO;
+import com.njcn.harmonic.service.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<>();
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RStatHarmonicMServiceImpl.java

@@ -0,0 +1,427 @@
+package com.njcn.harmonic.service.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.RStatHarmonicDMapper;
+import com.njcn.harmonic.mapper.RStatHarmonicMMapper;
+import com.njcn.harmonic.mapper.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.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) {
+                    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> getRStatHarmonicIcon(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> getRStatHarmonicIcon2(RStatHarmonicMParam param) {
+        //初始化对象
+        List<RHarmonicPolylineVO> iconList=new ArrayList<>();
+        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)
+                , "干扰源类型或者指标类型为空,请检查入参是否准确");
+
+        //获取主网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;
+    }
+
+    /**
+        * 根据用户选择的时间区间返回月份日期
+     */
+    @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;
+    }
+
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RStatHarmonicOrgMServiceImpl.java

@@ -0,0 +1,202 @@
+package com.njcn.harmonic.service.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.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 harmonicDate =null;
+        //判断是是否传入检测点信息值（电压）
+        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()));
+            harmonicDate =indicatorTypeDate.get(0);
+        }else{
+            //获取指标对象（频率偏差）
+            harmonicDate= dicDataFeignClient.getDicDataById(
+                    param.getStasisID()).getData();
+        }
+        //反防止参数查询数据报错
+        Assert.isTrue(
+                CollUtil.isNotEmpty(deptDTOList)||ObjectUtil.isNotNull(harmonicDate)
+                , "各单位或者指标类型为空,请检查入参是否准确");
+        //获取主网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, harmonicDate.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.setSort(data.getSort());
+                        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;
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RStatHarmonicOrgQServiceImpl.java

@@ -0,0 +1,194 @@
+package com.njcn.harmonic.service.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.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 harmonicDate =null;
+        //判断是是否传入检测点信息值（电压）
+        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()));
+            harmonicDate =indicatorTypeDate.get(0);
+        }else{
+            //获取指标对象（频率偏差）
+            harmonicDate= dicDataFeignClient.getDicDataById(
+                    param.getStasisID()).getData();
+        }
+        //反防止参数查询数据报错
+        Assert.isTrue(
+                CollUtil.isNotEmpty(deptDTOList)||ObjectUtil.isNotNull(harmonicDate)
+                , "各单位或者指标类型为空,请检查入参是否准确");
+        //获取主网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, harmonicDate.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.setSort(data.getSort());
+                        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;
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RStatHarmonicOrgYServiceImpl.java

@@ -0,0 +1,197 @@
+package com.njcn.harmonic.service.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.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 harmonicDate =null;
+        //判断是是否传入检测点信息值（电压）
+        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()));
+            harmonicDate =indicatorTypeDate.get(0);
+        }else{
+            //获取指标对象（频率偏差）
+            harmonicDate= dicDataFeignClient.getDicDataById(
+                    param.getStasisID()).getData();
+        }
+        //反防止参数查询数据报错
+        Assert.isTrue(
+                CollUtil.isNotEmpty(deptDTOList)||ObjectUtil.isNotNull(harmonicDate)
+                , "各单位或者指标类型为空,请检查入参是否准确");
+
+        //获取主网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, harmonicDate.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.setSort(data.getSort());
+                        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;
+    }
+
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RStatHarmonicQServiceImpl.java

@@ -0,0 +1,122 @@
+package com.njcn.harmonic.service.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+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.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.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) {
+                    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;
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RStatHarmonicYServiceImpl.java

@@ -0,0 +1,120 @@
+package com.njcn.harmonic.service.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+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.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.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) {
+                    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;
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RStatLoadTypeServiceImpl.java

@@ -0,0 +1,136 @@
+package com.njcn.harmonic.service.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.*;
+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.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;
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RStatOrgBusbarVoltageServiceImpl.java

@@ -0,0 +1,100 @@
+package com.njcn.harmonic.service.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+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.param.StatisticsBizBaseParam;
+import com.njcn.harmonic.mapper.RStatOrgBusbarVoltageQMapper;
+import com.njcn.harmonic.mapper.RStatOrgBusbarVoltageYMapper;
+import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatHarmonicOrgQ;
+import com.njcn.harmonic.pojo.po.RStatOrgBusbarVoltageM;
+import com.njcn.harmonic.mapper.RStatOrgBusbarVoltageMMapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.harmonic.pojo.po.RStatOrgBusbarVoltageQ;
+import com.njcn.harmonic.pojo.po.RStatOrgBusbarVoltageY;
+import com.njcn.harmonic.pojo.vo.RStatOrgBusbarVoltageVO;
+import com.njcn.harmonic.pojo.vo.RStatSubstationOrg2VO;
+import com.njcn.harmonic.pojo.vo.RStatSubstationOrgVO;
+import com.njcn.harmonic.service.RStatOrgBusbarVoltageService;
+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.List;
+import java.util.Map;
+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;
+
+    @Override
+    public List<RStatOrgBusbarVoltageVO> getRStatOrgBusbarVoltage(StatisticsBizBaseParam param) {
+        //获取部门信息
+        List<DeptDTO> data = deptFeignClient.getDeptDescendantIndexes(param.getId(), WebUtil.filterDeptType()).getData();
+        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)) {
+//            List<RStatOrgBusbarVoltageVO> temp = new ArrayList<>();
+            // 类型（1年 2季度 3月份
+            switch (param.getType().toString()) {
+                case BizParamConstant.STAT_BIZ_YEAR:
+                    // 获取年区域暂态指标分类统计表
+                    List<RStatOrgBusbarVoltageY> rStatOrgBusbarVoltageYS = rStatOrgBusbarVoltageYMapper.selectList(new LambdaQueryWrapper<RStatOrgBusbarVoltageY>()
+                            .in(RStatOrgBusbarVoltageY::getOrgNo, deptIds)
+                            .ge(StrUtil.isNotBlank(param.getStartTime()), RStatOrgBusbarVoltageY::getDataDate, param.getStartTime())
+                            .le(StrUtil.isNotBlank(param.getEndTime()), RStatOrgBusbarVoltageY::getDataDate, param.getEndTime()));
+                    temp=BeanUtil.copyToList(rStatOrgBusbarVoltageYS, RStatOrgBusbarVoltageVO.class);
+                    break;
+                case BizParamConstant.STAT_BIZ_QUARTER:
+                    // 获取季区域暂态指标分类统计表
+                    List<RStatOrgBusbarVoltageQ> rStatOrgBusbarVoltageQS = rStatOrgBusbarVoltageQMapper.selectList(new LambdaQueryWrapper<RStatOrgBusbarVoltageQ>()
+                            .in(RStatOrgBusbarVoltageQ::getOrgNo, deptIds)
+                            .ge(StrUtil.isNotBlank(param.getStartTime()), RStatOrgBusbarVoltageQ::getDataDate, param.getStartTime())
+                            .le(StrUtil.isNotBlank(param.getEndTime()), RStatOrgBusbarVoltageQ::getDataDate, param.getEndTime()));
+                    temp=BeanUtil.copyToList(rStatOrgBusbarVoltageQS, RStatOrgBusbarVoltageVO.class);
+                    break;
+                case BizParamConstant.STAT_BIZ_MONTH:
+                    // 获取月区域暂态指标分类统计表
+                    List<RStatOrgBusbarVoltageM> rStatOrgBusbarVoltageMS = rStatOrgBusbarVoltageMMapper.selectList(new LambdaQueryWrapper<RStatOrgBusbarVoltageM>()
+                            .in(RStatOrgBusbarVoltageM::getOrgNo, deptIds)
+                            .ge(StrUtil.isNotBlank(param.getStartTime()), RStatOrgBusbarVoltageM::getDataDate, param.getStartTime())
+                            .le(StrUtil.isNotBlank(param.getEndTime()), RStatOrgBusbarVoltageM::getDataDate, param.getEndTime()));
+                    temp=BeanUtil.copyToList(rStatOrgBusbarVoltageMS, RStatOrgBusbarVoltageVO.class);
+                    break;
+                default:
+                    break;
+
+            }
+
+//            Map<String, List<RStatSubstationOrgVO>> map = temp
+//                    .stream().collect(Collectors.groupingBy(RStatSubstationOrgVO::getOrgNo));
+        }
+        return temp;
+    }
+
+
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RStatOrgMServiceImpl.java

@@ -0,0 +1,87 @@
+package com.njcn.harmonic.service.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.RStatOrgMMapper;
+import com.njcn.harmonic.pojo.po.RStatOrgQ;
+import com.njcn.harmonic.pojo.vo.RStatOrgVO;
+import com.njcn.harmonic.service.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;
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RStatOrgQServiceImpl.java

@@ -0,0 +1,86 @@
+package com.njcn.harmonic.service.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.RStatOrgQMapper;
+import com.njcn.harmonic.pojo.vo.RStatOrgVO;
+import com.njcn.harmonic.service.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;
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RStatOrgYServiceImpl.java

@@ -0,0 +1,387 @@
+package com.njcn.harmonic.service.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.lang.Console;
+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.api.StatationStatClient;
+import com.njcn.device.pms.pojo.dto.PmsGeneralDeviceDTO;
+import com.njcn.device.pms.pojo.dto.PmsMonitorDTO;
+import com.njcn.device.pms.pojo.dto.PmsStatationStatInfoDTO;
+import com.njcn.device.pms.pojo.param.PmsDeviceInfoParam;
+import com.njcn.device.pms.pojo.param.PmsMonitorParam;
+import com.njcn.device.pms.pojo.param.PmsStatationStatInfoParam;
+import com.njcn.harmonic.mapper.*;
+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.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());
+                        //获取省级公司
+//                        value.setProvinceName(deptFeignClient.getAreaIdByDeptId());
+                    }
+                });
+            }
+          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;
+    }
+
+
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RStatSubstationMServiceImpl.java

@@ -0,0 +1,131 @@
+package com.njcn.harmonic.service.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.RStatSubstationQMapper;
+import com.njcn.harmonic.mapper.RStatSubstationYMapper;
+import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
+import com.njcn.harmonic.pojo.po.RStatSubstationM;
+import com.njcn.harmonic.mapper.RStatSubstationMMapper;
+import com.njcn.harmonic.pojo.vo.RSubstationIcon2VO;
+import com.njcn.harmonic.pojo.vo.RSubstationIconVO;
+import com.njcn.harmonic.service.RStatSubstationMService;
+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;
+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;
+    }
+}

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/RStatSubstationVoltageMServiceImpl.java

@@ -0,0 +1,56 @@
+package com.njcn.harmonic.service.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.RStatSubstationVoltageMMapper;
+import com.njcn.harmonic.pojo.vo.RVoltageIconVO;
+import com.njcn.harmonic.service.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;
+    }
+}