解决问题："只要数值有变化，就应该记录历史记录"/"联锁建立完，初始状态也需要记录在历史数据中"

jeecg-module-interlock/src/main/java/org/jeecg/modules/binlog/PostgreSQLClient.java

@@ -124,6 +124,7 @@ public class PostgreSQLClient implements ApplicationRunner {
 
             // 触发器发送通知 通过 LISTEN 来监听(订阅)通知
             statement.execute("LISTEN notify_event");
+            statement.execute("LISTEN notify_summary_event");
 
             // 采用轮询的方式查询是否有新的通知产生，
             // 暂时没有想到更好的方式替换掉 while 死循环。(可以采用postgresql数据库集成KafKa的方式，但是需要对数据库进行改动可能)
@@ -136,322 +137,390 @@ public class PostgreSQLClient implements ApplicationRunner {
                         System.out.println("变化的数据:"+name+"---"+parameter);
                         Map<String, Object> changeDataMap = JSONObject.parseObject(parameter, new TypeReference<Map<String, Object>>() {
                         });
-                        String systemId = (String) changeDataMap.get("interlock_system_id");   // 联锁系统ID
-                        String interlockCondition = (String) changeDataMap.get("interlock_condition");  // 联锁条件值
-                        String curronValue = (String) changeDataMap.get("interlock_condition");     // 当前值 -- 联锁条件点位对应的值
-                        String ybStatusTag = (String) changeDataMap.get("instrument_status_value");     // 仪表状态点位 值
-                        String ybValueTag = (String) changeDataMap.get("ysmnl_value");      // 仪表原始模拟量点位 值
-                        String plTag = (String) changeDataMap.get("bypass");           // 旁路点位 值
-                        String inputStatusTag = (String) changeDataMap.get("input_status");  // 输入卡件状态点位 值
-                        String outputStatusTag = (String) changeDataMap.get("output_status"); // 输出卡件状态点位 值
-                        String mpStatusTag = (String) changeDataMap.get("mp_status");     // MP状态点位 值
-                        String summaryId = (String) changeDataMap.get("summaryid");  // 联锁总表ID
-                        String id = (String) changeDataMap.get("id");  // 联锁条件ID
-                        String ybIfFs = (String) changeDataMap.get("instrument_status_juge");   // 仪表状态判断方式
-                        String upperLimit = ""; // 上限
-                        if (ObjectUtil.isNotNull(changeDataMap.get("upper_limit"))) {
-                            upperLimit = (String)changeDataMap.get("upper_limit");
-                        }
-                        String lowerLimit = ""; // 下限
-                        if (ObjectUtil.isNotNull(changeDataMap.get("lower_limit"))){
-                            lowerLimit = (String)changeDataMap.get("lower_limit");
-                        }
-                        String ifBypass = (String) changeDataMap.get("if_bypass");  // 是否旁路  (若 "是" 则 bypass 等于 点位值；若 "否" 则 bypass 等于 输入值)
-                        String tagTime = (String) changeDataMap.get("tag_time");   // 点位时间
+                        if ("notify_summary_event".equals(name)){
+                            LocalDateTime currentDateTime = LocalDateTime.now();
+                            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+                            String formattedDateTime = currentDateTime.format(formatter);
+
+                            String id = (String) changeDataMap.get("id");  // 联锁ID
+                            String systemId = (String) changeDataMap.get("interlock_system_id");  // 联锁ID
+
+                            // 根据联锁系统ID查询出 每个正常状态 对应的值
+                            InterlockBase base = baseService.getById(systemId);
+                            InterlockSummary interlockSummary = summaryService.getById(id);
+
+                            InterlockSummaryHistory interlockSummaryHistory = InterlockSummaryHistoryConvert.INSTANCE.toHistory(interlockSummary);
+                            interlockSummaryHistory.setSummaryOriginId(id);
+                            interlockSummaryHistory.setTagTime(formattedDateTime);
+                            interlockSummaryHistory.setInterlockStatusTy(base.getInterlockStatusTy());//联锁状态-正常状态-值
+                            interlockSummaryHistory.setInterlockStatusTyName(base.getInterlockStatusTyName());//联锁状态-正常状态-名称
+                            interlockSummaryHistory.setInterlockStatusWtyName(base.getInterlockStatusWtyName());//联锁状态-故障状态-名称
+                            //联锁状态
+                            if(interlockSummaryHistory.getInterlockStatus().equals(base.getInterlockStatusTy())){//正常
+                                interlockSummaryHistory.setInterlockStatusName(base.getInterlockStatusTyName());//当前联锁状态的名称
+                            }else{//故障
+                                interlockSummaryHistory.setInterlockStatusName(base.getInterlockStatusWtyName());//当前联锁状态的名称
+                            }
+                            summaryHistoryService.save(interlockSummaryHistory);
+
+                            QueryWrapper<InterlockDetail> query = new QueryWrapper<>();
+                            query.eq("summaryid",id);
+                            List<InterlockDetail> interlockDetailList = detailService.list(query);
+                            for (InterlockDetail detail : interlockDetailList) {
+                                InterlockDetailHistory interlockDetailHistory = InterlockDetailHistoryConvert.INSTANCE.toHistory(detail);
+                                interlockDetailHistory.setSummaryid(interlockSummaryHistory.getId());
+                                interlockDetailHistory.setSummaryOriginId(id);
+                                interlockDetailHistory.setTagTime(formattedDateTime);
+                                //保存当前0/1的含义
+                                //旁路状态
+                                interlockDetailHistory.setBypassYes(base.getBypassYes());//旁路状态-正常状态-值
+                                interlockDetailHistory.setBypassYesName(base.getBypassYesName());//旁路状态-正常状态-名称
+                                interlockDetailHistory.setBypassNoName(base.getBypassNoName());//旁路状态-故障状态-名称
+                                if(interlockDetailHistory.getBypass().equals(base.getBypassYes())){//正常
+                                    interlockDetailHistory.setBypassName(base.getBypassYesName());//当前旁路状态的名称
+                                }else{//故障
+                                    interlockDetailHistory.setBypassName(base.getBypassNoName());//当前旁路状态的名称
+                                }
+                                //仪表状态
+                                interlockDetailHistory.setInstrumentStatusNormal(base.getInstrumentStatusNormal());//仪表状态-正常状态-值
+                                interlockDetailHistory.setInstrumentStatusNormalName(base.getInstrumentStatusNormalName());//仪表状态-正常状态-名称
+                                interlockDetailHistory.setInstrumentStatusAbnormalName(base.getInstrumentStatusAbnormalName());//仪表状态-故障状态-名称
+                                if(interlockDetailHistory.getInstrumentStatus().equals(base.getInstrumentStatusNormal())){//正常
+                                    interlockDetailHistory.setInstrumentStatusName(base.getInstrumentStatusNormalName());//当前仪表状态的名称
+                                }else{//故障
+                                    interlockDetailHistory.setInstrumentStatusName(base.getInstrumentStatusAbnormalName());//当前仪表状态的名称
+                                }
+                                //控制系统状态
+                                interlockDetailHistory.setControlSystemStatusNormal(base.getControlSystemStatusNormal());//控制系统状态-正常状态-值
+                                interlockDetailHistory.setControlSystemStatusNormalName(base.getControlSystemStatusNormalName());//控制系统状态-正常状态-名称
+                                interlockDetailHistory.setControlSystemStatusAbnormalName(base.getControlSystemStatusAbnormalName());//控制系统状态-故障状态-名称
+                                if(interlockDetailHistory.getControlSystemStatus().equals(base.getControlSystemStatusNormal())){//正常
+                                    interlockDetailHistory.setControlSystemStatusName(base.getControlSystemStatusNormalName());//当前控制系统状态的名称
+                                }else{//故障
+                                    interlockDetailHistory.setControlSystemStatusName(base.getControlSystemStatusAbnormalName());//当前控制系统状态的名称
+                                }
+                                detailHistoryService.save(interlockDetailHistory);
+                            }
 
+                        }else {
+                            //Map<String, Object> changeDataMap = JSONObject.parseObject(parameter, new TypeReference<Map<String, Object>>() {
+                            //});
+                            String systemId = (String) changeDataMap.get("interlock_system_id");   // 联锁系统ID
+                            String interlockCondition = (String) changeDataMap.get("interlock_condition");  // 联锁条件值
+                            String curronValue = (String) changeDataMap.get("interlock_condition");     // 当前值 -- 联锁条件点位对应的值
+                            String ybStatusTag = (String) changeDataMap.get("instrument_status_value");     // 仪表状态点位 值
+                            String ybValueTag = (String) changeDataMap.get("ysmnl_value");      // 仪表原始模拟量点位 值
+                            String plTag = (String) changeDataMap.get("bypass");           // 旁路点位 值
+                            String inputStatusTag = (String) changeDataMap.get("input_status");  // 输入卡件状态点位 值
+                            String outputStatusTag = (String) changeDataMap.get("output_status"); // 输出卡件状态点位 值
+                            String mpStatusTag = (String) changeDataMap.get("mp_status");     // MP状态点位 值
+                            String summaryId = (String) changeDataMap.get("summaryid");  // 联锁总表ID
+                            String id = (String) changeDataMap.get("id");  // 联锁条件ID
+                            String ybIfFs = (String) changeDataMap.get("instrument_status_juge");   // 仪表状态判断方式
+                            String upperLimit = ""; // 上限
+                            if (ObjectUtil.isNotNull(changeDataMap.get("upper_limit"))) {
+                                upperLimit = (String)changeDataMap.get("upper_limit");
+                            }
+                            String lowerLimit = ""; // 下限
+                            if (ObjectUtil.isNotNull(changeDataMap.get("lower_limit"))){
+                                lowerLimit = (String)changeDataMap.get("lower_limit");
+                            }
+                            String ifBypass = (String) changeDataMap.get("if_bypass");  // 是否旁路  (若 "是" 则 bypass 等于 点位值；若 "否" 则 bypass 等于 输入值)
+                            String tagTime = (String) changeDataMap.get("tag_time");   // 点位时间
 
-                        String sysPlStatus = (String) changeDataMap.get("bypass_ps");  // 系统定义的旁路状态 0否1是
-                        String sysPlStatusName = (String) changeDataMap.get("bypass_name");  // 系统定义的旁路状态名称 0否1是
 
-                        String sysYbStatus = (String) changeDataMap.get("instrument_status_ps");  // 系统定义的仪表状态 0正常1故障
-                        String sysYbStatusName = (String) changeDataMap.get("instrument_status_name");  // 系统定义的仪表状态名称 0正常1故障
+                            String sysPlStatus = (String) changeDataMap.get("bypass_ps");  // 系统定义的旁路状态 0否1是
+                            String sysPlStatusName = (String) changeDataMap.get("bypass_name");  // 系统定义的旁路状态名称 0否1是
 
-                        String sysKzxtStatus = (String) changeDataMap.get("instrument_status_ps");  // 系统定义的控制系统状态 0正常1非正常
-                        String sysKzxtStatusName = (String) changeDataMap.get("instrument_status_name");  // 系统定义的控制系统状态名称 0正常1非正常
+                            String sysYbStatus = (String) changeDataMap.get("instrument_status_ps");  // 系统定义的仪表状态 0正常1故障
+                            String sysYbStatusName = (String) changeDataMap.get("instrument_status_name");  // 系统定义的仪表状态名称 0正常1故障
 
-                        String sysInputStatus = (String) changeDataMap.get("input_status_ps");  // 系统定义的输入卡件状态 0正常1非正常
-                        String sysInputStatusName = (String) changeDataMap.get("input_status_name");  // 系统定义的输入卡件状态名称 0正常1非正常
+                            String sysKzxtStatus = (String) changeDataMap.get("instrument_status_ps");  // 系统定义的控制系统状态 0正常1非正常
+                            String sysKzxtStatusName = (String) changeDataMap.get("instrument_status_name");  // 系统定义的控制系统状态名称 0正常1非正常
 
-                        String sysOutputStatus = (String) changeDataMap.get("output_status_ps");  // 系统定义的输出卡件状态 0正常1非正常
-                        String sysOutputStatusName = (String) changeDataMap.get("output_status_name");  // 系统定义的输出卡件状态名称 0正常1非正常
+                            String sysInputStatus = (String) changeDataMap.get("input_status_ps");  // 系统定义的输入卡件状态 0正常1非正常
+                            String sysInputStatusName = (String) changeDataMap.get("input_status_name");  // 系统定义的输入卡件状态名称 0正常1非正常
 
-                        String sysMpStatus = (String) changeDataMap.get("mp_status_ps");  // 系统定义的MP状态 0正常1非正常
-                        String sysMpStatusName = (String) changeDataMap.get("mp_status_name");  // 系统定义的MP状态名称 0正常1非正常
+                            String sysOutputStatus = (String) changeDataMap.get("output_status_ps");  // 系统定义的输出卡件状态 0正常1非正常
+                            String sysOutputStatusName = (String) changeDataMap.get("output_status_name");  // 系统定义的输出卡件状态名称 0正常1非正常
 
+                            String sysMpStatus = (String) changeDataMap.get("mp_status_ps");  // 系统定义的MP状态 0正常1非正常
+                            String sysMpStatusName = (String) changeDataMap.get("mp_status_name");  // 系统定义的MP状态名称 0正常1非正常
 
 
-                        // 根据联锁系统ID查询出 每个正常状态 对应的值
-                        InterlockBase base = baseService.getById(systemId);
 
-                        String baseYbNormalStatus = base.getInstrumentStatusNormal();   // 用户定义的 仪表状态正常 所对应的值
-                        String baseYbAbnormalStatus = inversionStatus(base.getInstrumentStatusNormal()); // 获取仪表状态异常所对应的值(取反)
+                            // 根据联锁系统ID查询出 每个正常状态 对应的值
+                            InterlockBase base = baseService.getById(systemId);
 
-                        String baseKzxtNormalStatus = base.getControlSystemStatusNormal(); // 用户定义的 控制系统状态正常 所对应的值
-                        String baseKzxtAbnormalStatus = inversionStatus(base.getControlSystemStatusNormal()); // 获取控制系统状态异常所对应的值(取反)
+                            String baseYbNormalStatus = base.getInstrumentStatusNormal();   // 用户定义的 仪表状态正常 所对应的值
+                            String baseYbAbnormalStatus = inversionStatus(base.getInstrumentStatusNormal()); // 获取仪表状态异常所对应的值(取反)
 
-                        String basePlNormalStatus = base.getBypassYes();  // 用户定义的 旁路状态否 所对应的值
-                        String basePlAbnormalStatus = inversionStatus(base.getBypassYes());  // 获取旁路状态是 所对应的值
+                            String baseKzxtNormalStatus = base.getControlSystemStatusNormal(); // 用户定义的 控制系统状态正常 所对应的值
+                            String baseKzxtAbnormalStatus = inversionStatus(base.getControlSystemStatusNormal()); // 获取控制系统状态异常所对应的值(取反)
 
-                        String baseLsNormalStatus = base.getInterlockStatusTy();  // 用户定义的 联锁状态投用 所对应的值
-                        String baseLsAbnormalStatus = inversionStatus(base.getInterlockStatusTy());  // 获取联锁状态未投用所对应的值(取反)
+                            String basePlNormalStatus = base.getBypassYes();  // 用户定义的 旁路状态否 所对应的值
+                            String basePlAbnormalStatus = inversionStatus(base.getBypassYes());  // 获取旁路状态是 所对应的值
 
-                        // 仪表状态     (明细表)
-                        String ybStatus = baseYbNormalStatus; // 用户定义仪表状态为正常的值
+                            String baseLsNormalStatus = base.getInterlockStatusTy();  // 用户定义的 联锁状态投用 所对应的值
+                            String baseLsAbnormalStatus = inversionStatus(base.getInterlockStatusTy());  // 获取联锁状态未投用所对应的值(取反)
 
-                        // 直接读取位号
-                        if ("0".equals(ybIfFs) && ObjectUtil.isNotNull(ybStatusTag)){
-                            // 仪表状态 等于点位值
-                            ybStatus = ybStatusTag;
-                        }
+                            // 仪表状态     (明细表)
+                            String ybStatus = baseYbNormalStatus; // 用户定义仪表状态为正常的值
 
-                        // 高低限判断
-                        if ("1".equals(ybIfFs)){
-                            // 如果 仪表值 大于上限 或者 小于下限 则状态为 异常；两种情况不会同时满足
-                            BigDecimal ybValueTagDecimal = new BigDecimal(ybValueTag);
-                            BigDecimal upperLimitDecimal = new BigDecimal(upperLimit);
-                            BigDecimal lowerLimitDecimal = new BigDecimal(lowerLimit);
-                            if ((ybValueTagDecimal.compareTo(upperLimitDecimal) > 0) || (ybValueTagDecimal.compareTo(lowerLimitDecimal) < 0)) {
-                                ybStatus = baseYbAbnormalStatus; // 仪表状态为异常
+                            // 直接读取位号
+                            if ("0".equals(ybIfFs) && ObjectUtil.isNotNull(ybStatusTag)){
+                                // 仪表状态 等于点位值
+                                ybStatus = ybStatusTag;
                             }
-                        }
 
-                        // 突变超限判断  规定时间内 (结束值-初始值)/初始值 * 100 百分比 是否大于 (高限-底限) * 阈值
-                        if ("2".equals(ybIfFs)){
-                            // 如果 采集的频率 大于 规定的时间
-                            // 例如 采集是一分钟采集一次 规定的时间的2s之内
-                            // 如果 采集的频率 小于等于 规定的时间
-                            // 例如 2S之内  去采集数据表中根据 设备id+模块名称+点位名称 查询2s之前的数据，但是表中的数据量大 时间？
-                            String yz = (String) changeDataMap.get("threshold_value");  // 阈值
-                            String time = (String) changeDataMap.get("threshold_time");  // 规定的时间
-                            String dw = (String) changeDataMap.get("threshold_time_unit");   // 时间单位
-                            if ("s".equals(dw)){
-                                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
-                                String endDate = DateUtils.getDate("yyyy-MM-dd HH:mm:ss");  // 当前时间 规定时间的结束时间
-                                LocalDateTime endDateTime = LocalDateTime.parse(endDate, formatter);
-                                LocalDateTime beginDateTime = endDateTime.minus(Duration.ofSeconds(Long.parseLong(time)));
-                                String beginDate = beginDateTime.format(formatter);  // 开始时间 规定时间的开始时间
-                                QueryWrapper<InterlockTag> tagQuery = new QueryWrapper<>();
-                                tagQuery.eq("interlock_condition_id",id).eq("parameter_type","8");
-                                InterlockTag interlockTag = tagService.getOne(tagQuery);
-                                IotedgeCollectData iotedgeData = iotedgeCollectDataService.getOneInfo(interlockTag.getDeviceId(),interlockTag.getModuleName(),interlockTag.getTagName(),beginDate);
-                                BigDecimal beginValue = BigDecimal.valueOf(Double.parseDouble(iotedgeData.getValue()));
-                                BigDecimal num = BigDecimal.valueOf(Double.parseDouble(ybValueTag)).subtract(beginValue);
-                                // (高限-底限) * 阈值  （数据库中的阈值是去掉百分比的直接乘即可）
-                                BigDecimal up = BigDecimal.valueOf(Double.parseDouble(upperLimit));
-                                BigDecimal lower = BigDecimal.valueOf(Double.parseDouble(lowerLimit));
-                                BigDecimal number = up.subtract(lower);
-                                BigDecimal newYz = number.multiply(BigDecimal.valueOf(Double.parseDouble(yz)));
-                                BigDecimal nowNum = num.divide(beginValue,2, RoundingMode.HALF_UP);
-                                if ((nowNum.compareTo(newYz)) > 0){
-                                    ybStatus = baseYbAbnormalStatus;
+                            // 高低限判断
+                            if ("1".equals(ybIfFs)){
+                                // 如果 仪表值 大于上限 或者 小于下限 则状态为 异常；两种情况不会同时满足
+                                BigDecimal ybValueTagDecimal = new BigDecimal(ybValueTag);
+                                BigDecimal upperLimitDecimal = new BigDecimal(upperLimit);
+                                BigDecimal lowerLimitDecimal = new BigDecimal(lowerLimit);
+                                if ((ybValueTagDecimal.compareTo(upperLimitDecimal) > 0) || (ybValueTagDecimal.compareTo(lowerLimitDecimal) < 0)) {
+                                    ybStatus = baseYbAbnormalStatus; // 仪表状态为异常
                                 }
                             }
-                        }
 
-                        // todo 判断 仪表状态 是否发生了改变；如果发生了变化就将变化之前的数据存入到历史数据表中
-                        String ifYbStatus = "1";  // 判断仪表状态较之前是否发生了变化 0:未发生变化 1:变化
-                        String currYbStatus = (String) changeDataMap.get("instrument_status");
-                        if (ObjectUtil.isNotNull(currYbStatus) && ybStatus.equals(currYbStatus)){
-                            ifYbStatus = "0";
-                        }
+                            // 突变超限判断  规定时间内 (结束值-初始值)/初始值 * 100 百分比 是否大于 (高限-底限) * 阈值
+                            if ("2".equals(ybIfFs)){
+                                // 如果 采集的频率 大于 规定的时间
+                                // 例如 采集是一分钟采集一次 规定的时间的2s之内
+                                // 如果 采集的频率 小于等于 规定的时间
+                                // 例如 2S之内  去采集数据表中根据 设备id+模块名称+点位名称 查询2s之前的数据，但是表中的数据量大 时间？
+                                String yz = (String) changeDataMap.get("threshold_value");  // 阈值
+                                String time = (String) changeDataMap.get("threshold_time");  // 规定的时间
+                                String dw = (String) changeDataMap.get("threshold_time_unit");   // 时间单位
+                                if ("s".equals(dw)){
+                                    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+                                    String endDate = DateUtils.getDate("yyyy-MM-dd HH:mm:ss");  // 当前时间 规定时间的结束时间
+                                    LocalDateTime endDateTime = LocalDateTime.parse(endDate, formatter);
+                                    LocalDateTime beginDateTime = endDateTime.minus(Duration.ofSeconds(Long.parseLong(time)));
+                                    String beginDate = beginDateTime.format(formatter);  // 开始时间 规定时间的开始时间
+                                    QueryWrapper<InterlockTag> tagQuery = new QueryWrapper<>();
+                                    tagQuery.eq("interlock_condition_id",id).eq("parameter_type","8");
+                                    InterlockTag interlockTag = tagService.getOne(tagQuery);
+                                    IotedgeCollectData iotedgeData = iotedgeCollectDataService.getOneInfo(interlockTag.getDeviceId(),interlockTag.getModuleName(),interlockTag.getTagName(),beginDate);
+                                    BigDecimal beginValue = BigDecimal.valueOf(Double.parseDouble(iotedgeData.getValue()));
+                                    BigDecimal num = BigDecimal.valueOf(Double.parseDouble(ybValueTag)).subtract(beginValue);
+                                    // (高限-底限) * 阈值  （数据库中的阈值是去掉百分比的直接乘即可）
+                                    BigDecimal up = BigDecimal.valueOf(Double.parseDouble(upperLimit));
+                                    BigDecimal lower = BigDecimal.valueOf(Double.parseDouble(lowerLimit));
+                                    BigDecimal number = up.subtract(lower);
+                                    BigDecimal newYz = number.multiply(BigDecimal.valueOf(Double.parseDouble(yz)));
+                                    BigDecimal nowNum = num.divide(beginValue,2, RoundingMode.HALF_UP);
+                                    if ((nowNum.compareTo(newYz)) > 0){
+                                        ybStatus = baseYbAbnormalStatus;
+                                    }
+                                }
+                            }
 
-                        // 控制系统状态  (明细表)
-                        String kzxtStatus = baseKzxtNormalStatus; // 用户定义控制系统为正常时的值
-                        // 由于 输出、输入卡件状态、MP状态 与控制系统状态相同 即 如果控制系统异常为1则三个状态异常也为1
-                        if (baseKzxtAbnormalStatus.equals(inputStatusTag) || baseKzxtAbnormalStatus.equals(outputStatusTag) || baseKzxtAbnormalStatus.equals(mpStatusTag)){
-                            kzxtStatus = baseKzxtAbnormalStatus; // 控制系统状态为异常
-                        }
+                            // todo 判断 仪表状态 是否发生了改变；如果发生了变化就将变化之前的数据存入到历史数据表中
+                            String ifYbStatus = "1";  // 判断仪表状态较之前是否发生了变化 0:未发生变化 1:变化
+                            String currYbStatus = (String) changeDataMap.get("instrument_status");
+                            if (ObjectUtil.isNotNull(currYbStatus) && ybStatus.equals(currYbStatus)){
+                                ifYbStatus = "0";
+                            }
 
-                        // todo 判断 控制系统状态 是否发生了改变；如果发生了变化就将变化之前的数据存入到历史数据表中
-                        String ifKzxtStatus = "1"; // 判断控制系统状态较之前是否发生了变化 0:未发生变化 1:变化
-                        String currKzxtStatus = (String) changeDataMap.get("control_system_status");
-                        if (ObjectUtil.isNotNull(currKzxtStatus) && kzxtStatus.equals(currKzxtStatus)){
-                            ifKzxtStatus = "0";
-                        }
+                            // 控制系统状态  (明细表)
+                            String kzxtStatus = baseKzxtNormalStatus; // 用户定义控制系统为正常时的值
+                            // 由于 输出、输入卡件状态、MP状态 与控制系统状态相同 即 如果控制系统异常为1则三个状态异常也为1
+                            if (baseKzxtAbnormalStatus.equals(inputStatusTag) || baseKzxtAbnormalStatus.equals(outputStatusTag) || baseKzxtAbnormalStatus.equals(mpStatusTag)){
+                                kzxtStatus = baseKzxtAbnormalStatus; // 控制系统状态为异常
+                            }
 
-                        // 修改明细表中 该条联锁条件的 仪表状态、控制系统状态
-                        UpdateWrapper<InterlockDetail> upDetailQuery = new UpdateWrapper<>();
-                        upDetailQuery.set("instrument_status",ybStatus).set("control_system_status",kzxtStatus);
-                        upDetailQuery.eq("id",id);
-                        detailService.update(upDetailQuery);
+                            // todo 判断 控制系统状态 是否发生了改变；如果发生了变化就将变化之前的数据存入到历史数据表中
+                            String ifKzxtStatus = "1"; // 判断控制系统状态较之前是否发生了变化 0:未发生变化 1:变化
+                            String currKzxtStatus = (String) changeDataMap.get("control_system_status");
+                            if (ObjectUtil.isNotNull(currKzxtStatus) && kzxtStatus.equals(currKzxtStatus)){
+                                ifKzxtStatus = "0";
+                            }
 
-                        if(baseYbNormalStatus.equals(ybStatus)){
-                            UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
-                            u.set("instrument_status_ps","0").set("instrument_status_name","正常");
-                            u.eq("id",id);
-                            detailService.update(upDetailQuery);
-                        }else {
-                            UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
-                            u.set("instrument_status_ps","1").set("instrument_status_name","故障");
-                            u.eq("id",id);
+                            // 修改明细表中 该条联锁条件的 仪表状态、控制系统状态
+                            UpdateWrapper<InterlockDetail> upDetailQuery = new UpdateWrapper<>();
+                            upDetailQuery.set("instrument_status",ybStatus).set("control_system_status",kzxtStatus);
+                            upDetailQuery.eq("id",id);
                             detailService.update(upDetailQuery);
-                        }
 
-                        if (baseKzxtNormalStatus.equals(kzxtStatus)){
-                            UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
-                            u.set("control_system_status_ps","0").set("control_system_status_name","正常");
-                            u.eq("id",id);
-                            detailService.update(upDetailQuery);
-                        }else {
-                            UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
-                            u.set("control_system_status_ps","1").set("control_system_status_name","非正常");
-                            u.eq("id",id);
-                            detailService.update(upDetailQuery);
-                        }
+                            if(baseYbNormalStatus.equals(ybStatus)){
+                                UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
+                                u.set("instrument_status_ps","0").set("instrument_status_name","正常");
+                                u.eq("id",id);
+                                detailService.update(upDetailQuery);
+                            }else {
+                                UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
+                                u.set("instrument_status_ps","1").set("instrument_status_name","故障");
+                                u.eq("id",id);
+                                detailService.update(upDetailQuery);
+                            }
 
-                        if (basePlNormalStatus.equals(plTag)){
-                            UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
-                            u.set("bypass_ps","1").set("bypass_name","是");
-                            u.eq("id",id);
-                            detailService.update(upDetailQuery);
-                        }else {
-                            UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
-                            u.set("bypass_ps","0").set("bypass_name","否");
-                            u.eq("id",id);
-                            detailService.update(upDetailQuery);
-                        }
+                            if (baseKzxtNormalStatus.equals(kzxtStatus)){
+                                UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
+                                u.set("control_system_status_ps","0").set("control_system_status_name","正常");
+                                u.eq("id",id);
+                                detailService.update(upDetailQuery);
+                            }else {
+                                UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
+                                u.set("control_system_status_ps","1").set("control_system_status_name","非正常");
+                                u.eq("id",id);
+                                detailService.update(upDetailQuery);
+                            }
 
-                        if (baseKzxtNormalStatus.equals(inputStatusTag)){
-                            UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
-                            u.set("input_status_ps","0").set("input_status_name","正常");
-                            u.eq("id",id);
-                            detailService.update(upDetailQuery);
-                        }else {
-                            UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
-                            u.set("input_status_ps","1").set("input_status_name","非正常");
-                            u.eq("id",id);
-                            detailService.update(upDetailQuery);
-                        }
+                            if (basePlNormalStatus.equals(plTag)){
+                                UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
+                                u.set("bypass_ps","1").set("bypass_name","是");
+                                u.eq("id",id);
+                                detailService.update(upDetailQuery);
+                            }else {
+                                UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
+                                u.set("bypass_ps","0").set("bypass_name","否");
+                                u.eq("id",id);
+                                detailService.update(upDetailQuery);
+                            }
 
-                        if (baseKzxtNormalStatus.equals(outputStatusTag)){
-                            UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
-                            u.set("output_status_ps","0").set("output_status_name","正常");
-                            u.eq("id",id);
-                            detailService.update(upDetailQuery);
-                        }else {
-                            UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
-                            u.set("output_status_ps","1").set("output_status_name","非正常");
-                            u.eq("id",id);
-                            detailService.update(upDetailQuery);
-                        }
+                            if (baseKzxtNormalStatus.equals(inputStatusTag)){
+                                UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
+                                u.set("input_status_ps","0").set("input_status_name","正常");
+                                u.eq("id",id);
+                                detailService.update(upDetailQuery);
+                            }else {
+                                UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
+                                u.set("input_status_ps","1").set("input_status_name","非正常");
+                                u.eq("id",id);
+                                detailService.update(upDetailQuery);
+                            }
 
+                            if (baseKzxtNormalStatus.equals(outputStatusTag)){
+                                UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
+                                u.set("output_status_ps","0").set("output_status_name","正常");
+                                u.eq("id",id);
+                                detailService.update(upDetailQuery);
+                            }else {
+                                UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
+                                u.set("output_status_ps","1").set("output_status_name","非正常");
+                                u.eq("id",id);
+                                detailService.update(upDetailQuery);
+                            }
 
-                        if (baseKzxtNormalStatus.equals(mpStatusTag)){
-                            UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
-                            u.set("mp_status_ps","0").set("mp_status_name","正常");
-                            u.eq("id",id);
-                            detailService.update(upDetailQuery);
-                        }else {
-                            UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
-                            u.set("mp_status_ps","1").set("mp_status_name","非正常");
-                            u.eq("id",id);
-                            detailService.update(upDetailQuery);
-                        }
 
-                        // 根据总表id 查询数所有的联锁条件
-                        String zdybzt = "0";   // 该联锁下 所有联锁条件的 (总)仪表状态
-                        String zdkzxtzt = "0"; // 该联锁下 所有联锁条件的 (总)控制系统状态
-                        int ybcount = 0;    // 该联锁下 所有联锁条件 仪表状态为 异常(1) 的数量
-                        int kzxtcount = 0;  // 该联锁下 所有联锁条件 控制系统状态为 异常(1) 的数量
-                        int plcount = 0;    // 该联锁下 所有联锁条件 旁路为 是(1) 的数量
-                        List<InterlockDetail> list = detailService.selectListBySummaryId(summaryId);
-                        for (InterlockDetail detail:list) {
-                            if (baseYbAbnormalStatus.equals(detail.getInstrumentStatus())){
-                                ybcount++;   // 如果仪表状态有一个是异常 则+1;
+                            if (baseKzxtNormalStatus.equals(mpStatusTag)){
+                                UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
+                                u.set("mp_status_ps","0").set("mp_status_name","正常");
+                                u.eq("id",id);
+                                detailService.update(upDetailQuery);
+                            }else {
+                                UpdateWrapper<InterlockDetail> u = new UpdateWrapper<>();
+                                u.set("mp_status_ps","1").set("mp_status_name","非正常");
+                                u.eq("id",id);
+                                detailService.update(upDetailQuery);
                             }
+
+                            // 根据总表id 查询数所有的联锁条件
+                            String zdybzt = "0";   // 该联锁下 所有联锁条件的 (总)仪表状态
+                            String zdkzxtzt = "0"; // 该联锁下 所有联锁条件的 (总)控制系统状态
+                            int ybcount = 0;    // 该联锁下 所有联锁条件 仪表状态为 异常(1) 的数量
+                            int kzxtcount = 0;  // 该联锁下 所有联锁条件 控制系统状态为 异常(1) 的数量
+                            int plcount = 0;    // 该联锁下 所有联锁条件 旁路为 是(1) 的数量
+                            List<InterlockDetail> list = detailService.selectListBySummaryId(summaryId);
+                            for (InterlockDetail detail:list) {
+                                if (baseYbAbnormalStatus.equals(detail.getInstrumentStatus())){
+                                    ybcount++;   // 如果仪表状态有一个是异常 则+1;
+                                }
 //                            if (baseKzxtAbnormalStatus.equals(inputStatusTag) || baseKzxtAbnormalStatus.equals(outputStatusTag) || baseKzxtAbnormalStatus.equals(mpStatusTag)) {
 //                                kzxtcount++; // 如果控制系统状态有一个是异常 则+1;
 //                            }
-                            if (baseKzxtAbnormalStatus.equals(detail.getInputStatus()) || baseKzxtAbnormalStatus.equals(detail.getOutputStatus()) || baseKzxtAbnormalStatus.equals(detail.getMpStatus())) {
-                                kzxtcount++; // 如果控制系统状态有一个是异常 则+1;
-                            }
+                                if (baseKzxtAbnormalStatus.equals(detail.getInputStatus()) || baseKzxtAbnormalStatus.equals(detail.getOutputStatus()) || baseKzxtAbnormalStatus.equals(detail.getMpStatus())) {
+                                    kzxtcount++; // 如果控制系统状态有一个是异常 则+1;
+                                }
 //                            if (basePlNormalStatus.equals(detail.getBypass())){
 //                                plcount++;  // 如果旁路有一个为 是 则+1;
 //                            }
-                            if (basePlAbnormalStatus.equals(detail.getBypass())){
-                                plcount++;  // 如果旁路有一个为故障状态 则+1;
+                                if (basePlAbnormalStatus.equals(detail.getBypass())){
+                                    plcount++;  // 如果旁路有一个为故障状态 则+1;
+                                }
                             }
-                        }
 
-                        // 根据总表id 查询对应的联锁
-                        QueryWrapper<InterlockSummary> summaryQuery = new QueryWrapper<>();
-                        summaryQuery.eq("id",summaryId);
-                        InterlockSummary interLock = summaryService.getOne(summaryQuery);
+                            // 根据总表id 查询对应的联锁
+                            QueryWrapper<InterlockSummary> summaryQuery = new QueryWrapper<>();
+                            summaryQuery.eq("id",summaryId);
+                            InterlockSummary interLock = summaryService.getOne(summaryQuery);
 
-                        // 联锁状态     (总表)
-                        String lsStatus = baseLsNormalStatus;   // 用户定义的联锁状态为投用时的值
-                        if (plcount > 0){
-                            lsStatus = baseLsAbnormalStatus ;   // 如果旁路有一个为 是 则联锁状态为 "未投用"
-                        }
+                            // 联锁状态     (总表)
+                            String lsStatus = baseLsNormalStatus;   // 用户定义的联锁状态为投用时的值
+                            if (plcount > 0){
+                                lsStatus = baseLsAbnormalStatus ;   // 如果旁路有一个为 是 则联锁状态为 "未投用"
+                            }
 
-                        // todo 判断 联锁状态 是否发生了改变；如果发生了变化就将变化之前的数据存入到历史数据表中
-                        String ifLsStatus = "1"; // 判断联锁状态较之前是否发生了变化 0:未发生变化 1:变化
-                        if (ObjectUtil.isNotNull(interLock.getInterlockStatus()) && lsStatus.equals(interLock.getInterlockStatus())){
-                            ifLsStatus = "0";
-                        }
+                            // todo 判断 联锁状态 是否发生了改变；如果发生了变化就将变化之前的数据存入到历史数据表中
+                            String ifLsStatus = "1"; // 判断联锁状态较之前是否发生了变化 0:未发生变化 1:变化
+                            if (ObjectUtil.isNotNull(interLock.getInterlockStatus()) && lsStatus.equals(interLock.getInterlockStatus())){
+                                ifLsStatus = "0";
+                            }
 
-                        // 回路健康级别  (总表)
-                        String hljkjbStatus = "A"; // 四级：A、B、C、D
-                        if (ybcount > 0){
-                            zdybzt = "1";   // 如果 该联锁下所有联锁条件的 仪表状态为异常的数量大于0 则 总的仪表状态为 异常
-                        }
-                        if (kzxtcount > 0){
-                            zdkzxtzt = "1"; // 如果 该联锁下所有联锁条件的 控制系统为异常的数量大于0 则 总的控制系统状态为 异常
-                        }
-                        ArrayList<String> sList = new ArrayList<>();
-                        sList.add(zdybzt);     // 仪表状态
-                        if(baseLsNormalStatus.equals(lsStatus)){
-                            sList.add("0");  // 暂时认为  联锁状态 投用 为 正常
-                        }else {
-                            sList.add("1");
-                        }
-                        sList.add(zdkzxtzt);   // 控制系统状态
-                        // 集合中 元素为 1 的数量
-                        long count = sList.stream().filter(e -> e.equals("1")).count();
-                        if (count == 0){
-                            hljkjbStatus = "A";   // 三个状态都正常 则回路健康级别 为 A
-                        }else if (count == 1){
-                            hljkjbStatus = "B";   // 有任何一个状态为异常 则回路健康级别为 B
-                        }else if (count == 2){
-                            hljkjbStatus = "C";   // 有任何两个状态为异常 则回路健康级别为 C
-                        }else {
-                            hljkjbStatus = "D";   // 三个状态都是异常 则回路健康级别为 D
-                        }
+                            // 回路健康级别  (总表)
+                            String hljkjbStatus = "A"; // 四级：A、B、C、D
+                            if (ybcount > 0){
+                                zdybzt = "1";   // 如果 该联锁下所有联锁条件的 仪表状态为异常的数量大于0 则 总的仪表状态为 异常
+                            }
+                            if (kzxtcount > 0){
+                                zdkzxtzt = "1"; // 如果 该联锁下所有联锁条件的 控制系统为异常的数量大于0 则 总的控制系统状态为 异常
+                            }
+                            ArrayList<String> sList = new ArrayList<>();
+                            sList.add(zdybzt);     // 仪表状态
+                            if(baseLsNormalStatus.equals(lsStatus)){
+                                sList.add("0");  // 暂时认为  联锁状态 投用 为 正常
+                            }else {
+                                sList.add("1");
+                            }
+                            sList.add(zdkzxtzt);   // 控制系统状态
+                            // 集合中 元素为 1 的数量
+                            long count = sList.stream().filter(e -> e.equals("1")).count();
+                            if (count == 0){
+                                hljkjbStatus = "A";   // 三个状态都正常 则回路健康级别 为 A
+                            }else if (count == 1){
+                                hljkjbStatus = "B";   // 有任何一个状态为异常 则回路健康级别为 B
+                            }else if (count == 2){
+                                hljkjbStatus = "C";   // 有任何两个状态为异常 则回路健康级别为 C
+                            }else {
+                                hljkjbStatus = "D";   // 三个状态都是异常 则回路健康级别为 D
+                            }
 
-                        // todo 判断 回路健康级别 是否发生了改变；如果发生了变化就将变化之前的数据存入到历史数据表中
-                        String ifHljkjbStatus = "1"; // 判断回路健康级别较之前是否发生了变化 0:未发生变化 1:变化
-                        if (ObjectUtil.isNotNull(interLock.getLoopHealthLevel()) && hljkjbStatus.equals(interLock.getLoopHealthLevel())){
-                            ifHljkjbStatus = "0";
-                        }
+                            // todo 判断 回路健康级别 是否发生了改变；如果发生了变化就将变化之前的数据存入到历史数据表中
+                            String ifHljkjbStatus = "1"; // 判断回路健康级别较之前是否发生了变化 0:未发生变化 1:变化
+                            if (ObjectUtil.isNotNull(interLock.getLoopHealthLevel()) && hljkjbStatus.equals(interLock.getLoopHealthLevel())){
+                                ifHljkjbStatus = "0";
+                            }
 
-                        // todo 判断 旁路状态 是否发生了改变，如果发生了变化就将变化之前的数据存入到历史数据表中
-                        String ifPlStatus = "1"; // 判断旁路状态是否发生了变化 0:未发生变化 1:变化
-                        QueryWrapper<InterlockDetailTemp> query = new QueryWrapper<>();
-                        query.eq("id",id);
-                        InterlockDetailTemp detailTemp = detailTempService.getOne(query);
-                        String bypass = detailTemp.getBypass(); // 上一次的旁路状态
-                        if (ObjectUtil.isNotNull(bypass) && plTag.equals(bypass)){
-                            ifPlStatus = "0";
-                        }
+                            // todo 判断 旁路状态 是否发生了改变，如果发生了变化就将变化之前的数据存入到历史数据表中
+                            String ifPlStatus = "1"; // 判断旁路状态是否发生了变化 0:未发生变化 1:变化
+                            QueryWrapper<InterlockDetailTemp> query = new QueryWrapper<>();
+                            query.eq("id",id);
+                            InterlockDetailTemp detailTemp = detailTempService.getOne(query);
+                            String bypass = detailTemp.getBypass(); // 上一次的旁路状态
+                            if (ObjectUtil.isNotNull(bypass) && plTag.equals(bypass)){
+                                ifPlStatus = "0";
+                            }
 
-                        // 修改总表中的联锁状态、回路健康级别
-                        UpdateWrapper<InterlockSummary> upSummaryQuery = new UpdateWrapper<>();
-                        upSummaryQuery.set("interlock_status",lsStatus).set("loop_health_level",hljkjbStatus);
-                        upSummaryQuery.eq("id",summaryId);
-                        summaryService.update(upSummaryQuery);
+                            // 修改总表中的联锁状态、回路健康级别
+                            UpdateWrapper<InterlockSummary> upSummaryQuery = new UpdateWrapper<>();
+                            upSummaryQuery.set("interlock_status",lsStatus).set("loop_health_level",hljkjbStatus);
+                            upSummaryQuery.eq("id",summaryId);
+                            summaryService.update(upSummaryQuery);
 
 
-                        if (lsStatus.equals(baseLsNormalStatus)){
-                            UpdateWrapper<InterlockSummary> u = new UpdateWrapper<>();
-                            u.set("interlock_status_ps","1").set("interlock_status_name","投用");
-                            u.eq("id",summaryId);
-                            summaryService.update(upSummaryQuery);
-                        }else {
-                            UpdateWrapper<InterlockSummary> u = new UpdateWrapper<>();
-                            u.set("interlock_status_ps","0").set("interlock_status_name","未投用");
-                            u.eq("id",summaryId);
-                            summaryService.update(upSummaryQuery);
-                        }
+                            if (lsStatus.equals(baseLsNormalStatus)){
+                                UpdateWrapper<InterlockSummary> u = new UpdateWrapper<>();
+                                u.set("interlock_status_ps","1").set("interlock_status_name","投用");
+                                u.eq("id",summaryId);
+                                summaryService.update(upSummaryQuery);
+                            }else {
+                                UpdateWrapper<InterlockSummary> u = new UpdateWrapper<>();
+                                u.set("interlock_status_ps","0").set("interlock_status_name","未投用");
+                                u.eq("id",summaryId);
+                                summaryService.update(upSummaryQuery);
+                            }
 
                         /*
                         // 只要有任意一个状态发生了变化 就将当前联锁、联锁条件记录到历史数据中  (可此时记录的状态确实是未改变之前的，但是点位值却是已经改变之后的)
@@ -482,10 +551,16 @@ public class PostgreSQLClient implements ApplicationRunner {
                         }
                         */
 
+                            QueryWrapper<InterlockSummaryTemp> summaryTempQuery = new QueryWrapper<>();
+                            summaryTempQuery.eq("id",summaryId);
+                            InterlockSummaryTemp interlockTemp = summaryTempService.getOne(summaryTempQuery);
 
-                        // 只要有任意一个状态发生了变化 就将当前联锁、联锁条件记录到历史数据中  (可此时记录的状态确实是未改变之前的，但是点位值却是已经改变之后的)
-                        //修改：记录历史数据的同时，记录下当下的含义，便于以后展示历史数据
-                        if ("1".equals(ifYbStatus) || "1".equals(ifLsStatus) || "1".equals(ifKzxtStatus) || "1".equals(ifHljkjbStatus) || "1".equals(ifPlStatus)){
+                            List<InterlockDetailTemp> tempList = detailTempService.selectListBySummaryId(summaryId);
+
+
+                            // 只要有任意一个状态发生了变化 就将当前联锁、联锁条件记录到历史数据中  (可此时记录的状态确实是未改变之前的，但是点位值却是已经改变之后的)
+                            //修改：记录历史数据的同时，记录下当下的含义，便于以后展示历史数据
+                            //if ("1".equals(ifYbStatus) || "1".equals(ifLsStatus) || "1".equals(ifKzxtStatus) || "1".equals(ifHljkjbStatus) || "1".equals(ifPlStatus)){
                             //QueryWrapper<InterlockSummaryTemp> summaryTempQuery = new QueryWrapper<>();
                             //summaryTempQuery.eq("id",summaryId);
                             //InterlockSummaryTemp interlockTemp = summaryTempService.getOne(summaryTempQuery)
@@ -554,45 +629,46 @@ public class PostgreSQLClient implements ApplicationRunner {
                                 }
                                 detailHistoryService.saveBatch(historyList);
                             }
+                            //}
+
+                            // 修改联锁临时表中每个点位值+状态
+                            UpdateWrapper<InterlockDetailTemp> upTempDetailQuery = new UpdateWrapper<>();
+                            upTempDetailQuery.set("instrument_status",ybStatus)
+                                    .set("control_system_status",kzxtStatus)
+                                    .set("interlock_condition",interlockCondition)
+                                    .set("instrument_status_value",ybStatusTag)
+                                    .set("ysmnl_value",ybValueTag)
+                                    .set("bypass",plTag)
+                                    .set("input_status",inputStatusTag)
+                                    .set("output_status",outputStatusTag)
+                                    .set("mp_status",mpStatusTag)
+                                    .set("bypass_ps",sysPlStatus)
+                                    .set("bypass_name",sysPlStatusName)
+                                    .set("input_status_ps",sysInputStatus)
+                                    .set("input_status_name",sysInputStatusName)
+                                    .set("instrument_status_ps",sysYbStatus)
+                                    .set("instrument_status_name",sysYbStatusName)
+                                    .set("control_system_status_ps",sysKzxtStatus)
+                                    .set("control_system_status_name",sysKzxtStatusName)
+                                    .set("output_status_ps",sysOutputStatus)
+                                    .set("output_status_name",sysOutputStatusName)
+                                    .set("mp_status_ps",sysMpStatus)
+                                    .set("mp_status_name",sysMpStatusName)
+                                    .set("tag_time",tagTime);
+                            upTempDetailQuery.eq("id",id);
+                            detailTempService.update(upTempDetailQuery);
+
+                            // 修改联锁临时表中每个点位值+状态
+                            UpdateWrapper<InterlockSummaryTemp> upTempSummaryQuery = new UpdateWrapper<>();
+                            upTempSummaryQuery.set("interlock_status",lsStatus)
+                                    .set("loop_health_level",hljkjbStatus)
+                                    .set("interlock_out_value",interLock.getInterlockOutValue())
+                                    .set("interlock_status_ps",interLock.getInterlockStatusPs())
+                                    .set("interlock_status_name",interLock.getInterlockStatusName())
+                                    .set("tag_time",interLock.getTagTime());
+                            upTempSummaryQuery.eq("id",summaryId);
+                            summaryTempService.update(upTempSummaryQuery);
                         }
-
-                        // 修改联锁临时表中每个点位值+状态
-                        UpdateWrapper<InterlockDetailTemp> upTempDetailQuery = new UpdateWrapper<>();
-                        upTempDetailQuery.set("instrument_status",ybStatus)
-                                .set("control_system_status",kzxtStatus)
-                                .set("interlock_condition",interlockCondition)
-                                .set("instrument_status_value",ybStatusTag)
-                                .set("ysmnl_value",ybValueTag)
-                                .set("bypass",plTag)
-                                .set("input_status",inputStatusTag)
-                                .set("output_status",outputStatusTag)
-                                .set("mp_status",mpStatusTag)
-                                .set("bypass_ps",sysPlStatus)
-                                .set("bypass_name",sysPlStatusName)
-                                .set("input_status_ps",sysInputStatus)
-                                .set("input_status_name",sysInputStatusName)
-                                .set("instrument_status_ps",sysYbStatus)
-                                .set("instrument_status_name",sysYbStatusName)
-                                .set("control_system_status_ps",sysKzxtStatus)
-                                .set("control_system_status_name",sysKzxtStatusName)
-                                .set("output_status_ps",sysOutputStatus)
-                                .set("output_status_name",sysOutputStatusName)
-                                .set("mp_status_ps",sysMpStatus)
-                                .set("mp_status_name",sysMpStatusName)
-                                .set("tag_time",tagTime);
-                        upTempDetailQuery.eq("id",id);
-                        detailTempService.update(upTempDetailQuery);
-
-                        // 修改联锁临时表中每个点位值+状态
-                        UpdateWrapper<InterlockSummaryTemp> upTempSummaryQuery = new UpdateWrapper<>();
-                        upTempSummaryQuery.set("interlock_status",lsStatus)
-                                .set("loop_health_level",hljkjbStatus)
-                                .set("interlock_out_value",interLock.getInterlockOutValue())
-                                .set("interlock_status_ps",interLock.getInterlockStatusPs())
-                                .set("interlock_status_name",interLock.getInterlockStatusName())
-                                .set("tag_time",interLock.getTagTime());
-                        upTempSummaryQuery.eq("id",summaryId);
-                        summaryTempService.update(upTempSummaryQuery);
                     }
                 }
 

jeecg-module-interlock/src/main/java/org/jeecg/modules/history/convert/InterlockSummaryHistoryConvert.java

@@ -25,6 +25,11 @@ public interface InterlockSummaryHistoryConvert {
     @Mapping(target = "id", ignore = true)
     InterlockSummaryHistory toHistory(InterlockSummary interlockSummary);
 
+    @Mapping(target = "interlockStatus",source = "interlockStatus")
+    @Mapping(target = "loopHealthLevel",source = "loopHealthLevel")
+    InterlockSummaryHistory toHistory2(InterlockSummaryHistory interlockSummaryHistory,String interlockStatus,String loopHealthLevel);
+
+
     @Mapping(target = "interlockStatus", source = "interlockStatus")
     InterlockHistoryQueryDTO toInterlockStatus(InterlockHistoryQueryDTO dto,String interlockStatus);
 

jeecg-module-interlock/src/main/java/org/jeecg/modules/summary/service/impl/InterlockSummaryServiceImpl.java

@@ -2,6 +2,7 @@ package org.jeecg.modules.summary.service.impl;
 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import org.jeecg.common.util.DateUtils;
 import org.jeecg.modules.base.entity.InterlockBase;
@@ -13,6 +14,13 @@ import org.jeecg.modules.detail.entity.InterlockDetail;
 import org.jeecg.modules.detail.mapper.InterlockDetailMapper;
 import org.jeecg.modules.detail.service.IInterlockDetailService;
 import org.jeecg.modules.detail.vo.InterlockDetailEditQueryVO;
+import org.jeecg.modules.history.convert.InterlockDetailHistoryConvert;
+import org.jeecg.modules.history.convert.InterlockSummaryHistoryConvert;
+import org.jeecg.modules.history.entity.InterlockDetailHistory;
+import org.jeecg.modules.history.entity.InterlockSummaryHistory;
+import org.jeecg.modules.history.mapper.InterlockDetailHistoryMapper;
+import org.jeecg.modules.history.service.IInterlockDetailHistoryService;
+import org.jeecg.modules.history.service.IInterlockSummaryHistoryService;
 import org.jeecg.modules.iotedgeCollectData.entity.IotedgeCollectData;
 import org.jeecg.modules.iotedgeCollectData.service.IIotedgeCollectDataService;
 import org.jeecg.modules.summary.constants.InterlockAllStatus;
@@ -83,6 +91,14 @@ public class InterlockSummaryServiceImpl extends ServiceImpl<InterlockSummaryMap
     @Autowired
     @SuppressWarnings("all")
     private IIotedgeCollectDataService iotedgeCollectDataService;
+    @Autowired
+    @SuppressWarnings("all")
+    private IInterlockSummaryHistoryService summaryHistoryService;
+    @Autowired
+    @SuppressWarnings("all")
+    private InterlockDetailHistoryMapper detailHistoryMapper;
+
+
 
     /**
      *  根据联锁总表id批量删除联锁及详细信息、点位
@@ -556,6 +572,13 @@ public class InterlockSummaryServiceImpl extends ServiceImpl<InterlockSummaryMap
 
         String summaryId = interlockSummary.getId();
 
+        InterlockSummaryHistory interlockSummaryHistory = InterlockSummaryHistoryConvert.INSTANCE.toHistory(interlockSummary);
+        interlockSummaryHistory.setSummaryOriginId(summaryId);
+        interlockSummaryHistory.setInterlockStatusTy(base.getInterlockStatusTy());//联锁状态-正常状态-值
+        interlockSummaryHistory.setInterlockStatusTyName(base.getInterlockStatusTyName());//联锁状态-正常状态-名称
+        interlockSummaryHistory.setInterlockStatusWtyName(base.getInterlockStatusWtyName());//联锁状态-故障状态-名称
+        summaryHistoryService.save(interlockSummaryHistory);
+
         //新增——联锁输出值点位
         interlockTagService.save(createInterlockTag(interlockAddDTO.getDeviceId(),interlockAddDTO.getModuleName(), interlockAddDTO.getInterlockOutValueTag(), interlockAddDTO.getInterlockOutValue(), InterlockConstants.INTERLOCK_OUT_VALUE,summaryId,summaryId));
 
@@ -646,6 +669,40 @@ public class InterlockSummaryServiceImpl extends ServiceImpl<InterlockSummaryMap
 //            detail.setSystemType(dto.getSystemType());
             //新增联锁详细信息表数据
             interlockDetailMapper.insert(detail);
+
+            InterlockDetailHistory interlockDetailHistory = InterlockDetailHistoryConvert.INSTANCE.toHistory(detail);
+            interlockDetailHistory.setSummaryid(interlockSummaryHistory.getId());
+            interlockDetailHistory.setSummaryOriginId(summaryId);
+
+            interlockDetailHistory.setBypassYes(base.getBypassYes());//旁路状态-正常状态-值
+            interlockDetailHistory.setBypassYesName(base.getBypassYesName());//旁路状态-正常状态-名称
+            interlockDetailHistory.setBypassNoName(base.getBypassNoName());//旁路状态-故障状态-名称
+            if(interlockDetailHistory.getBypass().equals(base.getBypassYes())){//正常
+                interlockDetailHistory.setBypassName(base.getBypassYesName());//当前旁路状态的名称
+            }else{//故障
+                interlockDetailHistory.setBypassName(base.getBypassNoName());//当前旁路状态的名称
+            }
+            //仪表状态
+            interlockDetailHistory.setInstrumentStatusNormal(base.getInstrumentStatusNormal());//仪表状态-正常状态-值
+            interlockDetailHistory.setInstrumentStatusNormalName(base.getInstrumentStatusNormalName());//仪表状态-正常状态-名称
+            interlockDetailHistory.setInstrumentStatusAbnormalName(base.getInstrumentStatusAbnormalName());//仪表状态-故障状态-名称
+            if(interlockDetailHistory.getInstrumentStatus().equals(base.getInstrumentStatusNormal())){//正常
+                interlockDetailHistory.setInstrumentStatusName(base.getInstrumentStatusNormalName());//当前仪表状态的名称
+            }else{//故障
+                interlockDetailHistory.setInstrumentStatusName(base.getInstrumentStatusAbnormalName());//当前仪表状态的名称
+            }
+            //控制系统状态
+            interlockDetailHistory.setControlSystemStatusNormal(base.getControlSystemStatusNormal());//控制系统状态-正常状态-值
+            interlockDetailHistory.setControlSystemStatusNormalName(base.getControlSystemStatusNormalName());//控制系统状态-正常状态-名称
+            interlockDetailHistory.setControlSystemStatusAbnormalName(base.getControlSystemStatusAbnormalName());//控制系统状态-故障状态-名称
+            if(interlockDetailHistory.getControlSystemStatus().equals(base.getControlSystemStatusNormal())){//正常
+                interlockDetailHistory.setControlSystemStatusName(base.getControlSystemStatusNormalName());//当前控制系统状态的名称
+            }else{//故障
+                interlockDetailHistory.setControlSystemStatusName(base.getControlSystemStatusAbnormalName());//当前控制系统状态的名称
+            }
+
+            detailHistoryMapper.insert(interlockDetailHistory);
+
             //新增联锁详细信息表临时表数据
             InterlockDetailTemp detailTemp = TempConvert.INSTANCE.toInterlockDetailTemp(detail);
             detailTempMapper.insert(detailTemp);
@@ -660,7 +717,22 @@ public class InterlockSummaryServiceImpl extends ServiceImpl<InterlockSummaryMap
 
         interlockSummary = InterlockSummaryConvert.INSTANCE.toInterlockSummary2(interlockSummary,interlockStatus,loopHealthLevel);
         //修改联锁总表数据
-        interlockSummaryMapper.updateById(interlockSummary);
+        UpdateWrapper<InterlockSummary> updateWrapper = new UpdateWrapper<>();
+        updateWrapper.eq("id",interlockSummary.getId());
+        updateWrapper.set("interlock_status",interlockSummary.getInterlockStatus());
+        updateWrapper.set("loop_health_level",interlockSummary.getLoopHealthLevel());
+        this.update(updateWrapper);
+        //interlockSummaryMapper.updateById(interlockSummary);
+
+        interlockSummaryHistory = InterlockSummaryHistoryConvert.INSTANCE.toHistory2(interlockSummaryHistory,interlockStatus,loopHealthLevel);
+        //联锁状态
+        if(interlockSummaryHistory.getInterlockStatus().equals(base.getInterlockStatusTy())){//正常
+            interlockSummaryHistory.setInterlockStatusName(base.getInterlockStatusTyName());//当前联锁状态的名称
+        }else{//故障
+            interlockSummaryHistory.setInterlockStatusName(base.getInterlockStatusWtyName());//当前联锁状态的名称
+        }
+        summaryHistoryService.updateById(interlockSummaryHistory);
+
         //新增联锁总表临时表数据
         InterlockSummaryTemp interlockSummaryTemp = TempConvert.INSTANCE.toInterlockSummaryTemp(interlockSummary);
         summaryTempMapper.insert(interlockSummaryTemp);