工业库报警 和 化验室报警 的多指标报警，也关联具体的化验项目相关逻辑处理

slibra-quartz/src/main/java/com/slibra/quartz/task/AsyncTask.java

@@ -131,7 +131,7 @@ public class AsyncTask {
                 //2025年02月20日10:52:31 在具体的报警类型中增加新的判断 仪表故障 数据异常等
                 this.handleSZWarning(tXinyiIndustry, normConfig);
                 //2024年5月28日14:14:26  下面是新增的 生化报警处理
-//                this.handleSHWarning(tXinyiIndustry, normConfig, xinyiCalculate);
+                this.handleSHWarning(tXinyiIndustry, normConfig, xinyiCalculate);
             }else{
                 //查询是否有正在工业库的同步任务失败的报警，有的话，什么都不做； 没有的话，新增该类型报警
                 if(CollectionUtils.isEmpty(tXinyiWarningRecords)){
@@ -1571,11 +1571,15 @@ public class AsyncTask {
         //下面是处理多个指标的 【断点】和 连续不变的报警
         //断点
         Date nowDate = DateUtils.getNowDate();
+        //2025年02月28日13:45:49 逻辑调整：多指标断点/联系不变 也要记录对应的化验类型 所以下面可以查询出来多个
         TXinyiWarningRecord warningRecord = TXinyiWarningRecord.builder().symbol(BusinessEnum.WarningSymbolEnum.YBGZ_DD_MORE_GYK.getCode()).status(0).build();
         List<TXinyiWarningRecord> tXinyiWarningRecords = this.xinyiWarningRecordMapper.selectTXinyiWarningRecordList(warningRecord);
         if(breakpointCount < 1){//恢复正常 关闭多个断点报警
+            //关闭之前的多个 多指标断点报警
             if(!CollectionUtils.isEmpty(tXinyiWarningRecords)){
-                closeWarning(tXinyiWarningRecords.get(0));
+                for (TXinyiWarningRecord tXinyiWarningRecord : tXinyiWarningRecords) {
+                    closeWarning(tXinyiWarningRecord);
+                }
             }
         }else if(breakpointCount == 1){//只有单个的断点
             TXinyiWarningRecord warningRecordBreakPointOne = breakPointList.get(0);
@@ -1618,15 +1622,18 @@ public class AsyncTask {
                 log.error("处理是否后续报警的报警类型是不支持的类型");
                 throw new ServiceException("处理是否后续报警的报警类型是不支持的类型");
             }
+            //关闭之前的多个 多指标断点报警
             if(!CollectionUtils.isEmpty(tXinyiWarningRecords)){
-                closeWarning(tXinyiWarningRecords.get(0));
+                for (TXinyiWarningRecord tXinyiWarningRecord : tXinyiWarningRecords) {
+                    closeWarning(tXinyiWarningRecord);
+                }
             }
         }else{
             //将其他类型的报警全部关闭
             //2025年02月27日17:09:56 此场景不关闭其他报警
 //            closeOtherWarningsBySymbol(BusinessEnum.WarningSymbolEnum.YBGZ_DD_MORE_GYK.getCode());
             //再新增新的类型的报警
-            if(CollectionUtils.isEmpty(tXinyiWarningRecords)){
+            /*if(CollectionUtils.isEmpty(tXinyiWarningRecords)){
                 //插入该类型报警
                 warningRecord.setType(0);
                 String msg = BusinessEnum.WarningSymbolEnum.YBGZ_DD_MORE_GYK.getMsg();
@@ -1643,6 +1650,44 @@ public class AsyncTask {
                 log.info("工业库报警的时候，发现存在仪表故障（断点多个指标）的报警，并且已经有该类型报警了，不做任何处理");
             }
             log.info("工业库报警的时候，发现存在仪表故障（断点多个指标）的报警，其他报警不再处理");
+            return;*/
+            //逻辑调整：要按指标报多指标断点  需要当前的集合和原来的集合判断，新的报警增加，如果之前有了报警则不处理
+            if(CollectionUtils.isEmpty(tXinyiWarningRecords)){
+                //新增的断点的数据全部都报警
+                for (TXinyiWarningRecord tXinyiWarningRecord : breakPointList) {
+                    //原来集合里存放的都是单指标异常 下面2个值需要重新赋值
+                    tXinyiWarningRecord.setReason(tXinyiWarningRecord.getCategory() + BusinessEnum.WarningSymbolEnum.YBGZ_DD_MORE_GYK.getCode());
+                    tXinyiWarningRecord.setSymbol(BusinessEnum.WarningSymbolEnum.YBGZ_DD_MORE_GYK.getCode());
+                    this.xinyiWarningRecordMapper.insertTXinyiWarningRecord(tXinyiWarningRecord);
+                    //同时处理决策 不用调用大模型，本地处理问答
+                    addChatRecordByBreakPointsMore(tXinyiWarningRecord, tXinyiIndustry, normConfig);
+                }
+            }else{//之前存在报警了 所以需要2个集合数据进行匹配，如果新的和原来的一样则不用做任何操作【持续报警】；如果不一样，则新的要报警，老报警要关闭
+                List<TXinyiWarningRecord> breakPointListNew = new ArrayList<>(breakPointList);//断点集合[需要新增的]
+                breakPointListNew.removeAll(tXinyiWarningRecords);
+                List<TXinyiWarningRecord> breakPointListClose = new ArrayList<>(tXinyiWarningRecords);//断点集合[需要关闭的]   还有2这重叠的，这种重叠的，是不需要做任何操作的，持续报警
+                breakPointListClose.removeAll(breakPointList);
+                //插入新的报警
+                if(!CollectionUtils.isEmpty(breakPointListNew)){
+                    for (TXinyiWarningRecord tXinyiWarningRecord : breakPointListNew) {
+                        //新插入
+                        //原来集合里存放的都是单指标异常 下面2个值需要重新赋值
+                        tXinyiWarningRecord.setReason(tXinyiWarningRecord.getCategory() + BusinessEnum.WarningSymbolEnum.YBGZ_DD_MORE_GYK.getCode());
+                        tXinyiWarningRecord.setSymbol(BusinessEnum.WarningSymbolEnum.YBGZ_DD_MORE_GYK.getCode());
+                        this.xinyiWarningRecordMapper.insertTXinyiWarningRecord(tXinyiWarningRecord);
+                        //同时处理决策 不用调用大模型，本地处理问答
+                        addChatRecordByBreakPointsMore(tXinyiWarningRecord, tXinyiIndustry, normConfig);
+                    }
+                }
+                //关闭老的报警
+                if(!CollectionUtils.isEmpty(breakPointListClose)){
+                    for (TXinyiWarningRecord tXinyiWarningRecord : breakPointListClose) {
+                        //老的报警，新的没有出现，关闭
+                        closeWarning(tXinyiWarningRecord);
+                    }
+                }
+            }
+            //如果出现多指标问题，后续的报警不再处理
             return;
         }
 
@@ -1650,8 +1695,11 @@ public class AsyncTask {
         TXinyiWarningRecord warningRecordNoChangeMore = TXinyiWarningRecord.builder().symbol(BusinessEnum.WarningSymbolEnum.YBGZ_LX_MORE.getCode()).status(0).build();
         List<TXinyiWarningRecord> tXinyiWarningNoChangeMoreRecords = this.xinyiWarningRecordMapper.selectTXinyiWarningRecordList(warningRecordNoChangeMore);
         if(noChange < 1){//恢复正常，关闭多个连续不变报警
+            //关闭之前的多个 多指标断点报警
             if(!CollectionUtils.isEmpty(tXinyiWarningNoChangeMoreRecords)){
-                closeWarning(tXinyiWarningNoChangeMoreRecords.get(0));
+                for (TXinyiWarningRecord tXinyiWarningRecord : tXinyiWarningNoChangeMoreRecords) {
+                    closeWarning(tXinyiWarningRecord);
+                }
             }
         }else if(noChange == 1){
             TXinyiWarningRecord noChangeWarningRecord = noChangeList.get(0);
@@ -1694,15 +1742,18 @@ public class AsyncTask {
                 log.error("处理是否后续报警的报警类型是不支持的类型");
                 throw new ServiceException("处理是否后续报警的报警类型是不支持的类型");
             }
+            //关闭之前的多个 多指标断点报警
             if(!CollectionUtils.isEmpty(tXinyiWarningNoChangeMoreRecords)){
-                closeWarning(tXinyiWarningNoChangeMoreRecords.get(0));
+                for (TXinyiWarningRecord tXinyiWarningRecord : tXinyiWarningNoChangeMoreRecords) {
+                    closeWarning(tXinyiWarningRecord);
+                }
             }
         }else{
             //将其他类型的报警全部关闭
             //2025年02月27日17:09:56 此场景不关闭其他报警
 //            closeOtherWarningsBySymbol(BusinessEnum.WarningSymbolEnum.YBGZ_LX_MORE.getCode());
             //触发 多个连续不变报警
-            if(CollectionUtils.isEmpty(tXinyiWarningNoChangeMoreRecords)){
+            /*if(CollectionUtils.isEmpty(tXinyiWarningNoChangeMoreRecords)){
                 //插入该类型报警
                 warningRecordNoChangeMore.setType(0);
                 String msg = BusinessEnum.WarningSymbolEnum.YBGZ_LX_MORE.getMsg();
@@ -1719,6 +1770,44 @@ public class AsyncTask {
                 log.info("工业库报警的时候，发现存在仪表故障（连续不变多个指标）的报警，并且已经有该类型报警了，不做任何处理");
             }
             log.info("发现存在仪表故障（连续不变多个指标）的报警，其他报警不再处理");
+            return;*/
+            //逻辑调整：要按指标报多指标断点  需要当前的集合和原来的集合判断，新的报警增加，如果之前有了报警则不处理
+            if(CollectionUtils.isEmpty(tXinyiWarningNoChangeMoreRecords)){
+                //新增的断点的数据全部都报警
+                for (TXinyiWarningRecord tXinyiWarningRecord : noChangeList) {
+                    //原来集合里存放的都是单指标异常 下面2个值需要重新赋值
+                    tXinyiWarningRecord.setReason(tXinyiWarningRecord.getCategory() + BusinessEnum.WarningSymbolEnum.YBGZ_LX_MORE.getCode());
+                    tXinyiWarningRecord.setSymbol(BusinessEnum.WarningSymbolEnum.YBGZ_LX_MORE.getCode());
+                    this.xinyiWarningRecordMapper.insertTXinyiWarningRecord(tXinyiWarningRecord);
+                    //同时处理决策 不用调用大模型，本地处理问答
+                    addChatRecordByBreakPointsMore(tXinyiWarningRecord, tXinyiIndustry, normConfig);
+                }
+            }else{//之前存在报警了 所以需要2个集合数据进行匹配，如果新的和原来的一样则不用做任何操作【持续报警】；如果不一样，则新的要报警，老报警要关闭
+                List<TXinyiWarningRecord> noChangeListNew = new ArrayList<>(noChangeList);//断点集合[需要新增的]
+                noChangeListNew.removeAll(tXinyiWarningNoChangeMoreRecords);
+                List<TXinyiWarningRecord> noChangeListClose = new ArrayList<>(tXinyiWarningNoChangeMoreRecords);//断点集合[需要关闭的]   还有2这重叠的，这种重叠的，是不需要做任何操作的，持续报警
+                noChangeListClose.removeAll(noChangeList);
+                //插入新的报警
+                if(!CollectionUtils.isEmpty(noChangeListNew)){
+                    for (TXinyiWarningRecord tXinyiWarningRecord : noChangeListNew) {
+                        //新插入
+                        //原来集合里存放的都是单指标异常 下面2个值需要重新赋值
+                        tXinyiWarningRecord.setReason(tXinyiWarningRecord.getCategory() + BusinessEnum.WarningSymbolEnum.YBGZ_LX_MORE.getCode());
+                        tXinyiWarningRecord.setSymbol(BusinessEnum.WarningSymbolEnum.YBGZ_LX_MORE.getCode());
+                        this.xinyiWarningRecordMapper.insertTXinyiWarningRecord(tXinyiWarningRecord);
+                        //同时处理决策 不用调用大模型，本地处理问答
+                        addChatRecordByBreakPointsMore(tXinyiWarningRecord, tXinyiIndustry, normConfig);
+                    }
+                }
+                //关闭老的报警
+                if(!CollectionUtils.isEmpty(noChangeListClose)){
+                    for (TXinyiWarningRecord tXinyiWarningRecord : noChangeListClose) {
+                        //老的报警，新的没有出现，关闭
+                        closeWarning(tXinyiWarningRecord);
+                    }
+                }
+            }
+            //如果出现多指标问题，后续的报警不再处理
             return;
         }
 
@@ -4110,8 +4199,11 @@ public class AsyncTask {
         TXinyiWarningRecord warningRecord = TXinyiWarningRecord.builder().symbol(BusinessEnum.WarningSymbolEnum.YBGZ_DD_MORE_HYS.getCode()).status(0).build();
         List<TXinyiWarningRecord> tXinyiWarningRecords = this.xinyiWarningRecordMapper.selectTXinyiWarningRecordList(warningRecord);
         if(breakpointCount < 1){//恢复正常 关闭多个断点报警
+            //2025年02月28日15:18:30 即使多指标断点，也是按具体分类报警  关闭多个报警
             if(!CollectionUtils.isEmpty(tXinyiWarningRecords)){
-                closeWarning(tXinyiWarningRecords.get(0));
+                for (TXinyiWarningRecord tXinyiWarningRecord : tXinyiWarningRecords) {
+                    closeWarning(tXinyiWarningRecord);
+                }
             }
         }else if(breakpointCount == 1){//只有单个的断点
             TXinyiWarningRecord warningRecordBreakPointOne = breakPointList.get(0);
@@ -4138,15 +4230,18 @@ public class AsyncTask {
                 ecczlxyExecute = false;
             if(ROBOT_CS_AD.getCode().equals(category))
                 csADExecute = false;
+            //2025年02月28日15:18:30 即使多指标断点，也是按具体分类报警  关闭多个报警
             if(!CollectionUtils.isEmpty(tXinyiWarningRecords)){
-                closeWarning(tXinyiWarningRecords.get(0));
+                for (TXinyiWarningRecord tXinyiWarningRecord : tXinyiWarningRecords) {
+                    closeWarning(tXinyiWarningRecord);
+                }
             }
         }else{
             //将其他类型的报警全部关闭
             //2025年02月27日17:35:37 此场景不关闭其他报警
 //            closeOtherWarningsBySymbol(BusinessEnum.WarningSymbolEnum.YBGZ_DD_MORE_HYS.getCode());
             //再新增新的类型的报警
-            if(CollectionUtils.isEmpty(tXinyiWarningRecords)){
+            /*if(CollectionUtils.isEmpty(tXinyiWarningRecords)){
                 //插入该类型报警
                 warningRecord.setType(0);
                 String msg = BusinessEnum.WarningSymbolEnum.YBGZ_DD_MORE_HYS.getMsg();
@@ -4163,6 +4258,44 @@ public class AsyncTask {
                 log.info("化验室报警的时候，发现存在仪表故障（断点多个指标）的报警，并且已经有该类型报警了，不做任何处理");
             }
             log.info("化验室报警的时候，发现存在仪表故障（断点多个指标）的报警，其他报警不再处理");
+            return;*/
+            //逻辑调整：要按指标报多指标断点  需要当前的集合和原来的集合判断，新的报警增加，如果之前有了报警则不处理
+            if(CollectionUtils.isEmpty(tXinyiWarningRecords)){
+                //新增的断点的数据全部都报警
+                for (TXinyiWarningRecord tXinyiWarningRecord : breakPointList) {
+                    //原来集合里存放的都是单指标异常 下面2个值需要重新赋值
+                    tXinyiWarningRecord.setReason(tXinyiWarningRecord.getCategory() + BusinessEnum.WarningSymbolEnum.YBGZ_DD_MORE_HYS.getCode());
+                    tXinyiWarningRecord.setSymbol(BusinessEnum.WarningSymbolEnum.YBGZ_DD_MORE_HYS.getCode());
+                    this.xinyiWarningRecordMapper.insertTXinyiWarningRecord(tXinyiWarningRecord);
+                    //同时处理决策 不用调用大模型，本地处理问答
+                    addChatRecordByBreakPointsMore(tXinyiWarningRecord, tXinyiIndustry, normConfig);
+                }
+            }else{//之前存在报警了 所以需要2个集合数据进行匹配，如果新的和原来的一样则不用做任何操作【持续报警】；如果不一样，则新的要报警，老报警要关闭
+                List<TXinyiWarningRecord> breakPointListNew = new ArrayList<>(breakPointList);//断点集合[需要新增的]
+                breakPointListNew.removeAll(tXinyiWarningRecords);
+                List<TXinyiWarningRecord> breakPointListClose = new ArrayList<>(tXinyiWarningRecords);//断点集合[需要关闭的]   还有2这重叠的，这种重叠的，是不需要做任何操作的，持续报警
+                breakPointListClose.removeAll(breakPointList);
+                //插入新的报警
+                if(!CollectionUtils.isEmpty(breakPointListNew)){
+                    for (TXinyiWarningRecord tXinyiWarningRecord : breakPointListNew) {
+                        //新插入
+                        //原来集合里存放的都是单指标异常 下面2个值需要重新赋值
+                        tXinyiWarningRecord.setReason(tXinyiWarningRecord.getCategory() + BusinessEnum.WarningSymbolEnum.YBGZ_DD_MORE_HYS.getCode());
+                        tXinyiWarningRecord.setSymbol(BusinessEnum.WarningSymbolEnum.YBGZ_DD_MORE_HYS.getCode());
+                        this.xinyiWarningRecordMapper.insertTXinyiWarningRecord(tXinyiWarningRecord);
+                        //同时处理决策 不用调用大模型，本地处理问答
+                        addChatRecordByBreakPointsMore(tXinyiWarningRecord, tXinyiIndustry, normConfig);
+                    }
+                }
+                //关闭老的报警
+                if(!CollectionUtils.isEmpty(breakPointListClose)){
+                    for (TXinyiWarningRecord tXinyiWarningRecord : breakPointListClose) {
+                        //老的报警，新的没有出现，关闭
+                        closeWarning(tXinyiWarningRecord);
+                    }
+                }
+            }
+            //如果出现多指标问题，后续的报警不再处理
             return;
         }
 

slibra-system/src/main/java/com/slibra/business/domain/TXinyiWarningRecord.java

@@ -1,9 +1,11 @@
 package com.slibra.business.domain;
 
 import java.math.BigDecimal;
+import java.util.ArrayList;
 import java.util.Date;
 import java.util.Objects;
 
+import com.alibaba.fastjson2.JSON;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.slibra.common.enums.BusinessEnum;
@@ -155,8 +157,43 @@ public class TXinyiWarningRecord extends BaseEntity
 
     public static void main(String[] args) {
         System.out.println(BusinessEnum.WarningSymbolEnum.getMsgByCode(1));
+        TXinyiWarningRecord build1 = TXinyiWarningRecord.builder().id(1L).category("a").build();
+        TXinyiWarningRecord build2 = TXinyiWarningRecord.builder().id(2L).category("b").build();
+        TXinyiWarningRecord build3 = TXinyiWarningRecord.builder().id(1L).category("c").build();
+        TXinyiWarningRecord build4 = TXinyiWarningRecord.builder().id(2L).category("a").build();
+        ArrayList<TXinyiWarningRecord> list1 = new ArrayList<>();
+        list1.add(build1);
+        list1.add(build2);
+        ArrayList<TXinyiWarningRecord> list2 = new ArrayList<>();
+        list2.add(build3);
+        list2.add(build4);
+
+        ArrayList<Object> list1Only = new ArrayList<>(list1);
+        list1Only.removeAll(list2);
+        System.out.println(JSON.toJSONString(list1Only));
+
+        ArrayList<Object> list2Only = new ArrayList<>(list2);
+        list2Only.removeAll(list1);
+        System.out.println(JSON.toJSONString(list2Only));
+
     }
 
     public void setCategory() {
     }
+
+
+    //重写 equals 和 hashCode  默认只要报警分类一样，就算是相同的报警
+    @Override
+    public final boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof TXinyiWarningRecord)) return false;
+
+        TXinyiWarningRecord that = (TXinyiWarningRecord) o;
+        return Objects.equals(category, that.category);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(category);
+    }
 }