微调

- 在RateDTO初始化时设置bRMSFlag默认值为false，确保16~31点/周波段按普通抽点处理
- 修复RMS段与普通抽点的控制流程分离，避免共享取模条件导致的逻辑混乱
- 优化RMS段处理逻辑，添加周波索引推进机制防止重复处理
- 修复2点/周波时半周波位置的采样点切换逻辑
- 添加段末尾对齐机制，确保外层循环能稳定跳转到下一段起点
- 更新测试文件路径配置，使用新的测试数据文件

pqs-advance/advance-api/src/main/java/com/njcn/advance/pojo/dto/waveAnalysis/AnalyWave.java

@@ -26,8 +26,6 @@ import java.util.*;
 public class AnalyWave {
 
 
-
-
     /*****************************************
      * 解析comtrate文件工具类
      * author yexb根据Ww算法装换
@@ -94,7 +92,7 @@ public class AnalyWave {
      ** ** strFilePath *** cfg文件路径
      * *** auth *** 读取方式 null则使用本地读取方式读取
      ******************************************/
-    public AnalyWaveModel.tagDataValue readComtrade(List<String> temCfgList,byte[] array, int iFlag) {
+    public AnalyWaveModel.tagDataValue readComtrade(List<String> temCfgList, byte[] array, int iFlag) {
         //初始化参数
         ComtradeCfg = new AnalyWaveModel.tagComtradeCfg();
         RatesCfg = new AnalyWaveModel.tagRates();
@@ -163,148 +161,145 @@ public class AnalyWave {
         iterable.next();
         String[] strTempArray;// 读取cfg文件
         try {
-                nFreq = 0f;//WW 2019-11-14
-                String strFileLine = iterable.next();
+            nFreq = 0f;//WW 2019-11-14
+            String strFileLine = iterable.next();
+            strTempArray = strFileLine.split(",");
+
+            for (int i = 0; i < strTempArray.length; i++) {
+                switch (i) {
+                    case 0:// 总个数
+                        ComtradeCfg.nChannelNum = Integer.parseInt(strTempArray[i]);
+                        break;
+                    case 1:// 模拟量的个数
+                    {
+                        String str = strTempArray[i].substring(0, strTempArray[i].length() - 1);
+                        ComtradeCfg.nAnalogNum = Integer.parseInt(str);
+                    }
+                    break;
+                    case 2:// 开关量的个数
+                    {
+                        String str = strTempArray[i].substring(0, strTempArray[i].length() - 1);
+                        ComtradeCfg.nDigitalNum = Integer.parseInt(str);
+                    }
+                    break;
+                }
+            }
+
+            // 从第三行到第ComtradeCfg.nChannelNum+3行是模拟量通道和数字量通道
+            for (int i = 0; i < ComtradeCfg.nChannelNum; i++) {
+                AnalyWaveModel.tagOneChannleCfg OneChannlecfg = new AnalyWaveModel.tagOneChannleCfg();
+                ComtradeCfg.OneChannleCfg.add(OneChannlecfg);
+
+                strFileLine = iterable.next();
+                strTempArray = strFileLine.split(",");
+                // 配置总共13项
+                for (int j = 0; j < strTempArray.length; j++) {
+                    switch (j) {
+                        case 0:// 通道序号
+                            OneChannlecfg.nIndex = Integer.parseInt(strTempArray[j]);
+                            break;
+                        case 1:// 通道名称
+                            OneChannlecfg.szChannleName = strTempArray[j];
+                            break;
+                        case 2:// 相位名称
+                            OneChannlecfg.szPhasicName = strTempArray[j];
+                            break;
+                        case 3:// 监视的通道名称
+                            OneChannlecfg.szMonitoredChannleName = strTempArray[j];
+                            break;
+                        case 4:// 通道的单位
+                            OneChannlecfg.szUnitName = strTempArray[j];
+                            break;
+                        case 5:// 通道的系数
+                            OneChannlecfg.fCoefficent = Float.parseFloat(strTempArray[j]);
+                            break;
+                        case 6:// 通道的偏移量
+                            OneChannlecfg.fOffset = Float.parseFloat(strTempArray[j]);
+                            break;
+                        case 7:// 起始采样时间的偏移量
+                            OneChannlecfg.fTimeOffset = Float.parseFloat(strTempArray[j]);
+                            break;
+                        case 8:// 采样值的最小值
+                            OneChannlecfg.nMin = Integer.parseInt(strTempArray[j]);
+                            break;
+                        case 9:// 采样值的最大值
+                            OneChannlecfg.nMax = Integer.parseInt(strTempArray[j]);
+                            break;
+                        case 10:// 一次变比
+                            OneChannlecfg.fPrimary = Float.parseFloat(strTempArray[j]);
+                            break;
+                        case 11:// 二次变比
+                            OneChannlecfg.fSecondary = Float.parseFloat(strTempArray[j]);
+                            break;
+                        case 12:// 一次值还是二次值标志
+                            OneChannlecfg.szValueType = strTempArray[j];
+                            break;
+                    }
+                }
+            }
+            // 采样频率
+            strFileLine = iterable.next();
+            float fFreq = Float.parseFloat(strFileLine);
+            nFreq = (float) fFreq;//WW 2019-11-14
+            // 采样段数
+            strFileLine = iterable.next();
+            int nRates = Integer.parseInt(strFileLine);
+            RatesCfg.nRates = nRates;
+            // 获得每段的采样率
+            long nOffset = 0;
+            for (int i = 0; i < nRates; i++) {
+                strFileLine = iterable.next();
                 strTempArray = strFileLine.split(",");
 
-                for (int i = 0; i < strTempArray.length; i++) {
-                    switch (i) {
-                        case 0:// 总个数
-                            ComtradeCfg.nChannelNum = Integer.parseInt(strTempArray[i]);
+                AnalyWaveModel.tagOneRate OneRate = new AnalyWaveModel.tagOneRate();
+                RatesCfg.OneRate.add(OneRate);
+
+                for (int j = 0; j < strTempArray.length; j++) {
+
+                    switch (j) {
+                        case 0:// 单周波采样点数
+                            OneRate.nOneSample = (int) (Float.parseFloat(strTempArray[j]) / nFreq);//WW 2019-11-14
+                            break;
+                        case 1:// 总点数 //这里的strTemp是一个偏移量
+                            OneRate.nSampleNum = (long) (Float.parseFloat(strTempArray[j]) - nOffset);
+                            nOffset += OneRate.nSampleNum;
                             break;
-                        case 1:// 模拟量的个数
-                        {
-                            String str = strTempArray[i].substring(0, strTempArray[i].length() - 1);
-                            ComtradeCfg.nAnalogNum = Integer.parseInt(str);
-                        }
-                        break;
-                        case 2:// 开关量的个数
-                        {
-                            String str = strTempArray[i].substring(0, strTempArray[i].length() - 1);
-                            ComtradeCfg.nDigitalNum = Integer.parseInt(str);
-                        }
-                        break;
                     }
                 }
+            }
 
-                // 从第三行到第ComtradeCfg.nChannelNum+3行是模拟量通道和数字量通道
-                for (int i = 0; i < ComtradeCfg.nChannelNum; i++) {
-                    AnalyWaveModel.tagOneChannleCfg OneChannlecfg = new AnalyWaveModel.tagOneChannleCfg();
-                    ComtradeCfg.OneChannleCfg.add(OneChannlecfg);
-
-                    strFileLine = iterable.next();
-                    strTempArray = strFileLine.split(",");
-                    // 配置总共13项
-                    for (int j = 0; j < strTempArray.length; j++) {
-                        switch (j) {
-                            case 0:// 通道序号
-                                OneChannlecfg.nIndex = Integer.parseInt(strTempArray[j]);
-                                break;
-                            case 1:// 通道名称
-                                OneChannlecfg.szChannleName = strTempArray[j];
-                                break;
-                            case 2:// 相位名称
-                                OneChannlecfg.szPhasicName = strTempArray[j];
-                                break;
-                            case 3:// 监视的通道名称
-                                OneChannlecfg.szMonitoredChannleName = strTempArray[j];
-                                break;
-                            case 4:// 通道的单位
-                                OneChannlecfg.szUnitName = strTempArray[j];
-                                break;
-                            case 5:// 通道的系数
-                                OneChannlecfg.fCoefficent = Float.parseFloat(strTempArray[j]);
-                                break;
-                            case 6:// 通道的偏移量
-                                OneChannlecfg.fOffset = Float.parseFloat(strTempArray[j]);
-                                break;
-                            case 7:// 起始采样时间的偏移量
-                                OneChannlecfg.fTimeOffset = Float.parseFloat(strTempArray[j]);
-                                break;
-                            case 8:// 采样值的最小值
-                                OneChannlecfg.nMin = Integer.parseInt(strTempArray[j]);
-                                break;
-                            case 9:// 采样值的最大值
-                                OneChannlecfg.nMax = Integer.parseInt(strTempArray[j]);
-                                break;
-                            case 10:// 一次变比
-                                OneChannlecfg.fPrimary = Float.parseFloat(strTempArray[j]);
-                                break;
-                            case 11:// 二次变比
-                                OneChannlecfg.fSecondary = Float.parseFloat(strTempArray[j]);
-                                break;
-                            case 12:// 一次值还是二次值标志
-                                OneChannlecfg.szValueType = strTempArray[j];
-                                break;
-                        }
-                    }
-                }
-                // 采样频率
-                strFileLine = iterable.next();
-                float fFreq = Float.parseFloat(strFileLine);
-                nFreq = (float) fFreq;//WW 2019-11-14
-                // 采样段数
-                strFileLine = iterable.next();
-                int nRates = Integer.parseInt(strFileLine);
-                RatesCfg.nRates = nRates;
-                // 获得每段的采样率
-                long nOffset = 0;
-                for (int i = 0; i < nRates; i++) {
-                    strFileLine = iterable.next();
-                    strTempArray = strFileLine.split(",");
-
-                    AnalyWaveModel.tagOneRate OneRate = new AnalyWaveModel.tagOneRate();
-                    RatesCfg.OneRate.add(OneRate);
-
-                    for (int j = 0; j < strTempArray.length; j++) {
-
-                        switch (j) {
-                            case 0:// 单周波采样点数
-                                OneRate.nOneSample = (int) (Float.parseFloat(strTempArray[j]) / nFreq);//WW 2019-11-14
-                                break;
-                            case 1:// 总点数 //这里的strTemp是一个偏移量
-                                OneRate.nSampleNum = (long) (Float.parseFloat(strTempArray[j]) - nOffset);
-                                nOffset += OneRate.nSampleNum;
-                                break;
-                        }
-                    }
-                }
-
-                SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss.SSS");
-                // 波形起始时间
-                strFileLine = iterable.next();
-                strFileLine = strFileLine.substring(0, strFileLine.length() - 3).replace(",", " ");
-                TimeTrige = sdf.parse(strFileLine);
-                // 暂态触发时间
-                strFileLine = iterable.next();
-                strFileLine = strFileLine.substring(0, strFileLine.length() - 3).replace(",", " ");
-                TimeWave = sdf.parse(strFileLine);
-
-                Calendar calendar = Calendar.getInstance();
-                calendar.setTime(TimeWave);
-                firstMs = calendar.get(Calendar.MILLISECOND);
-                firstTime = calendar.getTime();
-
-                long a = TimeWave.getTime();
-                long b = TimeTrige.getTime();
-                int c = (int) (a - b);
-                if (c >= 90 && c <= 110) {
-                    iPush = 100;
-                } else if (c >= 190 && c <= 210) {
-                    iPush = 200;
-                }
-                // 赋值编码格式（二进制）
-                strBinType = iterable.next().toUpperCase();
+            SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss.SSS");
+            // 波形起始时间
+            strFileLine = iterable.next();
+            strFileLine = strFileLine.substring(0, strFileLine.length() - 3).replace(",", " ");
+            TimeTrige = sdf.parse(strFileLine);
+            // 暂态触发时间
+            strFileLine = iterable.next();
+            strFileLine = strFileLine.substring(0, strFileLine.length() - 3).replace(",", " ");
+            TimeWave = sdf.parse(strFileLine);
 
+            Calendar calendar = Calendar.getInstance();
+            calendar.setTime(TimeWave);
+            firstMs = calendar.get(Calendar.MILLISECOND);
+            firstTime = calendar.getTime();
 
+            long a = TimeWave.getTime();
+            long b = TimeTrige.getTime();
+            int c = (int) (a - b);
+            if (c >= 90 && c <= 110) {
+                iPush = 100;
+            } else if (c >= 190 && c <= 210) {
+                iPush = 200;
+            }
+            // 赋值编码格式（二进制）
+            strBinType = iterable.next().toUpperCase();
 
 
         } catch (Exception e) {
             e.printStackTrace();
-            logger.error("读取文件内容出错"+e.getMessage());
+            logger.error("读取文件内容出错" + e.getMessage());
             return false;
-        }finally {
-
+        } finally {
 
 
         }
@@ -319,15 +314,8 @@ public class AnalyWave {
     private List<List<Float>> AnalyseComtradeDat(byte[] array, int iFlag) {
         float xValueAll = 0;//初始化xValue的值
         boolean blxValue = false;//判断是否首次登陆
-
         List<List<Float>> listWaveData = new ArrayList<>();//返回数据
-
-
         try {
-
-
-
-
             // 计算每个单独的数据块的大小 4字节的序号 4字节的时间 2字节的值
             // 示例中的排布是 4字节的序号 4字节的时间 UA(2字节) UB(2字节) UC(2字节) IA(2字节) IB(2字节)
             // IC(2字节)
@@ -470,7 +458,7 @@ public class AnalyWave {
                             {
                                 if (ComtradeCfg.OneChannleCfg.get(j).fPrimary != 0.0f)//根据cfg内的变比，将一次值转换成二次值
                                 {
-                                    fValue = ComtradeCfg.OneChannleCfg.get(j).fSecondary / ComtradeCfg.OneChannleCfg.get(j).fPrimary;
+                                    fValue = fValue * ComtradeCfg.OneChannleCfg.get(j).fSecondary / ComtradeCfg.OneChannleCfg.get(j).fPrimary;
                                 } else {
                                     fValue = fValue;
                                 }
@@ -500,7 +488,7 @@ public class AnalyWave {
         } catch (Exception e) {
             logger.error("读取文件出错：" + e.getMessage());
             return listWaveData;
-        }finally {
+        } finally {
 
         }
 

pqs-advance/advance-boot/src/main/java/com/njcn/advance/service/impl/EventWaveAnalysisServiceImpl.java

@@ -223,6 +223,10 @@ public class EventWaveAnalysisServiceImpl implements EventWaveAnalysisService {
         RmpEventDetailPO rmpEventDetailPO = rmpEventAdvanceMapper.selectById(eventIndex);
         EntityAdvancedData entityAdvancedData;
 
+        if (Objects.isNull(rmpEventDetailPO.getFileFlag())) {
+            throw new BusinessException("系统检测到波形文件未从装置招到本地,请联系管理员");
+        }
+
         if (rmpEventDetailPO.getFileFlag() == 1) {
             //获取所有暂态原因
             List<DictData> dicDataList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.EVENT_TYPE.getCode()).getData();

pqs-common/common-core/pom.xml

@@ -97,11 +97,11 @@
             <groupId>com.fasterxml.jackson.datatype</groupId>
             <artifactId>jackson-datatype-jsr310</artifactId>
         </dependency>
-        <!--mqtt相关依赖-->
-        <dependency>
-            <groupId>com.github.tocrhz</groupId>
-            <artifactId>mqtt-spring-boot-starter</artifactId>
-        </dependency>
+<!--        &lt;!&ndash;mqtt相关依赖&ndash;&gt;-->
+<!--        <dependency>-->
+<!--            <groupId>com.github.tocrhz</groupId>-->
+<!--            <artifactId>mqtt-spring-boot-starter</artifactId>-->
+<!--        </dependency>-->
 
 <!--        <dependency>-->
 <!--            <groupId>org.springframework.boot</groupId>-->

pqs-common/common-core/src/main/java/com/njcn/common/utils/PubUtils.java

@@ -15,6 +15,7 @@ import com.njcn.common.pojo.exception.BusinessException;
 import lombok.Data;
 
 import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
 import java.math.BigDecimal;
@@ -32,6 +33,7 @@ import java.util.*;
 import java.util.concurrent.TimeUnit;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 import static java.lang.Integer.parseInt;
 
@@ -281,6 +283,30 @@ public class PubUtils {
         }
     }
 
+    /**
+     * 用于获取对象中，前缀一样，后缀为2~50的属性值
+     *
+     * @param methodPrefix 方法前缀
+     * @param number       方法后缀
+     * @return 对象属性值
+     */
+    public static Double getValueByMethodDouble(List data ,Class clazz, String methodPrefix, Integer number) {
+        try {
+            Method method = clazz.getMethod(methodPrefix + number);
+            OptionalDouble average = data.stream().mapToDouble(temp -> {
+                try {
+                    return (Double) method.invoke(temp);
+                } catch (Exception e) {
+                    throw new BusinessException(CommonResponseEnum.REFLECT_METHOD_EXCEPTION);
+                }
+            }).average();
+            return average.orElse(0.0);
+
+        } catch (Exception e) {
+            throw new BusinessException(CommonResponseEnum.REFLECT_METHOD_EXCEPTION);
+        }
+    }
+
 
     public static List<String> getStartTimeEndTime(String beginDate, String endDate) throws Exception {
 

pqs-common/common-echarts/src/main/java/com/njcn/echarts/util/DrawPicUtil.java

@@ -57,8 +57,8 @@ public class DrawPicUtil {
 
 
     /***
-     * 绘制波形图
      * @author hongawen
+     * 绘制波形图
      * @date 2023/6/21 11:01
      * @return String base64数据
      */

pqs-common/common-event/src/main/java/com/njcn/event/file/component/WaveFileComponent.java

@@ -3,11 +3,9 @@ package com.njcn.event.file.component;
 import cn.hutool.core.date.DatePattern;
 import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.io.IoUtil;
-import cn.hutool.core.text.StrPool;
 import cn.hutool.core.util.ArrayUtil;
 import cn.hutool.core.util.CharsetUtil;
 import cn.hutool.core.util.StrUtil;
-import com.njcn.common.pojo.enums.response.CommonResponseEnum;
 import com.njcn.common.pojo.exception.BusinessException;
 import com.njcn.common.utils.wave.BitConverter;
 import com.njcn.event.file.pojo.dto.*;
@@ -511,13 +509,14 @@ public class WaveFileComponent {
                 //抽点后新的的采样率
                 List<RateDTO> newLstRate = new ArrayList<>();
                 for (int iRate = 0; iRate < comtradeCfgDTO.getNRates(); iRate++) {
-//                    if (comtradeCfgDTO.getLstRate().get(iRate).getNOneSample() >= 32) {
                     // 计算本段录波总共有多少波形
                     nWaveNum = comtradeCfgDTO.getLstRate().get(iRate).getNSampleNum() / comtradeCfgDTO.getLstRate().get(iRate).getNOneSample();
                     //设置总波形大小
                     comtradeCfgDTO.setNAllWaveNum(comtradeCfgDTO.getNAllWaveNum() + nWaveNum);
                     // 将最低采样率替换到本段录波内
                     RateDTO tmpRateDTO = new RateDTO();
+                    // C# 原实现中 bool 默认是 false，16~31 点/周波段也应按普通抽点处理
+                    tmpRateDTO.bRMSFlag = false;
                     // 有效值标志,如果是有效值，那么就需要反向补点，而不是抽点
                     if (comtradeCfgDTO.getLstRate().get(iRate).getNOneSample() >= 32) {
                         //YXB 2025-08-27
@@ -547,12 +546,7 @@ public class WaveFileComponent {
                         newLstRate.get(nnInd).setNSampleNum(comtradeCfgDTO.getLstRate().get(iRate).getNOneSample() * nWaveNum);
                     }
 
-                    // 正常的配置中采样率
-                   /* comtradeCfgDTO.getLstRate().get(nnInd).setNOneSample(comtradeCfgDTO.getLstRate().get(iRate).getNOneSample());
-                    comtradeCfgDTO.getLstRate().get(nnInd).setNSampleNum(comtradeCfgDTO.getLstRate().get(iRate).getNSampleNum());*/
-
                     nnInd++;
-//                    }
                 }
                 // 偏移量,采样间隔
                 long nOffSet = 0, nWaveSpan;
@@ -560,7 +554,6 @@ public class WaveFileComponent {
                 float fValue, dfValue;
                 // 计算不同块的采样率
                 int nIndex = 0;
-                // 将最低采样率替换到本段录波内
                 // .CFG中采样率
                 RateDTO tmpRateDTO;
                 // nBlockNum 总循环次数
@@ -575,197 +568,192 @@ public class WaveFileComponent {
                         }
                     }
                     tmpRateDTO = comtradeCfgDTO.getLstRate().get(nIndex);
-                    //YXB 2025-08-27 如果是有效值，那么需要去补点，而不是抽点
-                    if (newLstRate.get(nIndex).bRMSFlag == true) {
+                    dfValue = (float) 20 / tmpRateDTO.getNOneSample();
+                    // C# 原实现中 RMS 段与普通抽点是两条独立控制流，不能挂在同一个取模条件下
+                    if (Boolean.TRUE.equals(newLstRate.get(nIndex).bRMSFlag)) {
                         //计算本段补点采样间隔
                         nWaveSpan = newLstRate.get(nIndex).getNOneSample() / tmpRateDTO.getNOneSample();
-                    } else {
-                        // 计算本段抽点采样间隔
-                        nWaveSpan = tmpRateDTO.getNOneSample() / newLstRate.get(nIndex).getNOneSample();
+                        // 计算有多少个周波
+                        long allWaveTemp = newLstRate.get(nIndex).getNSampleNum() / newLstRate.get(nIndex).getNOneSample();
+                        // 本段需要补多少点
+                        long allempSample = newLstRate.get(nIndex).getNOneSample();
+                        int segmentEndIndex = (int) (nOffSet + tmpRateDTO.getNSampleNum() - 1);
+                        for (int iWaveTemp = 0; iWaveTemp < allWaveTemp; iWaveTemp++) {
+                            for (int mTempSample = 0; mTempSample < allempSample; mTempSample++) {
+                                // 2 点/周波时，半周波位置需要切换到该周波的第二个原始采样点
+                                if (mTempSample / nWaveSpan == 1 && mTempSample % nWaveSpan == 0) {
+                                    i++;
+                                }
+                                //存储局部数据集合，包含了时间，A，B，C三相
+                                List<Float> tmpWaveData = new ArrayList<>();
+                                for (int j = 0; j < comtradeCfgDTO.getNAnalogNum(); j++) {
+                                    if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzPhasicName().equalsIgnoreCase("N")) {
+                                        break;
+                                    }
+                                    float fCoef = comtradeCfgDTO.getLstAnalogDTO().get(j).getFCoefficent();
+                                    fValue = BitConverter.byte2ToUnsignedShort(datArray, i * nBlockSize + 2 * 4 + j * 2) * fCoef;
+                                    //WW 2019-11-14
+                                    /*************************
+                                     * 1、接口返回的默认是二次值
+                                     * 2、P是一次值 S是二次值
+                                     * 3、S(二次值）情况下：
+                                     *     ①、单位为"V"时候则直接等于；
+                                     *     ②、单位为"kV"时候需要乘以1000
+                                     * 4、P(一次值）情况下：
+                                     *     ①、单位为"V"时候则直接等于；
+                                     *     ②、单位为"kV"时候需要乘以1000
+                                     *************************/
+                                    //P是一次值 S是二次值
+                                    if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzValueType().equalsIgnoreCase("S")) {
+                                        //判断单位是V还是kV
+                                        if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("KV")) {
+                                            fValue = fValue * 1000.0f;
+                                        } else {
+                                            fValue = fValue;
+                                        }
+                                    }
+                                    //P是一次值 S是二次值
+                                    else if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzValueType().equalsIgnoreCase("P")) {
+                                        //判断单位是V还是kV
+                                        if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("V")) {
+                                            //根据cfg内的变比，将一次值转换成二次值
+                                            if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
+                                                fValue = fValue * comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
+                                            } else {
+                                                fValue = fValue;
+                                            }
+                                        }
+                                        //判断单位是V还是kV
+                                        else if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("KV")) {
+                                            //根据cfg内的变比，将一次值转换成二次值
+                                            if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
+                                                fValue = fValue * 1000.0f * comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
+                                            } else {
+                                                fValue = fValue;
+                                            }
+                                        } else //还有可能是  电流，单位是A
+                                        {
+                                            //根据cfg内的变比，将一次值转换成二次值
+                                            if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
+                                                fValue = fValue * comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
+                                            } else {
+                                                fValue = fValue;
+                                            }
+                                        }
+                                    }
+
+                                    //xValue前移量，假如是第一次时候则需要前移
+                                    if (!blxValue && j == 0) {
+                                        xValueAll = (float) (i * 20) / tmpRateDTO.getNOneSample() - comtradeCfgDTO.getNPush();
+                                        blxValue = true;
+                                        //只增加一个xValue的值 //增加时间值
+                                        tmpWaveData.add((float) (Math.round(xValueAll * 100)) / 100);
+                                    } else if (j == 0) {
+                                        xValueAll += (float) dfValue / nWaveSpan;
+                                        //只增加一个xValue的值 //增加时间值
+                                        tmpWaveData.add((float) (Math.round(xValueAll * 100)) / 100);
+                                    }
+
+                                    //不同通道yValue的值都需要增加，最终成ABC三相 //每个通道的值
+                                    tmpWaveData.add((float) (Math.round(fValue * 100)) / 100);
+                                }
+                                //把每个单独的值赋予到整体里面去
+                                listWaveData.add(tmpWaveData);
+                            }
+                            // 本周波处理完成后，推进到下一周波的原始采样点
+                            if (iWaveTemp < (allWaveTemp - 1)) {
+                                i++;
+                            }
+                        }
+                        // 某些文件的段点数并不是原始每周波点数的整倍数。
+                        // RMS 段处理完成后，强制把原始游标对齐到当前段末尾，
+                        // 这样外层 for 的下一次自增才能稳定落到下一段起点，避免重复进入同一 RMS 段。
+                        i = segmentEndIndex;
+                        continue;
                     }
 
-                    dfValue = (float) 20 / tmpRateDTO.getNOneSample();
+                    // 计算本段抽点采样间隔
+                    nWaveSpan = tmpRateDTO.getNOneSample() / newLstRate.get(nIndex).getNOneSample();
                     // 判断是否到了需要抽的采样点
                     if (i % nWaveSpan == 0) {
                         // 计算每个通道的值
                         //存储局部数据集合，包含了时间，A，B，C三相
                         List<Float> tmpWaveData = new ArrayList<>();
-                        //YXB 2025-08-27 如果是有效值，那么需要去补点，而不是抽点
-                        if (newLstRate.get(nIndex).bRMSFlag == true) {
-                            // 计算有多少个周波
-                            long allWaveTemp = newLstRate.get(nIndex).getNSampleNum() / newLstRate.get(nIndex).getNOneSample();
-                            // 本段需要补多少点
-                            long allempSample = newLstRate.get(nIndex).getNOneSample();
-                            //int iStartWaveTemp = i ;// 开始补点的起点
-                            for (int iWaveTemp = 0; iWaveTemp < allWaveTemp; iWaveTemp++) {
-                                for (int mTempSample = 0; mTempSample < allempSample; mTempSample++) {
-                                    //最多只有半波有效值，也就是每周波是1个或者2个点，然后去补最少16个点
-                                    if (mTempSample / nWaveSpan == 1 && mTempSample % nWaveSpan == 0) {
-                                        i++;
-                                    }
-                                    //存储局部数据集合，包含了时间，A，B，C三相
-                                    tmpWaveData = new ArrayList<>();
-                                    for (int j = 0; j < comtradeCfgDTO.getNAnalogNum(); j++) {
-                                        //数据只有电压ABC三相数据，不展示U0、I0等数据 YXB2020-10-09 去除相别为N相的数据
-                                        if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzPhasicName().equalsIgnoreCase("N")) {
-                                            break;
-                                        }
-                                        float fCoef = comtradeCfgDTO.getLstAnalogDTO().get(j).getFCoefficent();
+                        for (int j = 0; j < comtradeCfgDTO.getNAnalogNum(); j++) {
+                            //数据只有电压ABC三相数据，不展示U0、I0等数据 YXB2020-10-09 去除相别为N相的数据
+                            if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzPhasicName().equalsIgnoreCase("N")) {
+                                break;
+                            }
 
-                                        if((i * nBlockSize + 2 * 4 + j * 2) == 2437568){
-                                            System.out.println(55);
-                                        }
-                                        fValue = BitConverter.byte2ToUnsignedShort(datArray, i * nBlockSize + 2 * 4 + j * 2) * fCoef;
-                                        //WW 2019-11-14
-                                        /*************************
-                                         * 1、接口返回的默认是二次值
-                                         * 2、P是一次值 S是二次值
-                                         * 3、S(二次值）情况下：
-                                         *     ①、单位为"V"时候则直接等于；
-                                         *     ②、单位为"kV"时候需要乘以1000
-                                         * 4、P(一次值）情况下：
-                                         *     ①、单位为"V"时候则直接等于；
-                                         *     ②、单位为"kV"时候需要乘以1000
-                                         *************************/
-                                        //P是一次值 S是二次值
-                                        if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzValueType().equalsIgnoreCase("S")) {
-                                            //判断单位是V还是kV
-                                            if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("KV")) {
-                                                fValue = fValue * 1000.0f;
-                                            } else {
-                                                fValue = fValue;
-                                            }
-                                        }
-                                        //P是一次值 S是二次值
-                                        else if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzValueType().equalsIgnoreCase("P")) {
-                                            //判断单位是V还是kV
-                                            if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("V")) {
-                                                //根据cfg内的变比，将一次值转换成二次值
-                                                if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
-                                                    fValue = fValue * comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
-                                                } else {
-                                                    fValue = fValue;
-                                                }
-                                            }
-                                            //判断单位是V还是kV
-                                            else if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("KV")) {
-                                                //根据cfg内的变比，将一次值转换成二次值
-                                                if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
-                                                    fValue = fValue * 1000.0f * comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
-                                                } else {
-                                                    fValue = fValue;
-                                                }
-                                            } else //还有可能是  电流，单位是A
-                                            {
-                                                //根据cfg内的变比，将一次值转换成二次值
-                                                if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
-                                                    fValue = comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
-                                                } else {
-                                                    fValue = fValue;
-                                                }
-                                            }
-                                        }
+                            float fCoef = comtradeCfgDTO.getLstAnalogDTO().get(j).getFCoefficent();
+                            fValue = BitConverter.byte2ToUnsignedShort(datArray, i * nBlockSize + 2 * 4 + j * 2) * fCoef;
 
-                                        //xValue前移量，假如是第一次时候则需要前移
-                                        if (!blxValue && j == 0) {
-                                            xValueAll = (float) (i * 20) / tmpRateDTO.getNOneSample() - comtradeCfgDTO.getNPush();
-                                            blxValue = true;
-                                            //只增加一个xValue的值 //增加时间值
-                                            tmpWaveData.add((float) (Math.round(xValueAll * 100)) / 100);
-                                        } else if (j == 0) {
-                                            xValueAll += (float) dfValue / nWaveSpan;
-                                            //只增加一个xValue的值 //增加时间值
-                                            tmpWaveData.add((float) (Math.round(xValueAll * 100)) / 100);
-                                        }
-
-                                        //不同通道yValue的值都需要增加，最终成ABC三相 //每个通道的值
-                                        tmpWaveData.add((float) (Math.round(fValue * 100)) / 100);
-                                    }
-                                    //把每个单独的值赋予到整体里面去
-                                    listWaveData.add(tmpWaveData);
-                                }
-                                // 把每个单独的值赋予到整体里面去
-                                if (iWaveTemp < (allWaveTemp - 1)) {
-                                    i++;
+                            //WW 2019-11-14
+                            /**************************
+                             * 1、接口返回的默认是二次值
+                             * 2、P是一次值 S是二次值
+                             * 3、S(二次值）情况下：
+                             *     ①、单位为"V"时候则直接等于；
+                             *     ②、单位为"kV"时候需要乘以1000
+                             * 4、P(一次值）情况下：
+                             *     ①、单位为"V"时候则直接等于；
+                             *     ②、单位为"kV"时候需要乘以1000
+                             **************************/
+                            //P是一次值 S是二次值
+                            if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzValueType().equalsIgnoreCase("S")) {
+                                //判断单位是V还是kV
+                                if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("KV")) {
+                                    fValue = fValue * 1000.0f;
+                                } else {
+                                    fValue = fValue;
                                 }
                             }
-                        } else {
-                            for (int j = 0; j < comtradeCfgDTO.getNAnalogNum(); j++) {
-                                //数据只有电压ABC三相数据，不展示U0、I0等数据 YXB2020-10-09 去除相别为N相的数据
-                                if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzPhasicName().equalsIgnoreCase("N")) {
-                                    break;
-                                }
-
-                                float fCoef = comtradeCfgDTO.getLstAnalogDTO().get(j).getFCoefficent();
-                                fValue = BitConverter.byte2ToUnsignedShort(datArray, i * nBlockSize + 2 * 4 + j * 2) * fCoef;
-
-                                //WW 2019-11-14
-                                /**************************
-                                 * 1、接口返回的默认是二次值
-                                 * 2、P是一次值 S是二次值
-                                 * 3、S(二次值）情况下：
-                                 *     ①、单位为"V"时候则直接等于；
-                                 *     ②、单位为"kV"时候需要乘以1000
-                                 * 4、P(一次值）情况下：
-                                 *     ①、单位为"V"时候则直接等于；
-                                 *     ②、单位为"kV"时候需要乘以1000
-                                 **************************/
-                                //P是一次值 S是二次值
-                                if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzValueType().equalsIgnoreCase("S")) {
-                                    //判断单位是V还是kV
-                                    if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("KV")) {
-                                        fValue = fValue * 1000.0f;
+                            //P是一次值 S是二次值
+                            else if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzValueType().equalsIgnoreCase("P")) {
+                                //判断单位是V还是kV
+                                if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("V")) {
+                                    //根据cfg内的变比，将一次值转换成二次值
+                                    if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
+                                        fValue = fValue * comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
                                     } else {
                                         fValue = fValue;
                                     }
                                 }
-                                //P是一次值 S是二次值
-                                else if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzValueType().equalsIgnoreCase("P")) {
-                                    //判断单位是V还是kV
-                                    if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("V")) {
-                                        //根据cfg内的变比，将一次值转换成二次值
-                                        if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
-                                            fValue = fValue * comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
-                                        } else {
-                                            fValue = fValue;
-                                        }
+                                //判断单位是V还是kV
+                                else if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("KV")) {
+                                    //根据cfg内的变比，将一次值转换成二次值
+                                    if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
+                                        fValue = fValue * 1000.0f * comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
+                                    } else {
+                                        fValue = fValue;
                                     }
-                                    //判断单位是V还是kV
-                                    else if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("KV")) {
-                                        //根据cfg内的变比，将一次值转换成二次值
-                                        if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
-                                            fValue = fValue * 1000.0f * comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
-                                        } else {
-                                            fValue = fValue;
-                                        }
-                                    } else //还有可能是  电流，单位是A
-                                    {
-                                        //根据cfg内的变比，将一次值转换成二次值
-                                        if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
-                                            fValue = comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
-                                        } else {
-                                            fValue = fValue;
-                                        }
+                                } else //还有可能是  电流，单位是A
+                                {
+                                    //根据cfg内的变比，将一次值转换成二次值
+                                    if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
+                                        fValue = fValue * comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
+                                    } else {
+                                        fValue = fValue;
                                     }
                                 }
-                                //xValue前移量，假如是第一次时候则需要前移
-                                if (!blxValue && j == 0) {
-                                    xValueAll = (float) (i * 20) / tmpRateDTO.getNOneSample() - comtradeCfgDTO.getNPush();
-                                    blxValue = true;
-                                    //只增加一个xValue的值 //增加时间值
-                                    tmpWaveData.add((float) (Math.round(xValueAll * 100)) / 100);
-                                } else if (j == 0) {
-                                    xValueAll += (float) nWaveSpan * dfValue;
-                                    //只增加一个xValue的值 //增加时间值
-                                    tmpWaveData.add((float) (Math.round(xValueAll * 100)) / 100);
-                                }
-
-                                //不同通道yValue的值都需要增加，最终成ABC三相 //每个通道的值
-                                tmpWaveData.add((float) (Math.round(fValue * 100)) / 100);
                             }
-                            //把每个单独的值赋予到整体里面去
-                            listWaveData.add(tmpWaveData);
+                            //xValue前移量，假如是第一次时候则需要前移
+                            if (!blxValue && j == 0) {
+                                xValueAll = (float) (i * 20) / tmpRateDTO.getNOneSample() - comtradeCfgDTO.getNPush();
+                                blxValue = true;
+                                //只增加一个xValue的值 //增加时间值
+                                tmpWaveData.add((float) (Math.round(xValueAll * 100)) / 100);
+                            } else if (j == 0) {
+                                xValueAll += (float) nWaveSpan * dfValue;
+                                //只增加一个xValue的值 //增加时间值
+                                tmpWaveData.add((float) (Math.round(xValueAll * 100)) / 100);
+                            }
+
+                            //不同通道yValue的值都需要增加，最终成ABC三相 //每个通道的值
+                            tmpWaveData.add((float) (Math.round(fValue * 100)) / 100);
                         }
+                        //把每个单独的值赋予到整体里面去
+                        listWaveData.add(tmpWaveData);
                     }
                 }
             }
@@ -777,6 +765,304 @@ public class WaveFileComponent {
         return listWaveData;
     }
 
+//    private List<List<Float>> getComtradeDat(ComtradeCfgDTO comtradeCfgDTO, InputStream datStream, int iType) {
+//        //返回数据，如果仅仅做展示后期考虑换String类型，降低内存开销
+//        List<List<Float>> listWaveData = new ArrayList<>();
+//        //初始化xValue的值
+//        float xValueAll = 0;
+//        //判断是否首次登陆
+//        boolean blxValue = false;
+//        byte[] datArray;
+//        try {
+//            datArray = IoUtil.readBytes(datStream);
+//            if (ArrayUtil.isEmpty(datArray)) {
+//                throw new BusinessException(WaveFileResponseEnum.DAT_DATA_ERROR);
+//            }
+//            // 计算每个单独的数据块的大小 4个字节的序号 4个字节的时间 2个字节的值
+//            // 示例中的排布是 4个字节的序号 4个字节的时间 UA(2字节) UB(2字节) UC(2字节) IA(2字节) IB(2字节) IC(2字节)
+//            int nDigSize = (comtradeCfgDTO.getNDigitalNum() % 16) > 0 ? (comtradeCfgDTO.getNDigitalNum() / 16 + 1) * 2 : comtradeCfgDTO.getNDigitalNum() / 16 * 2;
+//            int nBlockSize = 2 * Integer.SIZE / 8 + comtradeCfgDTO.getNAnalogNum() * 2 + nDigSize;
+//            // 总长度除以每个块的大小
+//            int nBlockNum = (int)Math.floor(datArray.length / nBlockSize);
+//
+//            // 获取采样率
+//            int finalSampleRate = getFinalWaveSample(comtradeCfgDTO.getLstRate(), iType);
+//            if (finalSampleRate != -1) {
+//                //设置最终采样率
+//                comtradeCfgDTO.setFinalSampleRate(finalSampleRate);
+//                // 计算转换后的采样率
+//                int nnInd = 0;
+//                // 抽点后总共多少点数据
+//                int nWaveNum;
+//                //抽点后新的的采样率
+//                List<RateDTO> newLstRate = new ArrayList<>();
+//                for (int iRate = 0; iRate < comtradeCfgDTO.getNRates(); iRate++) {
+////                    if (comtradeCfgDTO.getLstRate().get(iRate).getNOneSample() >= 32) {
+//                    // 计算本段录波总共有多少波形
+//                    nWaveNum = comtradeCfgDTO.getLstRate().get(iRate).getNSampleNum() / comtradeCfgDTO.getLstRate().get(iRate).getNOneSample();
+//                    //设置总波形大小
+//                    comtradeCfgDTO.setNAllWaveNum(comtradeCfgDTO.getNAllWaveNum() + nWaveNum);
+//                    // 将最低采样率替换到本段录波内
+//                    RateDTO tmpRateDTO = new RateDTO();
+//                    // 有效值标志,如果是有效值，那么就需要反向补点，而不是抽点
+//                    if (comtradeCfgDTO.getLstRate().get(iRate).getNOneSample() >= 32) {
+//                        //YXB 2025-08-27
+//                        tmpRateDTO.bRMSFlag = false;
+//                    }
+//                    //如果采样是全波有效值或者半波有效值，需要去补足周波点数 YXB 2025-08-27
+//                    else if (comtradeCfgDTO.getLstRate().get(iRate).getNOneSample() <= 2) {
+//                        //YXB 2025-08-27
+//                        tmpRateDTO.bRMSFlag = true;
+//                    }
+//                    newLstRate.add(tmpRateDTO);
+//                    //iFlag =3 一定不进行抽点算法
+//                    if (iType != 3) {
+//                        //true 抽点算法（当前采样率跟统一采样率不一样则是抽点，否则是未抽点）
+//                        if (!Objects.equals(comtradeCfgDTO.getLstRate().get(iRate).getNOneSample(), comtradeCfgDTO.getFinalSampleRate())) {
+//                            newLstRate.get(nnInd).setNOneSample(comtradeCfgDTO.getFinalSampleRate());
+//                            // 计算本段录波按照最低采样点应该有多少录波
+//                            newLstRate.get(nnInd).setNSampleNum(comtradeCfgDTO.getFinalSampleRate() * nWaveNum);
+//                        } else {
+//                            newLstRate.get(nnInd).setNOneSample(comtradeCfgDTO.getLstRate().get(iRate).getNOneSample());
+//                            // 计算本段录波按照最低采样点应该有多少录波
+//                            newLstRate.get(nnInd).setNSampleNum(comtradeCfgDTO.getLstRate().get(iRate).getNOneSample() * nWaveNum);
+//                        }
+//                    } else {
+//                        newLstRate.get(nnInd).setNOneSample(comtradeCfgDTO.getLstRate().get(iRate).getNOneSample());
+//                        // 计算本段录波按照最低采样点应该有多少录波
+//                        newLstRate.get(nnInd).setNSampleNum(comtradeCfgDTO.getLstRate().get(iRate).getNOneSample() * nWaveNum);
+//                    }
+//
+//                    // 正常的配置中采样率
+//                   /* comtradeCfgDTO.getLstRate().get(nnInd).setNOneSample(comtradeCfgDTO.getLstRate().get(iRate).getNOneSample());
+//                    comtradeCfgDTO.getLstRate().get(nnInd).setNSampleNum(comtradeCfgDTO.getLstRate().get(iRate).getNSampleNum());*/
+//
+//                    nnInd++;
+////                    }
+//                }
+//                // 偏移量,采样间隔
+//                long nOffSet = 0, nWaveSpan;
+//                //两个点之间的时间差
+//                float fValue, dfValue;
+//                // 计算不同块的采样率
+//                int nIndex = 0;
+//                // 将最低采样率替换到本段录波内
+//                // .CFG中采样率
+//                RateDTO tmpRateDTO;
+//                // nBlockNum 总循环次数
+//                for (int i = 0; i < nBlockNum; i++) {
+//                    tmpRateDTO = comtradeCfgDTO.getLstRate().get(nIndex);
+//                    // 判断是否进入下一段
+//                    if (i == tmpRateDTO.getNSampleNum() + nOffSet) {
+//                        nOffSet += tmpRateDTO.getNSampleNum();
+//                        nIndex++;
+//                        if (nIndex == nnInd) {
+//                            break;
+//                        }
+//                    }
+//                    tmpRateDTO = comtradeCfgDTO.getLstRate().get(nIndex);
+//                    //YXB 2025-08-27 如果是有效值，那么需要去补点，而不是抽点
+//                    if (newLstRate.get(nIndex).bRMSFlag == true) {
+//                        //计算本段补点采样间隔
+//                        nWaveSpan = newLstRate.get(nIndex).getNOneSample() / tmpRateDTO.getNOneSample();
+//                    } else {
+//                        // 计算本段抽点采样间隔
+//                        nWaveSpan = tmpRateDTO.getNOneSample() / newLstRate.get(nIndex).getNOneSample();
+//                    }
+//
+//                    dfValue = (float) 20 / tmpRateDTO.getNOneSample();
+//                    // 判断是否到了需要抽的采样点
+//                    if (i % nWaveSpan == 0) {
+//                        // 计算每个通道的值
+//                        //存储局部数据集合，包含了时间，A，B，C三相
+//                        List<Float> tmpWaveData = new ArrayList<>();
+//                        //YXB 2025-08-27 如果是有效值，那么需要去补点，而不是抽点
+//                        if (newLstRate.get(nIndex).bRMSFlag == true) {
+//                            // 计算有多少个周波
+//                            long allWaveTemp = newLstRate.get(nIndex).getNSampleNum() / newLstRate.get(nIndex).getNOneSample();
+//                            // 本段需要补多少点
+//                            long allempSample = newLstRate.get(nIndex).getNOneSample();
+//                            //int iStartWaveTemp = i ;// 开始补点的起点
+//                            for (int iWaveTemp = 0; iWaveTemp < allWaveTemp; iWaveTemp++) {
+//                                for (int mTempSample = 0; mTempSample < allempSample; mTempSample++) {
+//                                    //最多只有半波有效值，也就是每周波是1个或者2个点，然后去补最少16个点
+//                                    if (mTempSample / nWaveSpan == 1 && mTempSample % nWaveSpan == 0) {
+//                                        i++;
+//                                    }
+//                                    //存储局部数据集合，包含了时间，A，B，C三相
+//                                    tmpWaveData = new ArrayList<>();
+//                                    for (int j = 0; j < comtradeCfgDTO.getNAnalogNum(); j++) {
+//                                        //数据只有电压ABC三相数据，不展示U0、I0等数据 YXB2020-10-09 去除相别为N相的数据
+//                                        if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzPhasicName().equalsIgnoreCase("N")) {
+//                                            break;
+//                                        }
+//                                        float fCoef = comtradeCfgDTO.getLstAnalogDTO().get(j).getFCoefficent();
+//
+//                                        if((i * nBlockSize + 2 * 4 + j * 2) == 2437568){
+//                                            System.out.println(55);
+//                                        }
+//                                        fValue = BitConverter.byte2ToUnsignedShort(datArray, i * nBlockSize + 2 * 4 + j * 2) * fCoef;
+//                                        //WW 2019-11-14
+//                                        /*************************
+//                                         * 1、接口返回的默认是二次值
+//                                         * 2、P是一次值 S是二次值
+//                                         * 3、S(二次值）情况下：
+//                                         *     ①、单位为"V"时候则直接等于；
+//                                         *     ②、单位为"kV"时候需要乘以1000
+//                                         * 4、P(一次值）情况下：
+//                                         *     ①、单位为"V"时候则直接等于；
+//                                         *     ②、单位为"kV"时候需要乘以1000
+//                                         *************************/
+//                                        //P是一次值 S是二次值
+//                                        if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzValueType().equalsIgnoreCase("S")) {
+//                                            //判断单位是V还是kV
+//                                            if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("KV")) {
+//                                                fValue = fValue * 1000.0f;
+//                                            } else {
+//                                                fValue = fValue;
+//                                            }
+//                                        }
+//                                        //P是一次值 S是二次值
+//                                        else if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzValueType().equalsIgnoreCase("P")) {
+//                                            //判断单位是V还是kV
+//                                            if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("V")) {
+//                                                //根据cfg内的变比，将一次值转换成二次值
+//                                                if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
+//                                                    fValue = fValue * comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
+//                                                } else {
+//                                                    fValue = fValue;
+//                                                }
+//                                            }
+//                                            //判断单位是V还是kV
+//                                            else if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("KV")) {
+//                                                //根据cfg内的变比，将一次值转换成二次值
+//                                                if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
+//                                                    fValue = fValue * 1000.0f * comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
+//                                                } else {
+//                                                    fValue = fValue;
+//                                                }
+//                                            } else //还有可能是  电流，单位是A
+//                                            {
+//                                                //根据cfg内的变比，将一次值转换成二次值
+//                                                if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
+//                                                    fValue = comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
+//                                                } else {
+//                                                    fValue = fValue;
+//                                                }
+//                                            }
+//                                        }
+//
+//                                        //xValue前移量，假如是第一次时候则需要前移
+//                                        if (!blxValue && j == 0) {
+//                                            xValueAll = (float) (i * 20) / tmpRateDTO.getNOneSample() - comtradeCfgDTO.getNPush();
+//                                            blxValue = true;
+//                                            //只增加一个xValue的值 //增加时间值
+//                                            tmpWaveData.add((float) (Math.round(xValueAll * 100)) / 100);
+//                                        } else if (j == 0) {
+//                                            xValueAll += (float) dfValue / nWaveSpan;
+//                                            //只增加一个xValue的值 //增加时间值
+//                                            tmpWaveData.add((float) (Math.round(xValueAll * 100)) / 100);
+//                                        }
+//
+//                                        //不同通道yValue的值都需要增加，最终成ABC三相 //每个通道的值
+//                                        tmpWaveData.add((float) (Math.round(fValue * 100)) / 100);
+//                                    }
+//                                    //把每个单独的值赋予到整体里面去
+//                                    listWaveData.add(tmpWaveData);
+//                                }
+//                                // 把每个单独的值赋予到整体里面去
+//                                if (iWaveTemp < (allWaveTemp - 1)) {
+//                                    i++;
+//                                }
+//                            }
+//                        } else {
+//                            for (int j = 0; j < comtradeCfgDTO.getNAnalogNum(); j++) {
+//                                //数据只有电压ABC三相数据，不展示U0、I0等数据 YXB2020-10-09 去除相别为N相的数据
+//                                if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzPhasicName().equalsIgnoreCase("N")) {
+//                                    break;
+//                                }
+//
+//                                float fCoef = comtradeCfgDTO.getLstAnalogDTO().get(j).getFCoefficent();
+//                                fValue = BitConverter.byte2ToUnsignedShort(datArray, i * nBlockSize + 2 * 4 + j * 2) * fCoef;
+//
+//                                //WW 2019-11-14
+//                                /**************************
+//                                 * 1、接口返回的默认是二次值
+//                                 * 2、P是一次值 S是二次值
+//                                 * 3、S(二次值）情况下：
+//                                 *     ①、单位为"V"时候则直接等于；
+//                                 *     ②、单位为"kV"时候需要乘以1000
+//                                 * 4、P(一次值）情况下：
+//                                 *     ①、单位为"V"时候则直接等于；
+//                                 *     ②、单位为"kV"时候需要乘以1000
+//                                 **************************/
+//                                //P是一次值 S是二次值
+//                                if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzValueType().equalsIgnoreCase("S")) {
+//                                    //判断单位是V还是kV
+//                                    if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("KV")) {
+//                                        fValue = fValue * 1000.0f;
+//                                    } else {
+//                                        fValue = fValue;
+//                                    }
+//                                }
+//                                //P是一次值 S是二次值
+//                                else if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzValueType().equalsIgnoreCase("P")) {
+//                                    //判断单位是V还是kV
+//                                    if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("V")) {
+//                                        //根据cfg内的变比，将一次值转换成二次值
+//                                        if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
+//                                            fValue = fValue * comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
+//                                        } else {
+//                                            fValue = fValue;
+//                                        }
+//                                    }
+//                                    //判断单位是V还是kV
+//                                    else if (comtradeCfgDTO.getLstAnalogDTO().get(j).getSzUnitName().equalsIgnoreCase("KV")) {
+//                                        //根据cfg内的变比，将一次值转换成二次值
+//                                        if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
+//                                            fValue = fValue * 1000.0f * comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
+//                                        } else {
+//                                            fValue = fValue;
+//                                        }
+//                                    } else //还有可能是  电流，单位是A
+//                                    {
+//                                        //根据cfg内的变比，将一次值转换成二次值
+//                                        if (comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary() != 0.0f) {
+//                                            fValue = comtradeCfgDTO.getLstAnalogDTO().get(j).getFSecondary() / comtradeCfgDTO.getLstAnalogDTO().get(j).getFPrimary();
+//                                        } else {
+//                                            fValue = fValue;
+//                                        }
+//                                    }
+//                                }
+//                                //xValue前移量，假如是第一次时候则需要前移
+//                                if (!blxValue && j == 0) {
+//                                    xValueAll = (float) (i * 20) / tmpRateDTO.getNOneSample() - comtradeCfgDTO.getNPush();
+//                                    blxValue = true;
+//                                    //只增加一个xValue的值 //增加时间值
+//                                    tmpWaveData.add((float) (Math.round(xValueAll * 100)) / 100);
+//                                } else if (j == 0) {
+//                                    xValueAll += (float) nWaveSpan * dfValue;
+//                                    //只增加一个xValue的值 //增加时间值
+//                                    tmpWaveData.add((float) (Math.round(xValueAll * 100)) / 100);
+//                                }
+//
+//                                //不同通道yValue的值都需要增加，最终成ABC三相 //每个通道的值
+//                                tmpWaveData.add((float) (Math.round(fValue * 100)) / 100);
+//                            }
+//                            //把每个单独的值赋予到整体里面去
+//                            listWaveData.add(tmpWaveData);
+//                        }
+//                    }
+//                }
+//            }
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//            throw new BusinessException(WaveFileResponseEnum.DAT_DATA_ERROR);
+//        }
+//
+//        return listWaveData;
+//    }
+
 
     /*********************************
      * 获取最小(最终)采样率方法
@@ -1370,8 +1656,8 @@ public class WaveFileComponent {
         s = sdf.format(d);
         System.out.println(s);
         WaveFileComponent waveFileComponent = new WaveFileComponent();
-        InputStream cfgStream = waveFileComponent.getFileInputStreamByFilePath("F:\\PQ_PQLD3_9_20250821_081038_640.cfg");
-        InputStream datStream = waveFileComponent.getFileInputStreamByFilePath("F:\\PQ_PQLD3_9_20250821_081038_640.dat");
+        InputStream cfgStream = waveFileComponent.getFileInputStreamByFilePath("C:\\Users\\Administrator\\Desktop\\wave\\PQMonitor_PQM2_006970_20260320_175033_734.CFG");
+        InputStream datStream = waveFileComponent.getFileInputStreamByFilePath("C:\\Users\\Administrator\\Desktop\\wave\\PQMonitor_PQM2_006970_20260320_175033_734.DAT");
         // 获取瞬时波形 //获取原始波形值
         WaveDataDTO waveDataDTO = waveFileComponent.getComtrade(cfgStream, datStream, 1);
         d = new Date();

pqs-device/pq-device/pq-device-api/src/main/java/com/njcn/device/pq/pojo/vo/LineDetailVO.java

@@ -105,6 +105,9 @@ public class LineDetailVO implements Serializable {
         @ApiModelProperty(name = "终端厂家")
         private String manufacturer;
 
+        @ApiModelProperty(name = "终端厂家")
+        private String objId;
+
     }
 
     @Data

pqs-device/pq-device/pq-device-api/src/main/java/com/njcn/device/pq/pojo/vo/common/DeviceOnlineRate.java

@@ -116,6 +116,9 @@ public class DeviceOnlineRate {
         @ApiModelProperty("监测点名称")
         private String lineName;
 
+        @ApiModelProperty("监测对象")
+        private String objName;
+
         @ApiModelProperty("监测点运行状态")
         private String runFlag;
 

pqs-device/pq-device/pq-device-boot/src/main/java/com/njcn/device/pq/job/DeviceComflagTasks.java

@@ -10,6 +10,7 @@ import com.njcn.device.node.mapper.NodeMapper;
 import com.njcn.device.pq.pojo.po.Device;
 import com.njcn.device.pq.pojo.po.DeviceProcess;
 import com.njcn.device.pq.pojo.po.Node;
+import com.njcn.message.constant.RedisKeyPrefix;
 import com.njcn.redis.utils.RedisUtil;
 import lombok.RequiredArgsConstructor;
 import org.apache.commons.lang3.StringUtils;
@@ -21,6 +22,7 @@ import org.springframework.util.CollectionUtils;
 import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
 import java.util.List;
+import java.util.Objects;
 import java.util.stream.Collectors;
 
 /**
@@ -63,8 +65,17 @@ public class DeviceComflagTasks {
                                 pqsCommunicateDto.setTime(LocalDateTimeUtil.now().format(DatePattern.NORM_DATETIME_FORMATTER));
                                 pqsCommunicateDto.setDevId(temp);
                                 pqsCommunicateDto.setType(0);
+                                //获取之前设备状态
+                                String devFalg =redisUtil.getStringByKey(RedisKeyPrefix.DEVICE_RUN_FLAG.concat(temp));
+
+                                if(StringUtils.isBlank(devFalg)||(!Objects.equals(Integer.valueOf(devFalg),pqsCommunicateDto.getType()))){
+                                    //状态翻转
+                                    redisUtil.saveByKey(RedisKeyPrefix.DEVICE_RUN_FLAG.concat(temp),pqsCommunicateDto.getType()+"");
+                                    pqsCommunicateFeignClient.insertion(pqsCommunicateDto) ;
+
+
+                                }
 
-                                pqsCommunicateFeignClient.insertion(pqsCommunicateDto) ;
                             });
 
                         }

pqs-device/pq-device/pq-device-boot/src/main/java/com/njcn/device/pq/service/impl/RStatIntegrityDServiceImpl.java

@@ -30,7 +30,11 @@ import com.njcn.device.pq.pojo.vo.RStatIntegrityVO;
 import com.njcn.device.pq.pojo.vo.common.DeviceOnlineRate;
 import com.njcn.device.pq.service.IRStatIntegrityDService;
 import com.njcn.device.rstatintegrity.mapper.RStatIntegrityDMapper;
+import com.njcn.device.userledger.service.UserLedgerService;
+import com.njcn.supervision.pojo.param.user.UserReportParam;
+import com.njcn.supervision.pojo.vo.user.UserLedgerVO;
 import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang.StringUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -61,6 +65,7 @@ public class RStatIntegrityDServiceImpl extends MppServiceImpl<RStatIntegrityDMa
     private final LineDetailMapper lineDetailMapper;
     private final GeneralDeviceService deviceService;
     private final LineService lineService;
+    private final UserLedgerService userLedgerService;
 
     @Override
     public Float getTotalIntegrityByLineIds(LineBaseQueryParam param) {
@@ -160,6 +165,9 @@ public class RStatIntegrityDServiceImpl extends MppServiceImpl<RStatIntegrityDMa
             List<DeviceOnlineRate.CitDetail> citDetailList = new ArrayList<>();
             DeviceOnlineRate.CitDetail citDetail;
             DeviceOnlineRate.LineDetail detail;
+            //用户侧监测点 监测对象
+            List<UserLedgerVO> userLedgerVOS = userLedgerService.selectUserList(new UserReportParam());
+            Map<String, String> objMap = userLedgerVOS.stream().collect(Collectors.toMap(UserLedgerVO::getId, UserLedgerVO::getProjectName));
             for (GeneralDeviceDTO dto : deviceInfo) {
                 //获取部门终端集合
                 List<RStatIntegrityVO> citDevOnRate = lineIntegrityRateInfo.stream().filter(x -> dto.getLineIndexes().contains(x.getLineIndex())).collect(Collectors.toList());
@@ -184,6 +192,8 @@ public class RStatIntegrityDServiceImpl extends MppServiceImpl<RStatIntegrityDMa
                     detail.setRunFlag(RunFlagEnum.getRunFlagRemarkByStatus(Integer.valueOf(line.getLineRunType())));
                     detail.setLineId(line.getLineId());
                     detail.setLineName(line.getLineName());
+                    //用户侧监测点 监测对象
+                    detail.setObjName(StringUtils.isBlank(line.getObjId())?"/":objMap.get(line.getObjId()));
                     detail.setLatestTime(line.getTimeID());
                     detail.setIntegrity(onlineRateByDevMap.getOrDefault(line.getLineId(), BigDecimal.valueOf(0)).doubleValue()>100.0?BigDecimal.valueOf(100.0):onlineRateByDevMap.getOrDefault(line.getLineId(), BigDecimal.valueOf(0)));
                     detailList.add(detail);

pqs-device/pq-device/pq-device-com/src/main/java/com/njcn/device/device/controller/DeviceController.java

@@ -3,9 +3,6 @@ package com.njcn.device.device.controller;
 import cn.hutool.core.collection.CollectionUtil;
 import cn.hutool.core.lang.Console;
 import cn.hutool.core.util.StrUtil;
-import com.github.tocrhz.mqtt.annotation.MqttSubscribe;
-import com.github.tocrhz.mqtt.annotation.NamedValue;
-import com.github.tocrhz.mqtt.annotation.Payload;
 import com.njcn.common.pojo.annotation.OperateInfo;
 import com.njcn.common.pojo.dto.SimpleDTO;
 import com.njcn.common.pojo.enums.common.LogEnum;
@@ -27,12 +24,10 @@ import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.eclipse.paho.client.mqttv3.MqttMessage;
 import org.springframework.beans.BeanUtils;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 
-import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
@@ -57,132 +52,132 @@ public class DeviceController extends BaseController {
 
     private final GeneralDeviceService generalDeviceService;
 
-    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
-    @PostMapping("/socketLine")
-    @ApiOperation("获取监测点定值信息")
-    public HttpResult<String> socketLine(@RequestBody @Validated ConstantValueParam.Constant param) {
-        String methodDescribe = getMethodDescribe("socketLine");
-        if(StrUtil.isBlank(param.getIp())){
-            param.setIp(RequestUtil.getRealIp());
-        }
-        String s = iDeviceService.sentLine(param);
-        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
-    }
-
-    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
-    @PostMapping("/updateSocketLine")
-    @ApiOperation("修改监测点定值信息")
-    public HttpResult<String> updateSocketLine(@RequestBody @Validated ConstantValueParam.ValueData param) {
-        String methodDescribe = getMethodDescribe("updateSocketLine");
-        if(StrUtil.isBlank(param.getIp())){
-            param.setIp(RequestUtil.getRealIp());
-        }
-        String s = iDeviceService.sentLineData(param);
-        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
-    }
-
-    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
-    @PostMapping("/socketDev")
-    @ApiOperation("获取终端定值信息")
-    public HttpResult<String> socketDev(@RequestBody @Validated ConstantValueParam.Constant param) {
-        String methodDescribe = getMethodDescribe("socketDev");
-        if(StrUtil.isBlank(param.getIp())){
-            param.setIp(RequestUtil.getRealIp());
-        }
-        String s = iDeviceService.sentDev(param);
-        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
-    }
-    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
-    @PostMapping("/updateSocketDev")
-    @ApiOperation("修改终端定值信息")
-    public HttpResult<String> updateSocketDev(@RequestBody @Validated ConstantValueParam.ValueData param) {
-        String methodDescribe = getMethodDescribe("updateSocketDev");
-        if(StrUtil.isBlank(param.getIp())){
-            param.setIp(RequestUtil.getRealIp());
-        }
-        String s = iDeviceService.sentDevData(param);
-        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
-    }
-
-    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
-    @PostMapping("/socketDevProperty")
-    @ApiOperation("获取终端性能信息")
-    public HttpResult<String> socketDevProperty(String devID) {
-        String methodDescribe = getMethodDescribe("socketDevProperty");
-        String s = iDeviceService.socketDevProperty(devID);
-        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
-    }
-
-    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
-    @PostMapping("/socketDevPropertyClose")
-    @ApiOperation("终端性能关闭")
-    public HttpResult<String> socketDevPropertyClose(String devID) {
-        String methodDescribe = getMethodDescribe("socketDevPropertyClose");
-        String s = iDeviceService.socketDevPropertyClose(devID);
-        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
-    }
-
-    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
-    @PostMapping("/realTimeData")
-    @ApiOperation("监测点实时数据查看")
-    public HttpResult<String> realTimeData(String lineID) {
-        String methodDescribe = getMethodDescribe("realTimeData");
-        String s = iDeviceService.realTimeData(lineID);
-        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
-    }
-
-    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
-    @PostMapping("/heartRealTimeData")
-    @ApiOperation("监测实施数据心跳")
-    public HttpResult<String> heartRealTimeData(String lineID) {
-        String methodDescribe = getMethodDescribe("heartRealTimeData");
-        String s = iDeviceService.heartRealTimeData(lineID);
-        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
-    }
-
-    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
-    @PostMapping("/closeRealTimeData")
-    @ApiOperation("监测点实施数据关闭")
-    public HttpResult<String> closeRealTimeData(String lineID) {
-        String methodDescribe = getMethodDescribe("closeRealTimeData");
-        String s = iDeviceService.closeRealTimeData(lineID);
-        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
-    }
-
-    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
-    @PostMapping("/getDevUpgrades")
-    @ApiOperation("终端版本升级")
-    public HttpResult<String> getDevUpgrades(@RequestBody @Validated ConstantValueParam.Upgrades param) {
-        String methodDescribe = getMethodDescribe("getDevUpgrades");
-        String s = iDeviceService.getDevUpgrades(param.getList(),param.getEdIndex());
-        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
-    }
-
-    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
-    @PostMapping("/closeUpgrades")
-    @ApiOperation("终端升级取消")
-    public HttpResult<String> closeUpgrades(@RequestBody List<String> devList) {
-        String methodDescribe = getMethodDescribe("closeUpgrades");
-        String s = iDeviceService.closeUpgrades(devList);
-        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
-    }
-
-    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
-    @PostMapping("/restartDev")
-    @ApiOperation("重启装置命令")
-    public HttpResult<String> restartDev(@RequestBody List<String> devList) {
-        String methodDescribe = getMethodDescribe("restartDev");
-        String s = iDeviceService.restartDev(devList);
-        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
-    }
-    @MqttSubscribe(value = "/zl/devData/{devID}",qos = 1)
-    public void responseRtData(String topic, @NamedValue("devID") String pageId, MqttMessage message, @Payload String payload) {
-        Console.log("receive from    : {}", topic);
-        Console.log("receive from    : {}", pageId);
-        Console.log("message     : {}", message.getPayload());
-        Console.log("message payload : {}", new String(message.getPayload(), StandardCharsets.UTF_8));
-        Console.log("string payload  : {}", payload);
-    }
+//    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+//    @PostMapping("/socketLine")
+//    @ApiOperation("获取监测点定值信息")
+//    public HttpResult<String> socketLine(@RequestBody @Validated ConstantValueParam.Constant param) {
+//        String methodDescribe = getMethodDescribe("socketLine");
+//        if(StrUtil.isBlank(param.getIp())){
+//            param.setIp(RequestUtil.getRealIp());
+//        }
+//        String s = iDeviceService.sentLine(param);
+//        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
+//    }
+//
+//    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+//    @PostMapping("/updateSocketLine")
+//    @ApiOperation("修改监测点定值信息")
+//    public HttpResult<String> updateSocketLine(@RequestBody @Validated ConstantValueParam.ValueData param) {
+//        String methodDescribe = getMethodDescribe("updateSocketLine");
+//        if(StrUtil.isBlank(param.getIp())){
+//            param.setIp(RequestUtil.getRealIp());
+//        }
+//        String s = iDeviceService.sentLineData(param);
+//        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
+//    }
+//
+//    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+//    @PostMapping("/socketDev")
+//    @ApiOperation("获取终端定值信息")
+//    public HttpResult<String> socketDev(@RequestBody @Validated ConstantValueParam.Constant param) {
+//        String methodDescribe = getMethodDescribe("socketDev");
+//        if(StrUtil.isBlank(param.getIp())){
+//            param.setIp(RequestUtil.getRealIp());
+//        }
+//        String s = iDeviceService.sentDev(param);
+//        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
+//    }
+//    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+//    @PostMapping("/updateSocketDev")
+//    @ApiOperation("修改终端定值信息")
+//    public HttpResult<String> updateSocketDev(@RequestBody @Validated ConstantValueParam.ValueData param) {
+//        String methodDescribe = getMethodDescribe("updateSocketDev");
+//        if(StrUtil.isBlank(param.getIp())){
+//            param.setIp(RequestUtil.getRealIp());
+//        }
+//        String s = iDeviceService.sentDevData(param);
+//        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
+//    }
+//
+//    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+//    @PostMapping("/socketDevProperty")
+//    @ApiOperation("获取终端性能信息")
+//    public HttpResult<String> socketDevProperty(String devID) {
+//        String methodDescribe = getMethodDescribe("socketDevProperty");
+//        String s = iDeviceService.socketDevProperty(devID);
+//        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
+//    }
+//
+//    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+//    @PostMapping("/socketDevPropertyClose")
+//    @ApiOperation("终端性能关闭")
+//    public HttpResult<String> socketDevPropertyClose(String devID) {
+//        String methodDescribe = getMethodDescribe("socketDevPropertyClose");
+//        String s = iDeviceService.socketDevPropertyClose(devID);
+//        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
+//    }
+//
+//    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+//    @PostMapping("/realTimeData")
+//    @ApiOperation("监测点实时数据查看")
+//    public HttpResult<String> realTimeData(String lineID) {
+//        String methodDescribe = getMethodDescribe("realTimeData");
+//        String s = iDeviceService.realTimeData(lineID);
+//        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
+//    }
+//
+//    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+//    @PostMapping("/heartRealTimeData")
+//    @ApiOperation("监测实施数据心跳")
+//    public HttpResult<String> heartRealTimeData(String lineID) {
+//        String methodDescribe = getMethodDescribe("heartRealTimeData");
+//        String s = iDeviceService.heartRealTimeData(lineID);
+//        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
+//    }
+//
+//    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+//    @PostMapping("/closeRealTimeData")
+//    @ApiOperation("监测点实施数据关闭")
+//    public HttpResult<String> closeRealTimeData(String lineID) {
+//        String methodDescribe = getMethodDescribe("closeRealTimeData");
+//        String s = iDeviceService.closeRealTimeData(lineID);
+//        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
+//    }
+//
+//    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+//    @PostMapping("/getDevUpgrades")
+//    @ApiOperation("终端版本升级")
+//    public HttpResult<String> getDevUpgrades(@RequestBody @Validated ConstantValueParam.Upgrades param) {
+//        String methodDescribe = getMethodDescribe("getDevUpgrades");
+//        String s = iDeviceService.getDevUpgrades(param.getList(),param.getEdIndex());
+//        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
+//    }
+//
+//    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+//    @PostMapping("/closeUpgrades")
+//    @ApiOperation("终端升级取消")
+//    public HttpResult<String> closeUpgrades(@RequestBody List<String> devList) {
+//        String methodDescribe = getMethodDescribe("closeUpgrades");
+//        String s = iDeviceService.closeUpgrades(devList);
+//        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
+//    }
+//
+//    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+//    @PostMapping("/restartDev")
+//    @ApiOperation("重启装置命令")
+//    public HttpResult<String> restartDev(@RequestBody List<String> devList) {
+//        String methodDescribe = getMethodDescribe("restartDev");
+//        String s = iDeviceService.restartDev(devList);
+//        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, s, methodDescribe);
+//    }
+//    @MqttSubscribe(value = "/zl/devData/{devID}",qos = 1)
+//    public void responseRtData(String topic, @NamedValue("devID") String pageId, MqttMessage message, @Payload String payload) {
+//        Console.log("receive from    : {}", topic);
+//        Console.log("receive from    : {}", pageId);
+//        Console.log("message     : {}", message.getPayload());
+//        Console.log("message payload : {}", new String(message.getPayload(), StandardCharsets.UTF_8));
+//        Console.log("string payload  : {}", payload);
+//    }
 
     @OperateInfo(info = LogEnum.SYSTEM_COMMON)
     @PostMapping("/updateDevCheckTime")

pqs-device/pq-device/pq-device-com/src/main/java/com/njcn/device/device/service/IDeviceService.java

@@ -19,113 +19,113 @@ import java.util.List;
 public interface IDeviceService extends IService<Device> {
 
 
-    /***
-     * @Description: mqtt获取外部定值
-     * @param param
-     * @return: java.lang.String
-     * @Author: wr
-     * @Date: 2023/8/14 10:17
-     */
-    String sentLine(ConstantValueParam.Constant param);
-
-    /***
-     * @Description: mqtt修改外部定值
-     * @param param
-     * @return: java.lang.String
-     * @Author: wr
-     * @Date: 2023/8/14 11:07
-     */
-    String sentLineData(ConstantValueParam.ValueData param);
-
-    /**
-     * @param param
-     * @Description: mqtt获取内部定值
-     * @return: java.lang.String
-     * @Author: wr
-     * @Date: 2023/8/14 14:51
-     */
-    String sentDev(ConstantValueParam.Constant param);
-
-    /**
-     * @param param
-     * @Description: mqtt修改内部定值
-     * @return: java.lang.String
-     * @Author: wr
-     * @Date: 2023/8/14 14:51
-     */
-    String sentDevData(ConstantValueParam.ValueData param);
-
-    /**
-     * @param devID
-     * @Description: 终端性能查看
-     * @return: java.lang.String
-     * @Author: wr
-     * @Date: 2023/8/15 11:27
-     */
-    String socketDevProperty(String devID);
-
-    /**
-     * @param devID
-     * @Description: 终端性能关闭
-     * @return: java.lang.String
-     * @Author: wr
-     * @Date: 2023/8/15 16:13
-     */
-    String socketDevPropertyClose(String devID);
-
-    /**
-     * @param lineIndex
-     * @Description: 监测点实时数据查看
-     * @return: java.lang.String
-     * @Author: wr
-     * @Date: 2023/8/15 16:13
-     */
-    String realTimeData(String lineIndex);
-
-    /**
-     * @param lineIndex
-     * @Description: 监测实施数据心跳
-     * @return: java.lang.String
-     * @Author: wr
-     * @Date: 2023/8/15 16:14
-     */
-    String heartRealTimeData(String lineIndex);
-
-    /**
-     * @param lineIndex
-     * @Description: 监测点实施数据关闭
-     * @return: java.lang.String
-     * @Author: wr
-     * @Date: 2023/8/15 16:14
-     */
-    String closeRealTimeData(String lineIndex);
-
-    /**
-     * 终端版本升级，批量升级条件必须是相同终端系列的终端才能升级
-     *
-     * @param list
-     * @param edIndex
-     * @return
-     */
-    String getDevUpgrades(List<String> list, String edIndex);
-
-    /**
-     * @param devList
-     * @Description: 终端升级取消
-     * @return: java.lang.String
-     * @Author: wr
-     * @Date: 2023/8/17 9:24
-     */
-    String closeUpgrades(List<String> devList);
-
-    /**
-     * @param devList
-     * @Description: 重启装置命令
-     * @return: java.lang.String
-     * @Author: wr
-     * @Date: 2023/8/17 9:24
-     */
-    String restartDev(List<String> devList);
+//    /***
+//     * @Description: mqtt获取外部定值
+//     * @param param
+//     * @return: java.lang.String
+//     * @Author: wr
+//     * @Date: 2023/8/14 10:17
+//     */
+//    String sentLine(ConstantValueParam.Constant param);
+//
+//    /***
+//     * @Description: mqtt修改外部定值
+//     * @param param
+//     * @return: java.lang.String
+//     * @Author: wr
+//     * @Date: 2023/8/14 11:07
+//     */
+//    String sentLineData(ConstantValueParam.ValueData param);
+//
+//    /**
+//     * @param param
+//     * @Description: mqtt获取内部定值
+//     * @return: java.lang.String
+//     * @Author: wr
+//     * @Date: 2023/8/14 14:51
+//     */
+//    String sentDev(ConstantValueParam.Constant param);
+//
+//    /**
+//     * @param param
+//     * @Description: mqtt修改内部定值
+//     * @return: java.lang.String
+//     * @Author: wr
+//     * @Date: 2023/8/14 14:51
+//     */
+//    String sentDevData(ConstantValueParam.ValueData param);
+//
+//    /**
+//     * @param devID
+//     * @Description: 终端性能查看
+//     * @return: java.lang.String
+//     * @Author: wr
+//     * @Date: 2023/8/15 11:27
+//     */
+//    String socketDevProperty(String devID);
+//
+//    /**
+//     * @param devID
+//     * @Description: 终端性能关闭
+//     * @return: java.lang.String
+//     * @Author: wr
+//     * @Date: 2023/8/15 16:13
+//     */
+//    String socketDevPropertyClose(String devID);
+//
+//    /**
+//     * @param lineIndex
+//     * @Description: 监测点实时数据查看
+//     * @return: java.lang.String
+//     * @Author: wr
+//     * @Date: 2023/8/15 16:13
+//     */
+//    String realTimeData(String lineIndex);
+//
+//    /**
+//     * @param lineIndex
+//     * @Description: 监测实施数据心跳
+//     * @return: java.lang.String
+//     * @Author: wr
+//     * @Date: 2023/8/15 16:14
+//     */
+//    String heartRealTimeData(String lineIndex);
+//
+//    /**
+//     * @param lineIndex
+//     * @Description: 监测点实施数据关闭
+//     * @return: java.lang.String
+//     * @Author: wr
+//     * @Date: 2023/8/15 16:14
+//     */
+//    String closeRealTimeData(String lineIndex);
+//
+//    /**
+//     * 终端版本升级，批量升级条件必须是相同终端系列的终端才能升级
+//     *
+//     * @param list
+//     * @param edIndex
+//     * @return
+//     */
+//    String getDevUpgrades(List<String> list, String edIndex);
+//
+//    /**
+//     * @param devList
+//     * @Description: 终端升级取消
+//     * @return: java.lang.String
+//     * @Author: wr
+//     * @Date: 2023/8/17 9:24
+//     */
+//    String closeUpgrades(List<String> devList);
+//
+//    /**
+//     * @param devList
+//     * @Description: 重启装置命令
+//     * @return: java.lang.String
+//     * @Author: wr
+//     * @Date: 2023/8/17 9:24
+//     */
+//    String restartDev(List<String> devList);
 
     /**
      * @param devId             装置id

pqs-device/pq-device/pq-device-com/src/main/java/com/njcn/device/device/service/impl/DeviceServiceImpl.java

@@ -1,10 +1,6 @@
 package com.njcn.device.device.service.impl;
 
 
-import cn.hutool.core.collection.CollUtil;
-import cn.hutool.core.collection.CollectionUtil;
-import cn.hutool.core.util.StrUtil;
-import cn.hutool.json.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
@@ -14,16 +10,11 @@ import com.njcn.device.device.mapper.DeviceMapper;
 import com.njcn.device.device.service.IDeviceService;
 import com.njcn.device.device.service.ProgramVersionService;
 import com.njcn.device.line.mapper.LineMapper;
-import com.njcn.device.pq.pojo.advanced.*;
-import com.njcn.device.pq.pojo.param.ConstantValueParam;
-import com.njcn.device.pq.pojo.po.DevVersion;
+
 import com.njcn.device.pq.pojo.po.Device;
-import com.njcn.device.pq.pojo.po.Line;
-import com.njcn.device.pq.pojo.po.Version;
+
 import com.njcn.device.pq.pojo.vo.DevStatusNumVO;
-import com.njcn.device.pq.pojo.vo.DeviceIpRVO;
-import com.njcn.device.utils.SocketClient;
-import com.njcn.web.utils.RequestUtil;
+
 import lombok.RequiredArgsConstructor;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
@@ -45,360 +36,360 @@ import java.util.stream.Collectors;
 public class DeviceServiceImpl extends ServiceImpl<DeviceMapper, Device> implements IDeviceService {
 
     private final LineMapper lineMapper;
-    private final SocketClient socketClient;
+//    private final SocketClient socketClient;
     private final DevVersionMapper devVersionMapper;
     private final ProgramVersionService programVersionService;
 
     @Value("${socket.port:60000}")
     private Integer socketPort;
 
-    @Override
-    public String sentLine(ConstantValueParam.Constant param) {
-        try {
-            //获取根据监测点获取终端信息
-            UpDevVO upDevVO = lineMapper.getDevInfo(param.getId());
-            //查询前置ip
-            String host = lineMapper.getNodeIp(upDevVO.getDevIndex(),0);
-            //拼接属性
-            ContValueRVO upParamVO = new ContValueRVO();
-            ContValueVO valueVO = new ContValueVO();
-            valueVO.setType(param.getType());
-            valueVO.setLineid(param.getId());
-            valueVO.setHander(param.getHander());
-            JSONObject jsonStr = new JSONObject(valueVO);
-            Integer len = jsonStr.toString().length();
-            upParamVO.setLen(len.toString());
-            upParamVO.setData(valueVO);
-            JSONObject jsonObject = new JSONObject(upParamVO);
-            String str = jsonObject.toString();
-            List<UpDevVO> devList = new ArrayList<>();
-            devList.add(upDevVO);
-            return socketClient.sentLine(param.getIp(), str, host, socketPort, "wr", devList);
-        } catch (Exception e) {
-            return "获取定值失败";
-        }
-
-    }
-
-    @Override
-    public String sentLineData(ConstantValueParam.ValueData param) {
-        try {
-            //获取根据监测点获取终端信息
-            UpDevVO upDevVO = lineMapper.getDevInfo(param.getId());
-            //查询前置ip
-            String host = lineMapper.getNodeIp(upDevVO.getDevIndex(),0);
-            ContUpdateValueRVO upParamVO = new ContUpdateValueRVO();
-            ContUpdateValueVO valueVO = new ContUpdateValueVO();
-            valueVO.setType(param.getType());
-            valueVO.setLineid(param.getId());
-            valueVO.setHander(param.getHander());
-            float[] intArr;
-            if (StrUtil.isBlank(param.getInterValue())) {
-                intArr = new float[0];
-            } else {
-                String[] valueArr = param.getInterValue().split(",");
-                intArr = new float[valueArr.length];
-                for (int i = 0; i < valueArr.length; i++) {
-                    intArr[i] = Float.parseFloat(valueArr[i]);
-                }
-            }
-            valueVO.setValue(intArr);
-            JSONObject jsonStr = new JSONObject(valueVO);
-            Integer len = jsonStr.toString().length();
-            upParamVO.setLen(len.toString());
-            upParamVO.setData(valueVO);
-            JSONObject jsonObject = new JSONObject(upParamVO);
-            String str = jsonObject.toString();
-            List<UpDevVO> devList = new ArrayList<>();
-            devList.add(upDevVO);
-            return socketClient.sentLine(param.getIp(), str, host, socketPort, "wr", devList);
-        } catch (Exception e) {
-            return "运行失败";
-        }
-    }
-
-    @Override
-    public String sentDev(ConstantValueParam.Constant param) {
-        try {
-            Line line = lineMapper.selectById(param.getId());
-            UpDevVO upDevVO = new UpDevVO();
-            upDevVO.setDevIndex(line.getId());
-            upDevVO.setDevName(line.getName());
-            String host = lineMapper.getNodeIp(line.getId(),1);
-            ContValueRVO upParamVO = new ContValueRVO();
-            ContValueVO valueVO = new ContValueVO();
-            valueVO.setType(param.getType());
-            valueVO.setIndex(param.getId());
-            valueVO.setHander(param.getHander());
-            JSONObject jsonStr = new JSONObject(valueVO);
-            Integer len = jsonStr.toString().length();
-            upParamVO.setLen(len.toString());
-            upParamVO.setData(valueVO);
-            JSONObject jsonObject = new JSONObject(upParamVO);
-            String str = jsonObject.toString();
-            List<UpDevVO> devList = new ArrayList<>();
-            devList.add(upDevVO);
-            return socketClient.sentDZDev(param.getIp(), str, host, socketPort, "wr", devList);
-        } catch (Exception e) {
-            return "获取定值失败";
-        }
-    }
-
-    @Override
-    public String sentDevData(ConstantValueParam.ValueData param) {
-        try {
-            Line line = lineMapper.selectById(param.getId());
-            UpDevVO upDevVO = new UpDevVO();
-            upDevVO.setDevIndex(line.getId());
-            upDevVO.setDevName(line.getName());
-            String host = lineMapper.getNodeIp(line.getId(),1);
-            ContUpdateDevValueRVO upParamVO = new ContUpdateDevValueRVO();
-            ContUpdateDevValueVO valueVO = new ContUpdateDevValueVO();
-            valueVO.setType(param.getType());
-            valueVO.setIndex(line.getId());
-            valueVO.setHander(String.valueOf(param.getHander()));
-            int[] intArr;
-            if (StrUtil.isBlank(param.getInterValue())) {
-                intArr = new int[0];
-            } else {
-                String[] valueArr = param.getInterValue().split(",");
-                intArr = new int[valueArr.length];
-                for (int i = 0; i < valueArr.length; i++) {
-                    intArr[i] = Integer.parseInt(valueArr[i]);
-                }
-            }
-            valueVO.setInterValue(intArr);
-            JSONObject jsonStr = new JSONObject(valueVO);
-            Integer len = jsonStr.toString().length();
-            upParamVO.setLen(len.toString());
-            upParamVO.setData(valueVO);
-            JSONObject jsonObject = new JSONObject(upParamVO);
-            String str = jsonObject.toString();
-
-            List<UpDevVO> devList = new ArrayList<>();
-            devList.add(upDevVO);
-            return socketClient.sentDZDev(param.getIp(), str, host, socketPort, "wr", devList);
-        } catch (Exception e) {
-            return "运行失败";
-        }
-    }
-
-    @Override
-    public String socketDevProperty(String devID) {
-        String host = lineMapper.getNodeIp(devID,1);
-        if(StrUtil.isBlank(host)){
-            return "前置ip获取失败";
-        }
-        JSONObject jsonObject = new JSONObject();
-        Map<String,String> map = new HashMap<>();
-        map.put("type","190");
-        map.put("index",devID);
-        map.put("hander","1");
-        jsonObject.set("data", map);
-        Integer len = jsonObject.get("data").toString().length();
-        jsonObject.set("len", len.toString());
-        socketClient.showProperty(jsonObject.toString(),host,socketPort,RequestUtil.getLoginName());
-        return "终端性能获取成功";
-    }
-
-    @Override
-    public String socketDevPropertyClose(String devID) {
-        String host = lineMapper.getNodeIp(devID,1);
-        try {
-            JSONObject jsonObject = new JSONObject();
-            Map<String, String> map = new HashMap<>();
-            map.put("type", "190");
-            map.put("index", devID);
-            map.put("hander", "0");
-            jsonObject.set("data", map);
-            Integer len = jsonObject.get("data").toString().length();
-            jsonObject.set("len", len.toString());
-            socketClient.closeDevSocket(jsonObject.toString(),host,socketPort,RequestUtil.getLoginName());
-            return "执行成功";
-        }catch (Exception e){
-            return "执行失败";
-        }
-    }
-
-    @Override
-    public String realTimeData(String lineIndex) {
-        //查询前置ip
-        String host = lineMapper.getNodeIp(lineIndex,0);
-        if(StrUtil.isBlank(host)){
-            return "设备前置机服务器配置异常,请联系管理员";
-        }else {
-            JSONObject jsonObject = new JSONObject();
-            jsonObject.set("LineId", lineIndex);
-            jsonObject.set("type", 0);
-            JSONObject jsonObject1 = new JSONObject();
-            jsonObject1.set("len",0);
-            jsonObject1.set("data",jsonObject);
-            socketClient.realTimeData(jsonObject1.toString(),host,socketPort,lineIndex);
-        }
-        return "请求成功";
-    }
-
-    @Override
-    public String heartRealTimeData(String lineIndex) {
-        JSONObject jsonObject = new JSONObject();
-        jsonObject.set("LineId", lineIndex);
-        jsonObject.set("type", 1);
-        JSONObject jsonObject1 = new JSONObject();
-        jsonObject1.set("len", 0);
-        jsonObject1.set("data", jsonObject);
-        String host = lineMapper.getNodeIp(lineIndex,0);
-        socketClient.heartRealData(jsonObject1.toString(),host,socketPort,lineIndex);
-        return "实时数据心跳请求成功";
-    }
-
-    @Override
-    public String closeRealTimeData(String lineIndex) {
-        socketClient.closeRealData(lineIndex);
-        return "关闭实时数据请求成功";
-    }
-
-    @Override
-    public String getDevUpgrades(List<String> list, String edIndex) {
-        List<DeviceIpRVO> resTemlist = new ArrayList<>();
-
-        List<DeviceIpRVO> relist = lineMapper.getDevicesIp(list);
-        //判断设备版本号
-        Integer isExit = devVersionMapper.selectCount(new LambdaQueryWrapper<DevVersion>()
-                .eq(DevVersion::getVersionId,edIndex)
-                .in(DevVersion::getLineId,list)
-                .eq(DevVersion::getState,1)
-        );
-        if (isExit > 0) {
-            return "请勿选择相同版本号升级";
-        }
-        if (!CollectionUtil.isEmpty(relist)) {
-            Version version = programVersionService.getById(edIndex);
-            String series = version.getDevType();
-            //判断设备是否存在相同型号
-            for (DeviceIpRVO deviceIpRVO : relist) {
-                if (!series.equals(deviceIpRVO.getDevSeries())) {
-                    return "当前装置版本系列与目标版本系列不相同";
-                }
-            }
-
-            //判断是否断开
-            if (relist.stream().filter(w -> w.getComFlag() == 0).findAny().isPresent()) {
-                return "存在通讯中断设备";
-            }
-
-
-            Set<String> set = new HashSet<>();
-            for (DeviceIpRVO d : relist) {
-                set.add(d.getIp());
-            }
-            Iterator<String> iterator = set.iterator();
-            while (iterator.hasNext()) {
-                List<UpDevVO> devIndex = new ArrayList<>();
-                DeviceIpRVO deviceIpRVO = new DeviceIpRVO();
-                String ip = iterator.next();
-                for (DeviceIpRVO d : relist) {
-                    UpDevVO upDevVO = new UpDevVO();
-                    upDevVO.setDevIndex(d.getDevIndex());
-                    upDevVO.setDevName(d.getDevName());
-                    if (ip.equals(d.getIp())) {
-                        devIndex.add(upDevVO);
-                    }
-                }
-                deviceIpRVO.setIp(ip);
-                deviceIpRVO.setDevlist(devIndex);
-                resTemlist.add(deviceIpRVO);
-            }
-        } else {
-            return "存在未知错误";
-        }
-        for (DeviceIpRVO deviceIpRVO : resTemlist) {
-            String ip = deviceIpRVO.getIp();
-            List<UpDevVO> devlist = deviceIpRVO.getDevlist();
-            UpDataVO upDataVO = new UpDataVO();
-            UpParamVO upParamVO = new UpParamVO();
-            upDataVO.setTerminal(devlist);
-            upDataVO.setType("180");
-            upDataVO.setEdIndex(edIndex);
-            upDataVO.setUserIndex(RequestUtil.getUserIndex());
-            JSONObject jsonstr = new JSONObject(upDataVO);
-            Integer len = jsonstr.toString().length();
-            upParamVO.setData(upDataVO);
-            upParamVO.setLen(len.toString());
-            JSONObject jsonObject = new JSONObject(upParamVO);
-            String str = jsonObject.toString();
-            socketClient.sentUpgrades(str, ip, socketPort, RequestUtil.getLoginName(), edIndex, devlist);
-        }
-        return "运行成功";
-    }
-
-    @Override
-    public String closeUpgrades(List<String> devList) {
-        List<DeviceIpRVO> relist = lineMapper.getDevicesIp(devList);
-        if(CollectionUtil.isEmpty(relist)){
-            return "前置机为空";
-        }else {
-            List<String> nodeIp = relist.stream().map(DeviceIpRVO::getIp).distinct().collect(Collectors.toList());
-            for(String ip: nodeIp){
-                List<DeviceIpRVO> devLl= relist.stream().filter(item->item.getIp().equals(ip)).collect(Collectors.toList());
-                if(CollectionUtil.isEmpty(devLl)){
-                    return "出错啦";
-                }
-
-                List<JSONObject> list = new ArrayList<>();
-                for(DeviceIpRVO devRVO:devLl){
-                    JSONObject dev = new JSONObject();
-                    dev.put("devIndex",devRVO.getDevIndex());
-                    dev.put("devName",devRVO.getDevName());
-                    list.add(dev);
-                }
-                JSONObject jsonObject = new JSONObject();
-                jsonObject.set("terminal", list);
-                jsonObject.set("type", 182);
-                JSONObject jsonObject1 = new JSONObject();
-                jsonObject1.set("len", 0);
-                jsonObject1.set("data", jsonObject);
-                socketClient.cancelUp(jsonObject1.toString(),ip,socketPort,devLl.size());
-            }
-        }
-        return "取消命令发送成功";
-    }
-
-    @Override
-    public String restartDev(List<String> devList) {
-        List<DeviceIpRVO> relist = lineMapper.getDevicesIp(devList);
-        if(CollUtil.isEmpty(relist)){
-            return "前置机为空";
-        }else {
-            List<String> nodeIp = relist.stream().map(DeviceIpRVO::getIp).distinct().collect(Collectors.toList());
-            for(String ip: nodeIp){
-                List<DeviceIpRVO> devLl = relist.stream().filter(item->item.getIp().equals(ip)).collect(Collectors.toList());
-                if(CollUtil.isEmpty(devLl)){
-                    return "出错啦";
-                }
-
-                List<JSONObject> list = new ArrayList<>();
-                List<String> devIn = new ArrayList<>();
-                for(DeviceIpRVO devRVO:devLl){
-                    devIn.add(devRVO.getDevIndex());
-                    JSONObject dev = new JSONObject();
-                    dev.set("devIndex", devRVO.getDevIndex());
-                    dev.set("devName", devRVO.getDevName());
-                    list.add(dev);
-                }
-
-                JSONObject jsonObject = new JSONObject();
-                jsonObject.set("terminal", list);
-                jsonObject.set("type", 181);
-                jsonObject.set("userIndex", RequestUtil.getUserIndex());
-                JSONObject jsonObject1 = new JSONObject();
-                jsonObject1.set("len", 0);
-                jsonObject1.set("data", jsonObject);
-
-                socketClient.restartDev(jsonObject1.toString(),ip,socketPort,devIn);
-            }
-        }
-        return "命令发送成功";
-    }
+//    @Override
+//    public String sentLine(ConstantValueParam.Constant param) {
+//        try {
+//            //获取根据监测点获取终端信息
+//            UpDevVO upDevVO = lineMapper.getDevInfo(param.getId());
+//            //查询前置ip
+//            String host = lineMapper.getNodeIp(upDevVO.getDevIndex(),0);
+//            //拼接属性
+//            ContValueRVO upParamVO = new ContValueRVO();
+//            ContValueVO valueVO = new ContValueVO();
+//            valueVO.setType(param.getType());
+//            valueVO.setLineid(param.getId());
+//            valueVO.setHander(param.getHander());
+//            JSONObject jsonStr = new JSONObject(valueVO);
+//            Integer len = jsonStr.toString().length();
+//            upParamVO.setLen(len.toString());
+//            upParamVO.setData(valueVO);
+//            JSONObject jsonObject = new JSONObject(upParamVO);
+//            String str = jsonObject.toString();
+//            List<UpDevVO> devList = new ArrayList<>();
+//            devList.add(upDevVO);
+//            return socketClient.sentLine(param.getIp(), str, host, socketPort, "wr", devList);
+//        } catch (Exception e) {
+//            return "获取定值失败";
+//        }
+//
+//    }
+//
+//    @Override
+//    public String sentLineData(ConstantValueParam.ValueData param) {
+//        try {
+//            //获取根据监测点获取终端信息
+//            UpDevVO upDevVO = lineMapper.getDevInfo(param.getId());
+//            //查询前置ip
+//            String host = lineMapper.getNodeIp(upDevVO.getDevIndex(),0);
+//            ContUpdateValueRVO upParamVO = new ContUpdateValueRVO();
+//            ContUpdateValueVO valueVO = new ContUpdateValueVO();
+//            valueVO.setType(param.getType());
+//            valueVO.setLineid(param.getId());
+//            valueVO.setHander(param.getHander());
+//            float[] intArr;
+//            if (StrUtil.isBlank(param.getInterValue())) {
+//                intArr = new float[0];
+//            } else {
+//                String[] valueArr = param.getInterValue().split(",");
+//                intArr = new float[valueArr.length];
+//                for (int i = 0; i < valueArr.length; i++) {
+//                    intArr[i] = Float.parseFloat(valueArr[i]);
+//                }
+//            }
+//            valueVO.setValue(intArr);
+//            JSONObject jsonStr = new JSONObject(valueVO);
+//            Integer len = jsonStr.toString().length();
+//            upParamVO.setLen(len.toString());
+//            upParamVO.setData(valueVO);
+//            JSONObject jsonObject = new JSONObject(upParamVO);
+//            String str = jsonObject.toString();
+//            List<UpDevVO> devList = new ArrayList<>();
+//            devList.add(upDevVO);
+//            return socketClient.sentLine(param.getIp(), str, host, socketPort, "wr", devList);
+//        } catch (Exception e) {
+//            return "运行失败";
+//        }
+//    }
+//
+//    @Override
+//    public String sentDev(ConstantValueParam.Constant param) {
+//        try {
+//            Line line = lineMapper.selectById(param.getId());
+//            UpDevVO upDevVO = new UpDevVO();
+//            upDevVO.setDevIndex(line.getId());
+//            upDevVO.setDevName(line.getName());
+//            String host = lineMapper.getNodeIp(line.getId(),1);
+//            ContValueRVO upParamVO = new ContValueRVO();
+//            ContValueVO valueVO = new ContValueVO();
+//            valueVO.setType(param.getType());
+//            valueVO.setIndex(param.getId());
+//            valueVO.setHander(param.getHander());
+//            JSONObject jsonStr = new JSONObject(valueVO);
+//            Integer len = jsonStr.toString().length();
+//            upParamVO.setLen(len.toString());
+//            upParamVO.setData(valueVO);
+//            JSONObject jsonObject = new JSONObject(upParamVO);
+//            String str = jsonObject.toString();
+//            List<UpDevVO> devList = new ArrayList<>();
+//            devList.add(upDevVO);
+//            return socketClient.sentDZDev(param.getIp(), str, host, socketPort, "wr", devList);
+//        } catch (Exception e) {
+//            return "获取定值失败";
+//        }
+//    }
+//
+//    @Override
+//    public String sentDevData(ConstantValueParam.ValueData param) {
+//        try {
+//            Line line = lineMapper.selectById(param.getId());
+//            UpDevVO upDevVO = new UpDevVO();
+//            upDevVO.setDevIndex(line.getId());
+//            upDevVO.setDevName(line.getName());
+//            String host = lineMapper.getNodeIp(line.getId(),1);
+//            ContUpdateDevValueRVO upParamVO = new ContUpdateDevValueRVO();
+//            ContUpdateDevValueVO valueVO = new ContUpdateDevValueVO();
+//            valueVO.setType(param.getType());
+//            valueVO.setIndex(line.getId());
+//            valueVO.setHander(String.valueOf(param.getHander()));
+//            int[] intArr;
+//            if (StrUtil.isBlank(param.getInterValue())) {
+//                intArr = new int[0];
+//            } else {
+//                String[] valueArr = param.getInterValue().split(",");
+//                intArr = new int[valueArr.length];
+//                for (int i = 0; i < valueArr.length; i++) {
+//                    intArr[i] = Integer.parseInt(valueArr[i]);
+//                }
+//            }
+//            valueVO.setInterValue(intArr);
+//            JSONObject jsonStr = new JSONObject(valueVO);
+//            Integer len = jsonStr.toString().length();
+//            upParamVO.setLen(len.toString());
+//            upParamVO.setData(valueVO);
+//            JSONObject jsonObject = new JSONObject(upParamVO);
+//            String str = jsonObject.toString();
+//
+//            List<UpDevVO> devList = new ArrayList<>();
+//            devList.add(upDevVO);
+//            return socketClient.sentDZDev(param.getIp(), str, host, socketPort, "wr", devList);
+//        } catch (Exception e) {
+//            return "运行失败";
+//        }
+//    }
+//
+//    @Override
+//    public String socketDevProperty(String devID) {
+//        String host = lineMapper.getNodeIp(devID,1);
+//        if(StrUtil.isBlank(host)){
+//            return "前置ip获取失败";
+//        }
+//        JSONObject jsonObject = new JSONObject();
+//        Map<String,String> map = new HashMap<>();
+//        map.put("type","190");
+//        map.put("index",devID);
+//        map.put("hander","1");
+//        jsonObject.set("data", map);
+//        Integer len = jsonObject.get("data").toString().length();
+//        jsonObject.set("len", len.toString());
+//        socketClient.showProperty(jsonObject.toString(),host,socketPort,RequestUtil.getLoginName());
+//        return "终端性能获取成功";
+//    }
+//
+//    @Override
+//    public String socketDevPropertyClose(String devID) {
+//        String host = lineMapper.getNodeIp(devID,1);
+//        try {
+//            JSONObject jsonObject = new JSONObject();
+//            Map<String, String> map = new HashMap<>();
+//            map.put("type", "190");
+//            map.put("index", devID);
+//            map.put("hander", "0");
+//            jsonObject.set("data", map);
+//            Integer len = jsonObject.get("data").toString().length();
+//            jsonObject.set("len", len.toString());
+//            socketClient.closeDevSocket(jsonObject.toString(),host,socketPort,RequestUtil.getLoginName());
+//            return "执行成功";
+//        }catch (Exception e){
+//            return "执行失败";
+//        }
+//    }
+//
+//    @Override
+//    public String realTimeData(String lineIndex) {
+//        //查询前置ip
+//        String host = lineMapper.getNodeIp(lineIndex,0);
+//        if(StrUtil.isBlank(host)){
+//            return "设备前置机服务器配置异常,请联系管理员";
+//        }else {
+//            JSONObject jsonObject = new JSONObject();
+//            jsonObject.set("LineId", lineIndex);
+//            jsonObject.set("type", 0);
+//            JSONObject jsonObject1 = new JSONObject();
+//            jsonObject1.set("len",0);
+//            jsonObject1.set("data",jsonObject);
+//            socketClient.realTimeData(jsonObject1.toString(),host,socketPort,lineIndex);
+//        }
+//        return "请求成功";
+//    }
+//
+//    @Override
+//    public String heartRealTimeData(String lineIndex) {
+//        JSONObject jsonObject = new JSONObject();
+//        jsonObject.set("LineId", lineIndex);
+//        jsonObject.set("type", 1);
+//        JSONObject jsonObject1 = new JSONObject();
+//        jsonObject1.set("len", 0);
+//        jsonObject1.set("data", jsonObject);
+//        String host = lineMapper.getNodeIp(lineIndex,0);
+//        socketClient.heartRealData(jsonObject1.toString(),host,socketPort,lineIndex);
+//        return "实时数据心跳请求成功";
+//    }
+//
+//    @Override
+//    public String closeRealTimeData(String lineIndex) {
+//        socketClient.closeRealData(lineIndex);
+//        return "关闭实时数据请求成功";
+//    }
+//
+//    @Override
+//    public String getDevUpgrades(List<String> list, String edIndex) {
+//        List<DeviceIpRVO> resTemlist = new ArrayList<>();
+//
+//        List<DeviceIpRVO> relist = lineMapper.getDevicesIp(list);
+//        //判断设备版本号
+//        Integer isExit = devVersionMapper.selectCount(new LambdaQueryWrapper<DevVersion>()
+//                .eq(DevVersion::getVersionId,edIndex)
+//                .in(DevVersion::getLineId,list)
+//                .eq(DevVersion::getState,1)
+//        );
+//        if (isExit > 0) {
+//            return "请勿选择相同版本号升级";
+//        }
+//        if (!CollectionUtil.isEmpty(relist)) {
+//            Version version = programVersionService.getById(edIndex);
+//            String series = version.getDevType();
+//            //判断设备是否存在相同型号
+//            for (DeviceIpRVO deviceIpRVO : relist) {
+//                if (!series.equals(deviceIpRVO.getDevSeries())) {
+//                    return "当前装置版本系列与目标版本系列不相同";
+//                }
+//            }
+//
+//            //判断是否断开
+//            if (relist.stream().filter(w -> w.getComFlag() == 0).findAny().isPresent()) {
+//                return "存在通讯中断设备";
+//            }
+//
+//
+//            Set<String> set = new HashSet<>();
+//            for (DeviceIpRVO d : relist) {
+//                set.add(d.getIp());
+//            }
+//            Iterator<String> iterator = set.iterator();
+//            while (iterator.hasNext()) {
+//                List<UpDevVO> devIndex = new ArrayList<>();
+//                DeviceIpRVO deviceIpRVO = new DeviceIpRVO();
+//                String ip = iterator.next();
+//                for (DeviceIpRVO d : relist) {
+//                    UpDevVO upDevVO = new UpDevVO();
+//                    upDevVO.setDevIndex(d.getDevIndex());
+//                    upDevVO.setDevName(d.getDevName());
+//                    if (ip.equals(d.getIp())) {
+//                        devIndex.add(upDevVO);
+//                    }
+//                }
+//                deviceIpRVO.setIp(ip);
+//                deviceIpRVO.setDevlist(devIndex);
+//                resTemlist.add(deviceIpRVO);
+//            }
+//        } else {
+//            return "存在未知错误";
+//        }
+//        for (DeviceIpRVO deviceIpRVO : resTemlist) {
+//            String ip = deviceIpRVO.getIp();
+//            List<UpDevVO> devlist = deviceIpRVO.getDevlist();
+//            UpDataVO upDataVO = new UpDataVO();
+//            UpParamVO upParamVO = new UpParamVO();
+//            upDataVO.setTerminal(devlist);
+//            upDataVO.setType("180");
+//            upDataVO.setEdIndex(edIndex);
+//            upDataVO.setUserIndex(RequestUtil.getUserIndex());
+//            JSONObject jsonstr = new JSONObject(upDataVO);
+//            Integer len = jsonstr.toString().length();
+//            upParamVO.setData(upDataVO);
+//            upParamVO.setLen(len.toString());
+//            JSONObject jsonObject = new JSONObject(upParamVO);
+//            String str = jsonObject.toString();
+//            socketClient.sentUpgrades(str, ip, socketPort, RequestUtil.getLoginName(), edIndex, devlist);
+//        }
+//        return "运行成功";
+//    }
+//
+//    @Override
+//    public String closeUpgrades(List<String> devList) {
+//        List<DeviceIpRVO> relist = lineMapper.getDevicesIp(devList);
+//        if(CollectionUtil.isEmpty(relist)){
+//            return "前置机为空";
+//        }else {
+//            List<String> nodeIp = relist.stream().map(DeviceIpRVO::getIp).distinct().collect(Collectors.toList());
+//            for(String ip: nodeIp){
+//                List<DeviceIpRVO> devLl= relist.stream().filter(item->item.getIp().equals(ip)).collect(Collectors.toList());
+//                if(CollectionUtil.isEmpty(devLl)){
+//                    return "出错啦";
+//                }
+//
+//                List<JSONObject> list = new ArrayList<>();
+//                for(DeviceIpRVO devRVO:devLl){
+//                    JSONObject dev = new JSONObject();
+//                    dev.put("devIndex",devRVO.getDevIndex());
+//                    dev.put("devName",devRVO.getDevName());
+//                    list.add(dev);
+//                }
+//                JSONObject jsonObject = new JSONObject();
+//                jsonObject.set("terminal", list);
+//                jsonObject.set("type", 182);
+//                JSONObject jsonObject1 = new JSONObject();
+//                jsonObject1.set("len", 0);
+//                jsonObject1.set("data", jsonObject);
+//                socketClient.cancelUp(jsonObject1.toString(),ip,socketPort,devLl.size());
+//            }
+//        }
+//        return "取消命令发送成功";
+//    }
+//
+//    @Override
+//    public String restartDev(List<String> devList) {
+//        List<DeviceIpRVO> relist = lineMapper.getDevicesIp(devList);
+//        if(CollUtil.isEmpty(relist)){
+//            return "前置机为空";
+//        }else {
+//            List<String> nodeIp = relist.stream().map(DeviceIpRVO::getIp).distinct().collect(Collectors.toList());
+//            for(String ip: nodeIp){
+//                List<DeviceIpRVO> devLl = relist.stream().filter(item->item.getIp().equals(ip)).collect(Collectors.toList());
+//                if(CollUtil.isEmpty(devLl)){
+//                    return "出错啦";
+//                }
+//
+//                List<JSONObject> list = new ArrayList<>();
+//                List<String> devIn = new ArrayList<>();
+//                for(DeviceIpRVO devRVO:devLl){
+//                    devIn.add(devRVO.getDevIndex());
+//                    JSONObject dev = new JSONObject();
+//                    dev.set("devIndex", devRVO.getDevIndex());
+//                    dev.set("devName", devRVO.getDevName());
+//                    list.add(dev);
+//                }
+//
+//                JSONObject jsonObject = new JSONObject();
+//                jsonObject.set("terminal", list);
+//                jsonObject.set("type", 181);
+//                jsonObject.set("userIndex", RequestUtil.getUserIndex());
+//                JSONObject jsonObject1 = new JSONObject();
+//                jsonObject1.set("len", 0);
+//                jsonObject1.set("data", jsonObject);
+//
+//                socketClient.restartDev(jsonObject1.toString(),ip,socketPort,devIn);
+//            }
+//        }
+//        return "命令发送成功";
+//    }
 
     @Override
     public void updateDevCheckTime(String devId, String thisTimeCheck, String nextTimeCheck) {

pqs-device/pq-device/pq-device-com/src/main/java/com/njcn/device/line/mapper/mapping/LineMapper.xml

@@ -1559,7 +1559,8 @@
             vg.Scale as voltageLevel,
             voltage.name as volName,
             lineDetail.Power_Flag powerFlag,
-            lineDetail.Run_Flag lineRunType
+            lineDetail.Run_Flag lineRunType,
+            lineDetail.Obj_Id objId
         FROM
             pq_line voltage,
             pq_line device,

pqs-energy/energy-api/pom.xml

@@ -55,6 +55,8 @@
             <version>1.1.0</version>
         </dependency>
 
+
+
     </dependencies>
 
 

pqs-energy/energy-boot/pom.xml

@@ -56,6 +56,12 @@
             <version>${project.version}</version>
         </dependency>
 
+        <!--mqtt相关依赖-->
+        <dependency>
+            <groupId>com.github.tocrhz</groupId>
+            <artifactId>mqtt-spring-boot-starter</artifactId>
+        </dependency>
+
         <dependency>
             <groupId>org.jetbrains</groupId>
             <artifactId>annotations</artifactId>

pqs-event/event-boot/src/main/java/com/njcn/event/service/majornetwork/Impl/AreaInfoServiceImpl.java

@@ -143,7 +143,7 @@ public class AreaInfoServiceImpl implements AreaInfoService {
                     )
                     .ge(StringUtils.isNotBlank(deviceInfoParam.getSearchBeginTime()), RmpEventDetailPO::getStartTime, DateUtil.beginOfDay(DateUtil.parse(deviceInfoParam.getSearchBeginTime())))
                     .le(StringUtils.isNotBlank(deviceInfoParam.getSearchEndTime()), RmpEventDetailPO::getStartTime, DateUtil.endOfDay(DateUtil.parse(deviceInfoParam.getSearchEndTime())))
-                    .orderByDesc(RmpEventDetailPO::getStartTime));
+                    .orderByDesc(RmpEventDetailPO::getStartTime).last("limit 100"));
             EventDetailNew eventDetailNew;
             for (RmpEventDetailPO eventDetail : eventDetails) {
                 eventDetailNew = BeanUtil.copyProperties(eventDetail, EventDetailNew.class);

pqs-event/event-common/pom.xml

@@ -36,6 +36,12 @@
             <scope>compile</scope>
         </dependency>
 
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-websocket</artifactId>
+            <version>2.7.12</version>
+        </dependency>
+
     </dependencies>
 
 

pqs-event/event-common/src/main/java/com/njcn/event/common/service/CommMonitorEventReportService.java

@@ -32,5 +32,5 @@ public interface CommMonitorEventReportService {
      * @param index
      * @return
      */
-    String saveStableEventReport(List<String> index, Map<String, AreaLineInfoVO> map);
+    String saveStableEventReport(List<String> index, Map<String, AreaLineInfoVO> map, String fileName);
 }

pqs-event/event-common/src/main/java/com/njcn/event/common/service/impl/CommMonitorEventReportServiceImpl.java

@@ -658,7 +658,7 @@ public class CommMonitorEventReportServiceImpl implements CommMonitorEventReport
     }
 
     @Override
-    public String saveStableEventReport(List<String> eventIndex, Map<String, AreaLineInfoVO> map) {
+    public String saveStableEventReport(List<String> eventIndex, Map<String, AreaLineInfoVO> map, String fileName) {
         WordUtil wordUtil = new WordUtil();
         for (String index : eventIndex) {
             RmpEventDetailPO detail = rmpEventDetailMapper.selectById(index);
@@ -709,7 +709,12 @@ public class CommMonitorEventReportServiceImpl implements CommMonitorEventReport
         }
         try {
             InputStream inputStream = wordUtil.createReport2(eventIndex);
-            String filePath = fileStorageUtil.uploadStream(inputStream, OssPath.APP_EVENT_REPORT, "暂降事件报告.docx");
+            String filePath;
+            if (Objects.isNull(fileName)) {
+                filePath = fileStorageUtil.uploadStream(inputStream, OssPath.APP_EVENT_REPORT, null);
+            } else {
+                filePath = fileStorageUtil.uploadStreamSpecifyName(inputStream, OssPath.APP_EVENT_REPORT, fileName);
+            }
             return filePath;
         } catch (IOException | InvalidFormatException e) {
             throw new RuntimeException(e);

pqs-event/event-common/src/main/java/com/njcn/event/common/service/impl/EventDetailServiceImpl.java

@@ -7,7 +7,7 @@ import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import com.github.tocrhz.mqtt.publisher.MqttPublisher;
+//import com.github.tocrhz.mqtt.publisher.MqttPublisher;
 import com.njcn.advance.api.EventCauseFeignClient;
 import com.njcn.advance.pojo.dto.EventAnalysisDTO;
 import com.njcn.common.utils.PubUtils;
@@ -18,6 +18,7 @@ import com.njcn.device.pq.pojo.po.DeptLine;
 import com.njcn.device.pq.pojo.vo.AreaLineInfoVO;
 import com.njcn.device.pq.pojo.vo.LineDetailDataVO;
 import com.njcn.event.common.mapper.RmpEventDetailMapper;
+import com.njcn.event.common.websocket.WebSocketServer;
 import com.njcn.event.pojo.vo.SendEventVO;
 import com.njcn.event.utils.EventUtil;
 import com.njcn.event.pojo.dto.EventDeatilDTO;
@@ -29,7 +30,9 @@ 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.api.UserFeignClient;
 import com.njcn.user.pojo.po.Dept;
+import com.njcn.user.pojo.po.User;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.influxdb.dto.QueryResult;
@@ -44,6 +47,7 @@ import java.math.RoundingMode;
 import java.time.Duration;
 import java.time.LocalDateTime;
 import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * @author denghuajun
@@ -57,11 +61,14 @@ public class EventDetailServiceImpl extends ServiceImpl<RmpEventDetailMapper, Rm
 
     private final InfluxDbUtils influxDbUtils;
     private final DicDataFeignClient dicDataFeignClient;
-    private final MqttPublisher publisher;
+//    private final MqttPublisher publisher;
+
+    private final WebSocketServer webSocketServer;
     private final CommTerminalGeneralClient commTerminalGeneralClient;
     private final LineFeignClient lineFeignClient;
     private final DeptLineFeignClient deptLineFeignClient;
     private final DeptFeignClient deptFeignClient;
+    private final UserFeignClient userFeignClient;
 
     private final EventCauseFeignClient eventCauseFeignClient;
     @Override
@@ -306,6 +313,9 @@ public class EventDetailServiceImpl extends ServiceImpl<RmpEventDetailMapper, Rm
                 String[] idsArray = deptInfo.getPids().split(",");
                 dept.addAll(Arrays.asList(idsArray));
             });
+            List<String> deptList = dept.stream().collect(Collectors.toList());
+
+            List<User> data = userFeignClient.getUserInfoByDeptIds(deptList).getData();
             SendEventVO vo = new SendEventVO();
             vo.setDeptList(dept);
             vo.setTime(po.getStartTime());
@@ -317,7 +327,10 @@ public class EventDetailServiceImpl extends ServiceImpl<RmpEventDetailMapper, Rm
             vo.setLineName(lineInfoVOList.get(0).getLineName());
             vo.setPowerCompany(lineInfoVOList.get(0).getGdName());
             vo.setSubstation(lineInfoVOList.get(0).getSubName());
-            publisher.send("/sendEvent", PubUtils.obj2json(vo), 1, false);
+            for (User datum : data) {
+                webSocketServer.sendMessageToUser(datum.getId(),PubUtils.obj2json(vo));
+            }
+//            publisher.send("/sendEvent", PubUtils.obj2json(vo), 1, false);
         }
     }
 

pqs-event/event-common/src/main/java/com/njcn/event/common/websocket/WebSocketConfig.java

@@ -0,0 +1,41 @@
+package com.njcn.event.common.websocket;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.socket.server.standard.ServerEndpointExporter;
+import org.springframework.web.socket.server.standard.ServletServerContainerFactoryBean;
+
+/**
+ * Description:
+ * Date: 2024/12/13  15:09【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+@Configuration
+public class WebSocketConfig {
+
+    @Bean
+    public ServerEndpointExporter serverEndpointExporter() {
+        return new ServerEndpointExporter();
+    }
+
+    /**
+     * 通信文本消息和二进制缓存区大小
+     * 避免对接 第三方 报文过大时，Websocket 1009 错误
+     *
+     * @return
+     */
+
+    @Bean
+    public ServletServerContainerFactoryBean createWebSocketContainer() {
+        ServletServerContainerFactoryBean container = new ServletServerContainerFactoryBean();
+        // 在此处设置bufferSize
+        container.setMaxTextMessageBufferSize(10240000);
+        container.setMaxBinaryMessageBufferSize(10240000);
+        container.setMaxSessionIdleTimeout(15 * 60000L);
+        return container;
+    }
+
+
+}

pqs-event/event-common/src/main/java/com/njcn/event/common/websocket/WebSocketServer.java

@@ -0,0 +1,147 @@
+package com.njcn.event.common.websocket;
+
+import cn.hutool.core.util.StrUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import javax.websocket.*;
+import javax.websocket.server.PathParam;
+import javax.websocket.server.ServerEndpoint;
+import java.io.IOException;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Description:
+ * Date: 2024/12/13  15:11【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+@Slf4j
+@Component
+@ServerEndpoint(value = "/event/{userId}")
+public class WebSocketServer {
+
+    private static final ConcurrentHashMap<String, Session> sessions = new ConcurrentHashMap<>();
+    private static final ConcurrentHashMap<String, Long> lastHeartbeatTime = new ConcurrentHashMap<>();
+    private static final ConcurrentHashMap<String, ScheduledExecutorService> heartbeatExecutors = new ConcurrentHashMap<>();
+    private static final long HEARTBEAT_TIMEOUT = 60; // 60秒超时
+
+    @OnOpen
+    public void onOpen(Session session, @PathParam("userId") String userId) {
+        if (StrUtil.isNotBlank(userId)) {
+            sessions.put(userId, session);
+            lastHeartbeatTime.put(userId, System.currentTimeMillis());
+            sendMessage(session, "连接成功");
+            System.out.println("用户 " + userId + " 已连接");
+
+            // 启动心跳检测
+            startHeartbeat(session, userId);
+        } else {
+            try {
+                session.close(new CloseReason(CloseReason.CloseCodes.VIOLATED_POLICY, "用户ID不能为空"));
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @OnMessage
+    public void onMessage(String message, Session session, @PathParam("userId") String userId) {
+        if ("alive".equalsIgnoreCase(message)) {
+            // 更新最后心跳时间
+            lastHeartbeatTime.put(userId, System.currentTimeMillis());
+            sendMessage(session, "over");
+        } else {
+            // 处理业务消息
+            System.out.println("收到用户 " + userId + " 的消息: " + message);
+            // TODO: 处理业务逻辑
+        }
+    }
+
+    @OnClose
+    public void onClose(Session session, CloseReason closeReason, @PathParam("userId") String userId) {
+        // 移除用户并取消心跳检测
+        sessions.remove(userId);
+        lastHeartbeatTime.remove(userId);
+        ScheduledExecutorService executor = heartbeatExecutors.remove(userId);
+        if (executor != null) {
+            executor.shutdownNow();
+        }
+        System.out.println("用户 " + userId + " 已断开连接，状态码: " + closeReason.getCloseCode());
+    }
+
+    @OnError
+    public void onError(Session session, Throwable throwable, @PathParam("userId") String userId) {
+        System.out.println("用户 " + userId + " 发生错误: " + throwable.getMessage());
+        try {
+            session.close(new CloseReason(CloseReason.CloseCodes.UNEXPECTED_CONDITION, "发生错误"));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void sendMessageToUser(String userId, String message) {
+        Session session = sessions.get(userId);
+        if (session != null && session.isOpen()) {
+            try {
+                session.getBasicRemote().sendText(message);
+            } catch (IOException e) {
+                System.out.println("发送消息给用户 " + userId + " 失败: " + e.getMessage());
+            }
+        } else {
+            System.out.println("webSocket用户 " + userId + " 不在线或会话已关闭");
+        }
+    }
+
+    private final Object lock = new Object();
+
+    public void sendMessageToAll(String message) {
+        sessions.forEach((userId, session) -> {
+            System.out.println("给用户推送消息" + userId);
+            if (session.isOpen()) {
+                synchronized (lock) {
+                    try {
+                        session.getBasicRemote().sendText(message);
+                    } catch (IOException e) {
+                        System.out.println("发送消息给用户 " + userId + " 失败: " + e.getMessage());
+                    }
+                }
+            }
+        });
+    }
+
+    private void sendMessage(Session session, String message) {
+        try {
+            session.getBasicRemote().sendText(message);
+        } catch (IOException e) {
+            System.out.println("发送消息失败: " + e.getMessage());
+        }
+    }
+
+    private void startHeartbeat(Session session, String userId) {
+        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
+        heartbeatExecutors.put(userId, executor);
+
+        // 定期检查心跳
+        executor.scheduleAtFixedRate(() -> {
+            long lastTime = lastHeartbeatTime.getOrDefault(userId, 0L);
+            long currentTime = System.currentTimeMillis();
+
+            // 如果超过30秒没有收到心跳
+            if (currentTime - lastTime > HEARTBEAT_TIMEOUT * 1000) {
+                try {
+                    System.out.println("用户 " + userId + " 心跳超时，关闭连接");
+                    session.close(new CloseReason(CloseReason.CloseCodes.NORMAL_CLOSURE, "心跳超时"));
+                } catch (IOException e) {
+                    System.out.println("关闭用户 " + userId + " 连接时出错: " + e.getMessage());
+                }
+                executor.shutdown();
+                heartbeatExecutors.remove(userId);
+            }
+        }, 0, 5, TimeUnit.SECONDS); // 每5秒检查一次
+    }
+}

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

@@ -1,12 +1,20 @@
 package com.njcn.harmonic.service.impl;
 
+import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.njcn.common.utils.HarmonicTimesUtil;
 import com.njcn.common.utils.PubUtils;
 import com.njcn.device.pq.api.LineFeignClient;
 import com.njcn.device.biz.pojo.po.Overlimit;
+import com.njcn.harmonic.common.mapper.RStatDataHarmRateVDMapper;
+import com.njcn.harmonic.common.mapper.RStatDataIDMapper;
 import com.njcn.harmonic.constant.Param;
+import com.njcn.harmonic.mapper.RStatDataHarmRateIDMapper;
 import com.njcn.harmonic.pojo.param.HarmInHarmParam;
+import com.njcn.harmonic.pojo.po.day.RStatDataHarmrateIDPO;
+import com.njcn.harmonic.pojo.po.day.RStatDataHarmrateVDPO;
+import com.njcn.harmonic.pojo.po.day.RStatDataIDPO;
 import com.njcn.harmonic.pojo.vo.HarmInHarmVO;
 import com.njcn.harmonic.service.HarmInHarmService;
 import com.njcn.influx.pojo.constant.InfluxDBTableConstant;
@@ -21,6 +29,7 @@ import org.springframework.stereotype.Service;
 
 import java.math.BigDecimal;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
 
@@ -41,7 +50,8 @@ public class HarmInHarmServiceImpl implements HarmInHarmService {
 
     private final IDataIService dataIService;
 
-
+    private final RStatDataHarmRateVDMapper dataHarmRateVDMapper;
+    private final RStatDataIDMapper dataIDMapper;
     @Override
     public HarmInHarmVO getHarmInHarmData(HarmInHarmParam harmInHarmParam) {
         HarmInHarmVO harmInHarmVO = new HarmInHarmVO();
@@ -77,33 +87,70 @@ public class HarmInHarmServiceImpl implements HarmInHarmService {
         List<Float> floatList = new ArrayList<>();
         if (StrUtil.isNotBlank(lineId)) {
             if (harmState == 0) {
-                InfluxQueryWrapper influxQueryWrapper = new InfluxQueryWrapper(DataHarmRateV.class);
-                influxQueryWrapper.meanSamePrefixAndSuffix("v_", "", HarmonicTimesUtil.harmonicTimesList(2, 50, 1))
-                        .between(DataHarmRateV::getTime, startTime, endTime)
-                        .eq(DataHarmRateV::getLineId, lineId)
-                        .eq(DataHarmRateV::getValueType, InfluxDBTableConstant.CP95)
-                        .ne(DataHarmRateV::getPhaseType, InfluxDBTableConstant.PHASE_TYPE_T);
-                DataHarmRateV dataHarmRateV = dataHarmRateVService.getMeanAllTimesData(influxQueryWrapper);
-                if (Objects.nonNull(dataHarmRateV)) {
+//                InfluxQueryWrapper influxQueryWrapper = new InfluxQueryWrapper(DataHarmRateV.class);
+//                influxQueryWrapper.meanSamePrefixAndSuffix("v_", "", HarmonicTimesUtil.harmonicTimesList(2, 50, 1))
+//                        .between(DataHarmRateV::getTime, startTime, endTime)
+//                        .eq(DataHarmRateV::getLineId, lineId)
+//                        .eq(DataHarmRateV::getValueType, InfluxDBTableConstant.CP95)
+//                        .ne(DataHarmRateV::getPhaseType, InfluxDBTableConstant.PHASE_TYPE_T);
+//                DataHarmRateV dataHarmRateV = dataHarmRateVService.getMeanAllTimesData(influxQueryWrapper);
+//                if (Objects.nonNull(dataHarmRateV)) {
+//                    for (int i = 2; i < 51; i++) {
+//                        floatList.add(PubUtils.getValueByMethodDouble(dataHarmRateV, "getV", i).floatValue());
+//                    }
+//                }else {
+//                    for (int i = 2; i < 51; i++) {
+//                        floatList.add(null);
+//                    }
+//                }
+                //转换成查mysql统计数据，分钟数据没有值
+                List<RStatDataHarmrateVDPO> harmV = dataHarmRateVDMapper.selectList(new LambdaQueryWrapper<RStatDataHarmrateVDPO>()
+                        .eq(RStatDataHarmrateVDPO::getLineId, lineId)
+                        .eq(RStatDataHarmrateVDPO::getValueType,"CP95")
+                        .in(RStatDataHarmrateVDPO::getPhaseType, Arrays.asList("A","B","C"))
+                        .ge(RStatDataHarmrateVDPO::getTime, DateUtil.beginOfDay(DateUtil.parse(startTime)))
+                        .le(RStatDataHarmrateVDPO::getTime, DateUtil.endOfDay(DateUtil.parse(endTime)))
+                );
+
+                if (Objects.nonNull(harmV)) {
                     for (int i = 2; i < 51; i++) {
-                        floatList.add(PubUtils.getValueByMethodDouble(dataHarmRateV, "getV", i).floatValue());
+                        floatList.add(PubUtils.getValueByMethodDouble(harmV,RStatDataHarmrateVDPO.class, "getV", i).floatValue());
                     }
                 }else {
                     for (int i = 2; i < 51; i++) {
                         floatList.add(null);
                     }
                 }
+
             } else {
-                InfluxQueryWrapper influxQueryWrapper = new InfluxQueryWrapper(DataI.class);
-                influxQueryWrapper.meanSamePrefixAndSuffix("i_", "", HarmonicTimesUtil.harmonicTimesList(2, 50, 1))
-                        .between(DataHarmRateV::getTime, startTime, endTime)
-                        .eq(DataHarmRateV::getLineId, lineId)
-                        .eq(DataHarmRateV::getValueType, InfluxDBTableConstant.CP95)
-                        .ne(DataHarmRateV::getPhaseType, InfluxDBTableConstant.PHASE_TYPE_T);
-                DataI dataI = dataIService.getMeanAllTimesData(influxQueryWrapper);
-                if (Objects.nonNull(dataI)) {
+//                InfluxQueryWrapper influxQueryWrapper = new InfluxQueryWrapper(DataI.class);
+//                influxQueryWrapper.meanSamePrefixAndSuffix("i_", "", HarmonicTimesUtil.harmonicTimesList(2, 50, 1))
+//                        .between(DataHarmRateV::getTime, startTime, endTime)
+//                        .eq(DataHarmRateV::getLineId, lineId)
+//                        .eq(DataHarmRateV::getValueType, InfluxDBTableConstant.CP95)
+//                        .ne(DataHarmRateV::getPhaseType, InfluxDBTableConstant.PHASE_TYPE_T);
+//                DataI dataI = dataIService.getMeanAllTimesData(influxQueryWrapper);
+//                if (Objects.nonNull(dataI)) {
+//                    for (int i = 2; i < 51; i++) {
+//                        floatList.add(PubUtils.getValueByMethodDouble(dataI, "getI", i).floatValue());
+//                    }
+//                }else {
+//                    for (int i = 2; i < 51; i++) {
+//                        floatList.add(null);
+//                    }
+//                }
+
+                //转换成查mysql统计数据，分钟数据没有值
+                List<RStatDataIDPO> harmI = dataIDMapper.selectList(new LambdaQueryWrapper<RStatDataIDPO>()
+                        .eq(RStatDataIDPO::getLineId, lineId)
+                        .eq(RStatDataIDPO::getValueType,"CP95")
+                        .in(RStatDataIDPO::getPhaseType, Arrays.asList("A","B","C"))
+                        .ge(RStatDataIDPO::getTime, DateUtil.beginOfDay(DateUtil.parse(startTime)))
+                        .le(RStatDataIDPO::getTime, DateUtil.endOfDay(DateUtil.parse(endTime)))
+                );
+                if (Objects.nonNull(harmI)) {
                     for (int i = 2; i < 51; i++) {
-                        floatList.add(PubUtils.getValueByMethodDouble(dataI, "getI", i).floatValue());
+                        floatList.add(PubUtils.getValueByMethodDouble(harmI,RStatDataIDPO.class, "getI", i).floatValue());
                     }
                 }else {
                     for (int i = 2; i < 51; i++) {

pqs-system/system-boot/src/main/java/com/njcn/system/timer/tasks/FrontLogsCleanTaskRunner.java

@@ -37,7 +37,7 @@ public class FrontLogsCleanTaskRunner implements TimerTaskRunner {
         QueryWrapper<PqFrontLogsChild> queryWrapper = new QueryWrapper<>();
         QueryWrapper<PqFrontLogs> pqFrontLogsQueryWrapper = new QueryWrapper<>();
         LocalDate calDate;
-        if(StrUtil.isBlank(date)){
+        if(!StrUtil.isBlank(date)){
             calDate = LocalDate.parse(date, DatePattern.NORM_DATE_FORMATTER);
 
         }else {

pqs-user/user-boot/src/main/java/com/njcn/user/service/impl/UserServiceImpl.java

@@ -490,26 +490,28 @@ public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IU
     @Override
     public List<UserVO> getFormalUserList() {
         List<UserVO> users = new ArrayList<>();
-        Role roleByCode1 = roleService.getRoleByCode(AppRoleEnum.APP_VIP_USER.getCode());
-        Role roleByCode2 = roleService.getRoleByCode(AppRoleEnum.BXS_USER.getCode());
-        Role roleByCode3 = roleService.getRoleByCode(AppRoleEnum.REGULAR_USER_8000.getCode());
-        Role roleByCode4 = roleService.getRoleByCode(AppRoleEnum.REGULAR_USER.getCode());
+        Role roleByCode1 = roleService.getRoleByCode(AppRoleEnum.ENGINEERING_USER.getCode());
+        Role roleByCode2 = roleService.getRoleByCode(AppRoleEnum.MARKET_USER.getCode());
         List<UserRole> userRoles = userRoleMapper.selectUserRole(
                 Stream.of(roleByCode1.getId()
                         ,roleByCode2.getId()
-                        ,roleByCode3.getId()
-                        ,roleByCode4.getId()
                 ).collect(Collectors.toList()));
         List<String> collect = userRoles.stream().map(UserRole::getUserId).distinct().collect(Collectors.toList());
-        List<User> users1 = this.listByIds(collect);
+
+        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.in(User::getState, Arrays.asList(1,2,4,5))
+                .in(User::getType,Arrays.asList(2,3));
+        List<User> users1 = this.list(queryWrapper);
         if (CollectionUtil.isNotEmpty(users1)) {
             users1.forEach(item->{
-                if (item.getState() == 1) {
-                    UserVO userVO = new UserVO();
-                    userVO.setId(item.getId());
-                    userVO.setName(item.getName());
-                    users.add(userVO);
+                //剔除工程 营销用户
+                if (collect.contains(item.getId())) {
+                    return;
                 }
+                UserVO userVO = new UserVO();
+                userVO.setId(item.getId());
+                userVO.setName(item.getName());
+                users.add(userVO);
             });
         }
         return users;