日报表修改。获取历史数据、计算投用率修改

jeecg-module-interlock/src/main/java/org/jeecg/modules/history/mapper/InterlockDetailHistoryMapper.java

@@ -94,4 +94,7 @@ public interface InterlockDetailHistoryMapper extends BaseMapper<InterlockDetail
 
     List<InterlockSummaryHistoryVO> getForExport1(InterlockHistoryQueryDTO dto);
 
+    //导出  根据历史总表id查询详细信息用于导出
+    List<InterlockSummaryHistoryVO> getForExportLast(List<String> summaryHistoryIdList);
+
 }

jeecg-module-interlock/src/main/java/org/jeecg/modules/history/mapper/InterlockSummaryHistoryMapper.java

@@ -74,4 +74,14 @@ public interface InterlockSummaryHistoryMapper extends BaseMapper<InterlockSumma
     List<InterlockHistoryDistinctZZXTVO> getDistinctZZXTSummaryListByUserPermission(String wiseUser);
 
 
+    /**
+     * 根据查询条件查询历史联锁总表所有联锁历史的最新一条  日报表
+     */
+    List<InterlockSummaryHistory> getSummaryHistoryList00(@Param("dto") InterlockHistoryQueryDTO dto);
+    /**
+     * 根据条件查询历史联锁总表数据  月报表、年报表、手动导出
+     */
+    List<InterlockSummaryHistory> getSummaryHistoryList11(@Param("dto") InterlockHistoryQueryDTO dto);
+
+
 }

jeecg-module-interlock/src/main/java/org/jeecg/modules/history/mapper/xml/InterlockDetailHistoryMapper.xml

@@ -493,4 +493,22 @@
         where mm = 1
     </select>
 
+
+    <!-- 联锁总历史数据表查询（各种逻辑状态）——用于手动导出   含义从详细历史数据表中获取 -->
+    <!-- 每个系统的数据 先按联锁总表的生成时间倒序排序，s.create_time desc,  ？？保证新增的联锁在最前面； 再按tag_time倒序排序，使最新发生变化的数据在最前面  -->
+    <select id="getForExportLast" resultType="org.jeecg.modules.history.vo.InterlockSummaryHistoryVO">
+        select d.id, d.summaryid, d.interlockname, d.interlock_condition, d.interlock_condition_tag, d.instrument_status, d.control_system_status,
+        s.interlock_status, s.loop_health_level, d.bypass, s.tag_time,
+        s.interlock_status_name, d.bypass_name,
+        d.instrument_status_name, d.control_system_status_name
+        from interlock_detail_history d left join interlock_summary_history s on d.summaryid = s.id
+        <where>
+            s.id in
+            <foreach collection="summaryHistoryIdList" item="item" open="(" close=")" separator=",">
+                #{item}
+            </foreach>
+        </where>
+        order by s.tag_time desc
+    </select>
+
 </mapper>

jeecg-module-interlock/src/main/java/org/jeecg/modules/history/mapper/xml/InterlockSummaryHistoryMapper.xml

@@ -216,6 +216,44 @@
         </where>
     </select>
 
+    <!-- 查询历史联锁总表所有联锁历史的最新一条  日报表 -->
+    <select id="getSummaryHistoryList00" parameterType="org.jeecg.modules.history.dto.InterlockHistoryQueryDTO" resultType="org.jeecg.modules.history.entity.InterlockSummaryHistory">
+        select n.* from
+        (select distinct s.*, ROW_NUMBER() OVER (PARTITION BY s.summary_origin_id ORDER BY s.tag_time DESC) AS mm
+         from interlock_detail_history d left join interlock_summary_history s on d.summaryid = s.id
+        <where>
+            <if test="dto.interlockSystemId != null and dto.interlockSystemId != ''"> and s.interlock_system_id = #{dto.interlockSystemId}</if>
+            <if test="dto.interlockApparatusId != null and dto.interlockApparatusId != ''"> and s.interlock_apparatus_id = #{dto.interlockApparatusId}</if>
+            <if test="dto.interlockname != null and dto.interlockname != ''"> and d.interlockname like concat('%', #{dto.interlockname}, '%')</if>
+            <if test="dto.interlockCondition != null and dto.interlockCondition != ''"> and d.interlock_condition = #{dto.interlockCondition}</if>
+            <if test="dto.interlockConditionTag != null and dto.interlockConditionTag != ''"> and d.interlock_condition_tag like concat('%',#{dto.interlockConditionTag},'%')</if>
+            <if test="dto.instrumentStatus != null and dto.instrumentStatus != ''"> and d.instrument_status = #{dto.instrumentStatus}</if>
+            <if test="dto.controlSystemStatus != null and dto.controlSystemStatus != ''"> and d.control_system_status = #{dto.controlSystemStatus}</if>
+            <if test="dto.interlockStatus != null and dto.interlockStatus != ''"> and s.interlock_status = #{dto.interlockStatus}</if>
+            <if test="dto.loopHealthLevel != null and dto.loopHealthLevel != ''"> and s.loop_health_level = #{dto.loopHealthLevel}</if>
+            <if test="dto.beginTime != null"> and TO_TIMESTAMP(s.tag_time, 'YYYY-MM-DD HH24:MI:SS') <![CDATA[ <= ]]> #{dto.beginTime} </if>
+        </where>) n
+        where mm=1;
+    </select>
+
+    <!-- 根据条件查询历史联锁总表数据  月报表、年报表、手动导出 -->
+    <select id="getSummaryHistoryList11" parameterType="org.jeecg.modules.history.dto.InterlockHistoryQueryDTO" resultType="org.jeecg.modules.history.entity.InterlockSummaryHistory">
+        select distinct s.* from interlock_summary_history s inner join interlock_detail_history d on d.summaryid = s.id
+        <where>
+            <if test="dto.interlockSystemId != null and dto.interlockSystemId != ''"> and s.interlock_system_id = #{dto.interlockSystemId}</if>
+            <if test="dto.interlockApparatusId != null and dto.interlockApparatusId != ''"> and s.interlock_apparatus_id = #{dto.interlockApparatusId}</if>
+            <if test="dto.interlockname != null and dto.interlockname != ''"> and d.interlockname like concat('%', #{dto.interlockname}, '%')</if>
+            <if test="dto.interlockCondition != null and dto.interlockCondition != ''"> and d.interlock_condition = #{dto.interlockCondition}</if>
+            <if test="dto.interlockConditionTag != null and dto.interlockConditionTag != ''"> and d.interlock_condition_tag like concat('%',#{dto.interlockConditionTag},'%')</if>
+            <if test="dto.instrumentStatus != null and dto.instrumentStatus != ''"> and d.instrument_status = #{dto.instrumentStatus}</if>
+            <if test="dto.controlSystemStatus != null and dto.controlSystemStatus != ''"> and d.control_system_status = #{dto.controlSystemStatus}</if>
+            <if test="dto.interlockStatus != null and dto.interlockStatus != ''"> and s.interlock_status = #{dto.interlockStatus}</if>
+            <if test="dto.loopHealthLevel != null and dto.loopHealthLevel != ''"> and s.loop_health_level = #{dto.loopHealthLevel}</if>
+            <if test="dto.beginTime != null"> and TO_TIMESTAMP(s.tag_time, 'YYYY-MM-DD HH24:MI:SS') <![CDATA[ >= ]]> #{dto.beginTime} </if>
+            <if test="dto.endTime != null"> and TO_TIMESTAMP(s.tag_time, 'YYYY-MM-DD HH24:MI:SS') <![CDATA[ <= ]]> #{dto.endTime} </if>
+        </where>
+    </select>
+
 
 
 </mapper>

jeecg-module-interlock/src/main/java/org/jeecg/modules/history/quartz/ReportJobDay.java

@@ -59,6 +59,8 @@ public class ReportJobDay implements Job {
         this.parameter = parameter;
     }
 
+    /*
+    //日报表之前的备份  20240923
     @Override
     public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
         log.info(" Job Execution key："+jobExecutionContext.getJobDetail().getKey());
@@ -180,4 +182,128 @@ public class ReportJobDay implements Job {
             e.printStackTrace();
         }
     }
+
+     */
+
+    @Override
+    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
+        log.info(" Job Execution key："+jobExecutionContext.getJobDetail().getKey());
+
+        String separator = "/";
+        String filePrex = this.parameter;
+        String reportType = "";
+
+        InterlockHistoryQueryDTO dto = new InterlockHistoryQueryDTO();
+        Calendar start = Calendar.getInstance();
+        start.set(Calendar.HOUR_OF_DAY, 0);
+        start.set(Calendar.MINUTE, 0);
+        start.set(Calendar.SECOND, 0);
+
+        Calendar end = Calendar.getInstance();
+        end.set(Calendar.HOUR_OF_DAY, 23);
+        end.set(Calendar.MINUTE, 59);
+        end.set(Calendar.SECOND, 59);
+
+        if(this.parameter.equals("day")) {
+            // 昨天凌晨00:00:00
+            start.add(Calendar.DAY_OF_MONTH, -1);
+            // 昨天晚上23:59:59
+            end.add(Calendar.DAY_OF_MONTH, -1);
+
+            reportType = "0";
+
+        }else if(this.parameter.equals("month")){
+            // 上个月的第一天凌晨00:00:00
+            start.add(Calendar.MONTH, -1);
+            start.set(Calendar.DAY_OF_MONTH, 1);
+            // 上个月的最后一天晚上23:59:59
+            end.set(Calendar.DAY_OF_MONTH, 1);
+            end.add(Calendar.DAY_OF_MONTH, -1);
+
+            reportType = "1";
+
+        }else if(this.parameter.equals("year")){
+            // 去年的第一天凌晨00:00:00
+            start.add(Calendar.YEAR, -1);
+            start.set(Calendar.MONTH, 0);
+            start.set(Calendar.DAY_OF_MONTH, 1);
+            // 去年的最后一天晚上23:59:59
+            end.set(Calendar.MONTH, 0);
+            end.set(Calendar.DAY_OF_MONTH, 1);
+            end.add(Calendar.DAY_OF_MONTH, -1);
+
+            reportType = "2";
+        }
+
+        //Date beginTime = start.getTime();
+        //Date endTime = end.getTime();
+
+        //log.info(String.format(" **********导出" + filePrex + "历史数据**********  时间:" + beginTime + "——" + endTime));
+
+        //dto.setBeginTime(beginTime);
+        //dto.setEndTime(endTime);
+
+        Calendar currentDate = Calendar.getInstance();
+        Date currentTime = currentDate.getTime();
+        dto.setBeginTime(currentTime);
+
+        log.info(" **********导出" + filePrex + "历史数据**********  时间:" + currentTime);
+
+        // 文件路径，如"D:/ttt/opt/upFiles/"
+        String fileUrlPrex = upLoadPath + separator + filePrex + separator;
+        File saveFile = new File(fileUrlPrex);
+        if (!saveFile.exists()) {
+            saveFile.mkdirs();
+        }
+
+        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+        String timestamp = dateFormat.format(new Date());
+        String fileName = String.format("联锁历史数据_" + filePrex + "报表_%s.xlsx", timestamp);
+
+        String filePath = fileUrlPrex  + fileName;
+
+//        List<InterlockHistoryDistinctZZXTVO> zzxtvoList = summaryHistoryMapper.getDistinctZZXTSummaryList1(dto);
+        List<InterlockHistoryDistinctZZXTVO> zzxtvoList = summaryHistoryMapper.getDistinctZZXTSummaryListByAdmin();//目前按全部装置-系统数据进行导出
+
+        if(zzxtvoList == null || zzxtvoList.size()==0) return;
+        else {
+            Workbook workbook = new XSSFWorkbook();
+            try {
+                workbook = interlockDetailHistoryService.exportXlsToFile1(dto, zzxtvoList, InterlockSummaryHistoryVO.class,"0");//0日报表1手动、月报表、年报表
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+
+            try (FileOutputStream fileOut = new FileOutputStream(filePath)) {
+                workbook.write(fileOut);
+            } catch (IOException e) {
+                // 处理异常
+                e.printStackTrace();
+            } finally {
+                try {
+                    if (workbook != null) {
+                        workbook.close();
+                    }
+                } catch (IOException e) {
+                    // 处理关闭 workbook 时可能发生的异常
+                    e.printStackTrace();
+                }
+            }
+        }
+
+        //新增报表记录
+        InterlockDataReport report = new InterlockDataReport();
+        report.setReportName(fileName);
+        report.setReportType(reportType); // 0日报表1月报表2年报表
+        report.setReportUrl(filePath);
+        reportService.save(report);
+
+        // IoTEdge-发送邮件
+        try {
+            restClientService.sendEmali(fileName,fileUrlPrex);
+            log.info(String.format(" **********发送" + filePrex + "历史数据导出邮件通知**********  "));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
 }

jeecg-module-interlock/src/main/java/org/jeecg/modules/history/service/impl/InterlockDetailHistoryServiceImpl.java

@@ -12,6 +12,7 @@ import org.jeecg.modules.detail.dto.InterlockDetailQueryDTO;
 import org.jeecg.modules.history.convert.InterlockSummaryHistoryConvert;
 import org.jeecg.modules.history.dto.InterlockHistoryQueryDTO;
 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.mapper.InterlockSummaryHistoryMapper;
 import org.jeecg.modules.history.service.IInterlockDetailHistoryService;
@@ -530,10 +531,42 @@ public class InterlockDetailHistoryServiceImpl extends ServiceImpl<InterlockDeta
         String formattedEndTime = dto.getEndTime() != null ? sdf.format(dto.getEndTime()) : "";
         List<InterlockSummaryHistoryVO> exportList = new ArrayList<InterlockSummaryHistoryVO>();
         dto.setInterlockSystemId(zzxtvo.getInterlockSystemId()); // 系统id
-        if ("0".equals(type)){
-            exportList = this.getForExport00(dto);//日报表
-        }else {
-            exportList = this.getForExport11(dto);//手动导出、月报表、年报表
+        List<InterlockSummaryHistory> summaryHistoryList = new ArrayList<InterlockSummaryHistory>();//用于计算投用率的历史联锁总表数据
+        if ("0".equals(type)){//日报表相关
+            //导出当前时刻所有的联锁最新历史总表数据用于计算投用率
+            summaryHistoryList = summaryHistoryMapper.getSummaryHistoryList00(dto);
+
+//            //获取所有联锁数据用于写入日报表
+//            exportList = this.getForExport00(dto);
+        }else {//手动导出、月报表、年报表相关
+            //获取符合查询条件的所有历史联锁总表数据用户计算投用率
+            summaryHistoryList = summaryHistoryMapper.getSummaryHistoryList11(dto);
+//            exportList = this.getForExport11(dto);
+        }
+        // 计算投用率
+        //计算投用数量和未投用数量
+//        ty = summaryHistoryMapper.cocuntTY11(dto);
+//        wty = summaryHistoryMapper.cocuntWTY11(dto);
+        List<String> summaryHistoryIdList = new ArrayList<>();//查询到的历史联锁总表id
+        int ty = 0;
+        int wty = 0;
+        for(InterlockSummaryHistory interlockSummaryHistory:summaryHistoryList){
+            summaryHistoryIdList.add(interlockSummaryHistory.getId());//历史联锁总表id
+            if(interlockSummaryHistory.getInterlockStatus().equals(interlockSummaryHistory.getInterlockStatusTy())){//投用
+                ty++;
+            }else{
+                wty++;
+            }
+        }
+        int total = ty + wty; // 总数量
+        String tylPercentage = "0.00%";//如果没有历史数据，投用率为0
+        if(total!=0){
+            double tyl = (double) ty / total * 100;
+            tylPercentage = String.format("%.2f%%", tyl); // 将百分比转换为百分数形式，保留两位小数
+        }
+        //获取导出的数据exportList
+        if(summaryHistoryIdList.size()!=0){
+            exportList = interlockDetailHistoryMapper.getForExportLast(summaryHistoryIdList);
         }
 
         System.out.println("系统开始-----------------------------------------------------------------------------------"+zzxtvo.getInterlockSystemName());
@@ -547,17 +580,6 @@ public class InterlockDetailHistoryServiceImpl extends ServiceImpl<InterlockDeta
             sheet.setColumnWidth(j, columnWidths[j] * 256);
         }
 
-        // 计算投用率
-        int ty = summaryHistoryMapper.cocuntTY11(dto);
-        int wty = summaryHistoryMapper.cocuntWTY11(dto);
-        int total = ty + wty; // 总数量
-        String tylPercentage = "0.00%";//如果没有历史数据，投用率为0
-        if(total!=0){
-            double tyl = (double) ty / total * 100;
-            tylPercentage = String.format("%.2f%%", tyl); // 将百分比转换为百分数形式，保留两位小数
-        }
-
-
         //第一行：联锁历史数据报表
         int rowNum = 0;
         Row titleRow = sheet.createRow(rowNum++);

jeecg-module-interlock/src/main/java/org/jeecg/modules/interlockAvoidCircular/service/impl/InterlockAvoidCircularServiceImpl.java

@@ -171,7 +171,8 @@ public class InterlockAvoidCircularServiceImpl implements InterlockAvoidCircular
     }
 
     /**
-     * 修改系统时，修改联锁总表的联锁状态和回路健康等级
+     * 修改系统时，修改联锁的各个状态和值
+     * 如果系统状态修改了，更新点位时间
      *
      * @param base
      */
@@ -234,6 +235,219 @@ public class InterlockAvoidCircularServiceImpl implements InterlockAvoidCircular
         List<InterlockSummary> interlockSummaryList = interlockAvoidCircularMapper.getInterlockSummaryListBySystemId(base.getId());
 
         for(InterlockSummary interlockSummary:interlockSummaryList){
+            //联锁总表更新点位时间
+            interlockSummary.setTagTime(formattedDateTime);
+            //设置各状态默认值
+            String interlockStatus = interlockStatusTy;;//	先设置为 联锁状态-投用
+            String loopHealthLevel = "A";// 回路健康级别
+            String controlSystemStatus = controlSystemStatusNormal;// 总体 先设置为 控制系统状态-正常
+            String instrumentStatus = instrumentStatusNormal;// 总体 先设置为 仪表状态-正常
+            String bypass = bypassYes;// 总体 先设置为 旁路状态-非旁路
+            //根据总表id查找联锁详细表信息并进行处理
+            List<InterlockDetail> interlockDetailList = interlockAvoidCircularMapper.getInterlockDetailListBySummaryId(interlockSummary.getId());
+
+            for(InterlockDetail interlockDetail:interlockDetailList){
+                //联锁详细表更新点位时间
+                interlockDetail.setTagTime(formattedDateTime);
+                //旁路状态更新：如果是直接读取位号，则值不变;如果默认正常或者现场旁路，需要改变旁路状态的值
+                if(isChangeBypass){
+                    if(InterlockAllStatus.IF_BY_PASS_NO.equals(interlockDetail.getIfBypass())){
+                        interlockDetail.setBypass(bypassYes);//如果是默认正常，将旁路状态设为正常状态
+                    }else if(InterlockAllStatus.IF_BY_PASS_spot.equals(interlockDetail.getIfBypass())){
+                        //先判断现在旁路状态是正常还是故障
+                        if(interlockBaseOrg.getBypassYes().equals(interlockDetail.getBypass())){
+                            interlockDetail.setBypass(bypassYes);//原来是正常状态，现在也设置成正常状态对应的值
+                        }else {
+                            interlockDetail.setBypass(bypassNo);//原来是故障状态，现在也设置成故障状态对应的值
+                        }
+                    }
+                }
+                //联锁状态：旁路状态多个的话，任何一个旁路状态是故障状态，则联锁状态是故障状态，如果旁路状态都是正常状态，则联锁状态是正常状态
+                if(interlockDetail.getBypass()!=null && bypassNo.equals(interlockDetail.getBypass())) interlockStatus = interlockStatusWty;
+
+                //仪表状态  有通过原始量判断出来的值，所以不管变不变，都要判断一下当前仪表状态是正常还是故障
+                if(interlockDetail.getInstrumentStatusJuge()!=null){
+                    if(InterlockAllStatus.INSTRUMENT_STATUS_JUDGE0.equals(interlockDetail.getInstrumentStatusJuge())){
+                        //0直接读取位号
+                        interlockDetail.setInstrumentStatus(interlockDetail.getInstrumentStatusValue());
+                    } else if(InterlockAllStatus.INSTRUMENT_STATUS_JUDGE1.equals(interlockDetail.getInstrumentStatusJuge())){
+                        //1高低限判断
+                        BigDecimal ysmnlValue = new BigDecimal(interlockDetail.getYsmnlValue());
+                        BigDecimal lowerLimit = new BigDecimal(interlockDetail.getLowerLimit());
+                        BigDecimal upperLimit = new BigDecimal(interlockDetail.getUpperLimit());
+                        if(ysmnlValue.compareTo(lowerLimit) >= 0 && ysmnlValue.compareTo(upperLimit) <= 0) interlockDetail.setInstrumentStatus(instrumentStatusNormal); // 正常
+                        else interlockDetail.setInstrumentStatus(instrumentStatusAbnormal); // 故障
+
+                    } else if(InterlockAllStatus.INSTRUMENT_STATUS_JUDGE2.equals(interlockDetail.getInstrumentStatusJuge())){ //2突变超限判断
+                        //通过判断原始模拟量位号突变（与iotedge_collect_data表的数据进行比较）超过某阈值得出值
+                        // 去采集数据表中根据 设备id+模块名称+点位名称 查询设置的s之前的数据
+                        String yz = interlockDetail.getThresholdValue();  // 阈值
+                        String time = interlockDetail.getThresholdTime();  // 规定的时间
+                        String dw = interlockDetail.getThresholdTimeUnit();   // 时间单位
+
+                        if ("s".equals(dw)){
+                            // 本次原始模拟量值
+                            BigDecimal ysmnlValue = new BigDecimal(interlockDetail.getYsmnlValue());
+
+                            // 查询上一次原始模拟量值
+                            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);  // 开始时间 规定时间的开始时间
+
+                            IotedgeCollectData iotedgeData = iotedgeCollectDataService.getOneInfo(interlockDetail.getYsmnlDeviceId(),interlockDetail.getYsmnlModuleName(),interlockDetail.getYsmnlTag(),beginDate);
+                            BigDecimal beginValue = new BigDecimal("0");
+                            if(iotedgeData != null){
+                                beginValue = new BigDecimal(iotedgeData.getValue());
+                            }
+//                            BigDecimal beginValue = new BigDecimal(iotedgeData.getValue());
+//                            //如果原来的模拟量是0的话
+//                            if(beginValue.equals(BigDecimal.ZERO)){
+//                                beginValue=BigDecimal.valueOf(0.001);
+//                                if(ysmnlValue.equals(BigDecimal.ZERO)){
+//                                    ysmnlValue=BigDecimal.valueOf(0.001);
+//                                }
+//                            }
+//                            System.out.println("beginValue:" + beginValue);
+                            BigDecimal num = ysmnlValue.subtract(beginValue);
+
+                            // (高限-底限) * 阈值  （数据库中的阈值是去掉百分比的直接乘即可）
+                            BigDecimal lowerLimit = new BigDecimal(interlockDetail.getLowerLimit());
+                            BigDecimal upperLimit = new BigDecimal(interlockDetail.getUpperLimit());
+
+                            BigDecimal number = upperLimit.subtract(lowerLimit);
+                            BigDecimal newYz = number.multiply(new BigDecimal(yz));
+//                        if ((num.divide(beginValue).compareTo(newYz)) > 0){
+//                            dto.setInstrumentStatus(instrumentStatusAbnormal); // 故障
+//                        }else dto.setInstrumentStatus(instrumentStatusNormal); // 正常
+                            //有可能出现无限循环小数，保留三位小数
+                            BigDecimal orgYz = new BigDecimal(100);//默认增量百分比为百分百
+                            if(!beginValue.equals(new BigDecimal("0"))){
+                                orgYz = num.divide(beginValue,2,RoundingMode.HALF_UP);
+                            }
+                            if ((orgYz.compareTo(newYz)) > 0){
+                                interlockDetail.setInstrumentStatus(instrumentStatusAbnormal); // 故障
+                            }else interlockDetail.setInstrumentStatus(instrumentStatusNormal); // 正常
+
+//                            if ((num.divide(beginValue,2, RoundingMode.HALF_UP).compareTo(newYz)) > 0){
+//                                interlockDetail.setInstrumentStatus(instrumentStatusAbnormal); // 故障
+//                            }else interlockDetail.setInstrumentStatus(instrumentStatusNormal); // 正常
+                        }
+                    } else if(InterlockAllStatus.INSTRUMENT_STATUS_JUDGE3.equals(interlockDetail.getInstrumentStatusJuge())){
+                        //3默认正常
+                        interlockDetail.setInstrumentStatus(instrumentStatusNormal);
+                    }
+
+                    if(interlockDetail.getInstrumentStatus()!=null && interlockDetail.getInstrumentStatus().equals(instrumentStatusAbnormal)) instrumentStatus = instrumentStatusAbnormal;
+                }
+
+                if(isChangeControlSystemStatus){
+                    //MP状态、输入卡件状态、输出卡件状态如果设置的是默认正常，需要更改默认正常的值
+                    if(interlockDetail.getMpStatusTag() == null){
+                        interlockDetail.setMpStatus(controlSystemStatusNormal);
+                    }
+                    if(interlockDetail.getInputStatusTag() == null){
+                        interlockDetail.setInputStatus(controlSystemStatusNormal);
+                    }
+                    if(interlockDetail.getOutputStatusTag() == null){
+                        interlockDetail.setOutputStatus(controlSystemStatusNormal);
+                    }
+                }
+                //控制系统状态 ——  MP状态、输入卡件状态、输出卡件状态任何一个非正常则控制系统状态非正常。
+                if(controlSystemStatusAbnormal.equals(interlockDetail.getMpStatus()) || controlSystemStatusAbnormal.equals(interlockDetail.getInputStatus()) || controlSystemStatusAbnormal.equals(interlockDetail.getOutputStatus())) {
+                    interlockDetail.setControlSystemStatus(controlSystemStatusAbnormal); // 非正常
+                    controlSystemStatus = controlSystemStatusAbnormal;
+                } else interlockDetail.setControlSystemStatus(controlSystemStatusNormal); // 正常
+                interlockDetailNewList.add(interlockDetail);
+                //新增联锁详细信息表临时表数据
+                InterlockDetailTemp detailTemp = TempConvert.INSTANCE.toInterlockDetailTemp(interlockDetail);
+                interlockDetailTempList.add(detailTemp);
+            }
+
+            //联锁状态
+            interlockSummary.setInterlockStatus(interlockStatus);
+            //回路健康等级
+            loopHealthLevel = getLHL(instrumentStatus, instrumentStatusAbnormal,interlockStatus, interlockStatusWty, controlSystemStatus, controlSystemStatusAbnormal);
+            interlockSummary.setLoopHealthLevel(loopHealthLevel);
+            interlockSummaryNewList.add(interlockSummary);
+            //修改联锁总表临时表数据
+            InterlockSummaryTemp interlockSummaryTemp = TempConvert.INSTANCE.toInterlockSummaryTemp(interlockSummary);
+            interlockSummaryTempList.add(interlockSummaryTemp);
+        }
+
+        //4.将联锁总表和详细表信息更新到数据库
+        interlockSummaryService.updateBatchById(interlockSummaryNewList);
+        interlockDetailService.updateBatchById(interlockDetailNewList);
+        interlockSummaryTempService.updateBatchById(interlockSummaryTempList);
+        interlockDetailTempService.updateBatchById(interlockDetailTempList);
+
+        return;
+    }
+
+    /**
+     * 修改系统时，修改联锁总表的联锁状态和回路健康等级  备份之前的，没有修改点位时间
+     *
+     * @param base
+     */
+    public void updateInterlockSummaryStatus1(InterlockBase base, InterlockBase interlockBaseOrg){
+
+        //设置默认值，默认状态未改变，看系统状态是否发生变化
+        boolean isChangeControlSystemStatus = false;
+        boolean isChangeBypass = false;
+        boolean isChangeInstrumentStatus = false;
+        boolean isChangeInterlockStatus = false;
+
+        //1.获取原来的含义表，先查看系统状态含义是否发生了变化
+        if(!base.getControlSystemStatusNormal().equals(interlockBaseOrg.getControlSystemStatusNormal())){
+            isChangeControlSystemStatus = true;
+        }
+        if(!base.getBypassYes().equals(interlockBaseOrg.getBypassYes())){
+            isChangeBypass = true;
+        }
+        if(!base.getInstrumentStatusNormal().equals(interlockBaseOrg.getInstrumentStatusNormal())){
+            isChangeInstrumentStatus = true;
+        }
+        if(!base.getInterlockStatusTy().equals(interlockBaseOrg.getInterlockStatusTy())){
+            isChangeInterlockStatus = true;
+        }
+        //如果全部状态都未改变，不需要进行状态变化
+        if((!isChangeControlSystemStatus)&&(!isChangeBypass)&&(!isChangeInstrumentStatus)&&(!isChangeInterlockStatus)){
+            return;
+        }
+
+        // 系统设置的各状态
+        // 控制系统状态（输入卡件状态、输出卡件状态、MP状态）
+        String controlSystemStatusNormal = base.getControlSystemStatusNormal(); //正常状态： 如正常
+        String controlSystemStatusAbnormal = editStatus(base.getControlSystemStatusNormal()); //故障状态：如非正常
+        // 旁路状态
+        String bypassYes = base.getBypassYes(); //正常状态： 如否、非旁路
+        String bypassNo = editStatus(base.getBypassYes()); //故障状态：如是、旁路
+        // 仪表状态
+        String instrumentStatusNormal = base.getInstrumentStatusNormal(); //正常状态：如正常
+        String instrumentStatusAbnormal = editStatus(base.getInstrumentStatusNormal()); //故障状态：如非正常
+        // 联锁状态
+        String interlockStatusTy = base.getInterlockStatusTy(); //正常状态： 如投用
+        String interlockStatusWty = editStatus(base.getInterlockStatusTy()); //故障状态：如未投用
+
+        // 获取当前日期时间
+        LocalDateTime currentDateTime = LocalDateTime.now();
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+        String formattedDateTime = currentDateTime.format(formatter);
+
+        //先查找该系统下的联锁总表信息
+        //需要更新的联锁总表信息
+        List<InterlockSummary> interlockSummaryNewList = new ArrayList<>();
+        //需要更新的联锁详细表信息
+        List<InterlockDetail> interlockDetailNewList = new ArrayList<>();
+        //需要更新的联锁总表临时表信息
+        List<InterlockSummaryTemp> interlockSummaryTempList = new ArrayList<>();
+        //需要更新的联锁详细数据临时表信息
+        List<InterlockDetailTemp> interlockDetailTempList = new ArrayList<>();
+
+        //根据系统id查找所有联锁总表信息
+        List<InterlockSummary> interlockSummaryList = interlockAvoidCircularMapper.getInterlockSummaryListBySystemId(base.getId());
+
+        for(InterlockSummary interlockSummary:interlockSummaryList){
             //设置各状态默认值
             String interlockStatus = interlockStatusTy;;//	先设置为 联锁状态-投用
             String loopHealthLevel = "A";// 回路健康级别