Merge branch 'master' of http://8.140.179.55:20000/r/pipIrr-SV

zhubaomin

2024-11-26 d5a24d68b0ddb3faade00504dabc0643db7d056c

Merge branch 'master' of http://8.140.179.55:20000/r/pipIrr-SV

 pipIrr-platform/pipIrr-common/pom.xml

@@ -101,6 +101,11 @@
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3.2</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-extension</artifactId>
            <version>3.5.3.2</version>
        </dependency>

        <!-- é˜¿é‡Œfastjson -->
        <dependency>
@@ -167,6 +172,7 @@
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.17.2</version>
        </dependency>

    </dependencies>

    <build>

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/core/CoreConstantManage.java

@@ -1,5 +1,6 @@
package com.dy.common.mw.core;

import java.util.ArrayList;
import java.util.List;

import org.apache.logging.log4j.*;
@@ -10,10 +11,12 @@
    
    private final static CoreConstantManage instance = new CoreConstantManage() ;

    private static Long sleepBigBusy = 100L ;//大忙时（除了恒久任务，还是其他任务），核心线程暂停间隔
    private static Long sleepSmallBusy = 500L ;//小忙时（只有恒久任务，无其他任务），核心线程暂停间隔
	
    private List<CoreConstantTimer> coreConstantTimers ;

    private Long coreInterval = 100L ;//核心线程暂停间隔

    private CoreConstantManage(){
        coreConstantTimers = new ArrayList<>() ;
    }
    
    public static CoreConstantManage getInstance(){
@@ -22,12 +25,10 @@
    
    /**
     * è®¾ç½®æš‚停时长
     * @param sleepBigBusy å¤§å¿™æ—¶ï¼ˆé™¤äº†æ’久任务，还是其他任务），核心线程暂停间隔
     * @param sleepSmallBusy å°å¿™æ—¶ï¼ˆåªæœ‰æ’久任务，无其他任务），核心线程暂停间隔
     * @param coreInterval æ ¸å¿ƒçº¿ç¨‹æš‚停间隔
     */
    public void setSleep(Long sleepBigBusy, Long sleepSmallBusy){
        CoreConstantManage.sleepBigBusy = sleepBigBusy ;
        CoreConstantManage.sleepSmallBusy = sleepSmallBusy ;
    public void setSleep(Long coreInterval){
        this.coreInterval = coreInterval ;
    }

    public void start(){
@@ -35,7 +36,8 @@
        List<CoreTask> constantTasks = CoreUnit.getAllConstantTasks();
        if (constantTasks != null && constantTasks.size() > 0) {
            for (CoreTask task : constantTasks) {
                new CoreConstantThread(sleepBigBusy, sleepSmallBusy, task).start();
                //new CoreConstantThread(sleepBigBusy, sleepSmallBusy, task).start();
                coreConstantTimers.add(new CoreConstantTimer(coreInterval, task).start());
            }
        }
    }

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/core/CoreConstantThread.java

@@ -9,6 +9,15 @@
 * @LastEditTime 2023/12/19 16:41
 * @Description
 */
/**
 * 2024-11-21 è¯¥ç±»å·²ç»å¼ƒç”¨ï¼Œæ”¹ç”±CoreConstantTimer实现。
 * å½“采用Thread实现时，在while(true){}中使用Thread.sleep()，可能导致的严重性能问题，不推荐在循环中使用线程休眠。
 * Java线程实现采用内核线程实现，线程的休眠及唤醒（状态切换）需借助操作系统进行，这是一个极其耗时耗力的操作。
 * åœ¨çº¿ç¨‹ä¼‘眠或运行时间较长的情景下，其对性能的影响还不算明显，因为对线程状态的切换并不频繁。
 * ä½†è‹¥çº¿ç¨‹ä¼‘眠及运行的时间都很短（例如毫秒/秒），
 * ç³»ç»Ÿå°†é¢‘繁的对线程状态进行切换，导致严重的性能损耗，并对着循环次数的递增而放大。
 */
@Deprecated
public class CoreConstantThread extends Thread {

    private final static Logger log = LogManager.getLogger(CoreConstantThread.class.getName()) ;

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/core/CoreConstantTimer.java

New file
@@ -0,0 +1,45 @@
package com.dy.common.mw.core;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import java.util.Timer;
import java.util.TimerTask;

/**
 * @Author: liurunyu
 * @Date: 2024/11/21 17:13
 * @Description
 */
public class CoreConstantTimer extends TimerTask {

    private final static Logger log = LogManager.getLogger(CoreConstantTimer.class.getName()) ;

    private Timer timer;

    private long coreInterval ;

    private CoreTask task ;

    public CoreConstantTimer(long coreInterval, CoreTask task){
        this.timer = new Timer();
        this.coreInterval = coreInterval ;
        this.task = task ;
    }

    public CoreConstantTimer start(){
        this.timer.schedule(this, 0 , this.coreInterval);
        return this ;
    }

    @Override
    public void run() {
        if(task != null){
            try {
                task.execute();
            } catch (Exception e) {
                log.error("恒久任务" + task.getClass().getName() + "执行时发生异常" + (e.getMessage() == null ? "" : (":" + e.getMessage())), e);
            }
        }
    }
}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/core/CoreThread.java

@@ -4,6 +4,15 @@

import com.dy.common.queue.Queue;

/**
 * 2024-11-21 è¯¥ç±»å·²ç»å¼ƒç”¨ï¼Œæ”¹ç”±CoreTimer实现。
 * å½“采用Thread实现时，在while(true){}中使用Thread.sleep()，可能导致的严重性能问题，不推荐在循环中使用线程休眠。
 * Java线程实现采用内核线程实现，线程的休眠及唤醒（状态切换）需借助操作系统进行，这是一个极其耗时耗力的操作。
 * åœ¨çº¿ç¨‹ä¼‘眠或运行时间较长的情景下，其对性能的影响还不算明显，因为对线程状态的切换并不频繁。
 * ä½†è‹¥çº¿ç¨‹ä¼‘眠及运行的时间都很短（例如毫秒/秒），
 * ç³»ç»Ÿå°†é¢‘繁的对线程状态进行切换，导致严重的性能损耗，并对着循环次数的递增而放大。
 */
@Deprecated
public class CoreThread extends Thread{
    
    private static Logger log = LogManager.getLogger(CoreThread.class.getName()) ;

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/core/CoreTimer.java

New file
@@ -0,0 +1,80 @@
package com.dy.common.mw.core;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import java.util.Timer;
import java.util.TimerTask;

/**
 * @Author: liurunyu
 * @Date: 2024/11/21 13:41
 * @Description
 */
public class CoreTimer extends TimerTask {

    private static final Logger log = LogManager.getLogger(CoreTimer.class.getName()) ;

    private static final CoreTimer instance = new CoreTimer() ;

    private Long workInterval = 100L ;//核心线程暂停间隔

    private Timer timer;

    private boolean stop;

    private CoreTimer(){
        this.timer = new Timer();
        this.stop = false ;
    }

    public static CoreTimer getInstance(){
        return instance ;
    }

    public void stop(){
        this.stop = true ;
        if(this.timer != null){
            this.timer.cancel();
        }
    }
    public boolean isStop(){
        return this.stop ;
    }

    /**
     * è®¾ç½®/核心线程暂停间隔
     * @param workInterval /核心线程暂停间隔
     */
    public void setSleep(Long workInterval){
        this.workInterval = workInterval ;
    }

    public void start(){
        this.timer.schedule(this, 0 , this.workInterval);
    }

    /**
     * TimerTask的run方法
     */
    @Override
    public void run() {
        try{
            /**
             * æ­¤å¤„取出当前队列的节点数量，作为一个定量count处理，
             * åŽŸå› :
             * åœ¨å¤„理定量count过程中，可能有的节点又回到队列中，也可能新生节点进入队列中，即在处理过程中，队列可能又增长了
             */
            int count = CoreUnit.taskQueue.size() ;
            while(count > 0){
                CoreTask task = (CoreTask)CoreUnit.taskQueue.pop() ;
                if(task != null){
                    task.execute();
                }
                count-- ;
            }
        }catch(Exception e){
            log.error("核心线程发生异常" + (e.getMessage() == null ? "" : (":" + e.getMessage())), e);;
        }
    }
}

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/core/CoreUnit.java

@@ -8,6 +8,7 @@
import com.dy.common.mw.UnitInterface;
import com.dy.common.mw.UnitCallbackInterface;


public class CoreUnit implements UnitInterface {
    
    private static final CoreUnit instance = new CoreUnit() ;
@@ -36,17 +37,14 @@
        if(vo == null){
            throw new Exception("核心模块配置对象不能为空！") ;
        }
        if(vo.sleepBigBusy == null || vo.sleepSmallBusy == null){
        if(vo.coreInterval == null){
            throw new Exception("核心模块配置对象间隔属性值不能为空！") ;
        }
        if(vo.sleepBigBusy <= 0){
            throw new Exception("核心模块配置对象属性sleepBigBusy值不能小于0！") ;
        if(vo.coreInterval <= 0){
            throw new Exception("核心模块配置对象属性coreInterval值不能小于0！") ;
        }
        if(vo.sleepBigBusy > 1000){
            throw new Exception("核心模块配置对象属性sleepBigBusy值不能大于1000！") ;
        }
        if(vo.sleepSmallBusy > 1000){
            throw new Exception("核心模块配置对象属性sleepSmallBusy值不能大于1000！") ;
        if(vo.coreInterval > 1000){
            throw new Exception("核心模块配置对象属性coreInterval值不能大于1000！") ;
        }
        if(vo.queueWarnSize == null || vo.queueMaxSize == null){
            throw new Exception("核心模块配置对象队列节点限制数量属性值不能为空！") ;
@@ -67,18 +65,22 @@
    public void start(UnitCallbackInterface callback) throws Exception {
        if(!started){
            started = true ;
            /*
            CoreThread ct = CoreThread.getInstance() ;
            ct.setSleep(this.adapter.getConfig().sleepBigBusy, this.adapter.getConfig().sleepSmallBusy);
            ct.start(); 
			
            ct.start();
            */
            CoreTimer ct = CoreTimer.getInstance() ;
            ct.setSleep(this.adapter.getConfig().coreInterval);
            ct.start();

            CoreConstantManage ccm = CoreConstantManage.getInstance() ;
            ccm.setSleep(this.adapter.getConfig().sleepBigBusy, this.adapter.getConfig().sleepSmallBusy);
            ccm.setSleep(this.adapter.getConfig().coreInterval);
            ccm.start();
            
            if(adapter.getConfig().showStartInfo){
                System.out.println("核心模块成功启动，"
                        + "主线程繁忙间隔：" + adapter.getConfig().sleepBigBusy + "毫秒，"
                        + "轻闲间隔：" + adapter.getConfig().sleepSmallBusy + "毫秒"  );
                        + "主线程执行间隔：" + adapter.getConfig().coreInterval + "毫秒");
            }
            callback.call(null);
        }

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/mw/core/CoreUnitConfigVo.java

@@ -1,8 +1,7 @@
package com.dy.common.mw.core;

public class CoreUnitConfigVo {
    public Long sleepBigBusy = 100L ;//大忙时（除了恒久任务，还有其他任务需处理），核心线程暂停间隔
    public Long sleepSmallBusy = 500L ;//小忙时（只有恒久任务，无其他任务需处理），核心线程暂停间隔
    public Long coreInterval = 100L ;//大忙时（除了恒久任务，还有其他任务需处理），核心线程暂停间隔
    public Integer queueWarnSize = 1000 ;//队列报警长度
    public Integer queueMaxSize = 5000 ;//队列最大长度
    public Boolean showStartInfo; //是否在控制台上显示信息

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/softUpgrade/state/UpgradeRtu.java

@@ -22,9 +22,9 @@
    @JSONField(serialize = false)
    public static final int STATE_SUCCESS = 2 ;//2-升级成功
    @JSONField(serialize = false)
    public static final int STATE_FAILONE = 3 ;//3-升级失败（1包死）
    public static final int STATE_FAILONE = 3 ;//3-升级失败（一包死）
    @JSONField(serialize = false)
    public static final int STATE_FAIL = 4 ;//4-升级失败（非1包死）
    public static final int STATE_FAIL = 4 ;//4-升级失败（多包死）
    @JSONField(serialize = false)
    public static final int STATE_FAILOFFLINE = 5 ;//4-升级失败（离线）
    @JSONField(serialize = false)

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/softUpgrade/state/UpgradeState.java

@@ -18,6 +18,7 @@
    public int successTotal ;//所有成功
    public int failTotal ;//所有失败（一包死失败+多包死失败+离线失败）
    public int failOneTotal ;//所有一包死失败
    public int failMultiTotal ;//所有多包死失败
    public int failOffTotal ;//所有离线失败

    public Boolean allOver ;//所有都结束（true:是，false:否）
@@ -35,6 +36,7 @@
        this.successTotal = 0;
        this.failTotal = 0;
        this.failOneTotal = 0;
        this.failMultiTotal = 0;
        this.failOffTotal = 0;
        this.allOver = false ;
    }
@@ -49,7 +51,8 @@
        sb.append("    \n已结束总数：" + overTotal) ;
        sb.append("    \n成功总数：" + successTotal) ;
        sb.append("    \n失败总数：" + failTotal) ;
        sb.append("    \n1包死失败总数：" + failOneTotal) ;
        sb.append("    \n一包死失败总数：" + failOneTotal) ;
        sb.append("    \n多包死失败总数：" + failMultiTotal) ;
        sb.append("    \n离线失败总数：" + failOffTotal) ;
        sb.append("    \n全结束：" + allOver) ;
        return sb.toString() ;

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/util/CreateRandom.java

@@ -11,13 +11,15 @@

    /*
    public static void main(String[] args) {
        System.out.println(CreateRandom.Random(1, 0));
        System.out.println(CreateRandom.Random(2, 0));
        System.out.println(CreateRandom.Random(3, 0));
        System.out.println(CreateRandom.Random(4, 0));
        System.out.println(CreateRandom.Random(5, 0));
        System.out.println(CreateRandom.Random(100, 0));
        System.out.println(CreateRandom.Random(1256, 1234));
        System.out.println(CreateRandom.random(1, 0));
        System.out.println(CreateRandom.random(2, 0));
        System.out.println(CreateRandom.random(3, 0));
        System.out.println(CreateRandom.random(4, 0));
        System.out.println(CreateRandom.random(5, 0));
        System.out.println(CreateRandom.random(100, 0));
        System.out.println(CreateRandom.random(1256, 1234));
        System.out.println("=======================");
        System.out.println(create_between(10, 100));
    }
    */
    

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/util/ThreadJob.java

@@ -2,6 +2,7 @@


@SuppressWarnings("unused")
@Deprecated
public abstract class ThreadJob {
    protected Thread thread ;
    protected boolean stop = false ;

 pipIrr-platform/pipIrr-common/src/main/java/com/dy/common/util/TimerTaskJob.java

@@ -7,11 +7,12 @@
 * @Author: liurunyu
 * @Date: 2024/11/20 17:49
 * @Description :
 * 2024-11-20：
 * æ­¤æŠ½è±¡ç±»ä»£æ›¿ThreadJob，原因：
 * åœ¨while(true){}中使用Thread.sleep()，可能导致的严重性能问题，不推荐在循环中使用线程休眠。
 * Java线程实现采用内核线程实现，线程的休眠及唤醒（状态切换）需借助操作系统进行，这是一个极其耗时耗力的操作。
 * åœ¨çº¿ç¨‹ä¼‘眠或运行时间较长的情景下，其对性能的影响还不算明显，因为对线程状态的切换并不频繁。
 * ä½†è‹¥çº¿ç¨‹ä¼‘眠及运行的时间都很短（例如毫秒/秒，文中案例就是一个典型案例），
 * ä½†è‹¥çº¿ç¨‹ä¼‘眠及运行的时间都很短（例如毫秒/秒），
 * ç³»ç»Ÿå°†é¢‘繁的对线程状态进行切换，导致严重的性能损耗，并对着循环次数的递增而放大。
 */
public abstract class TimerTaskJob {

 pipIrr-platform/pipIrr-global/pom.xml

@@ -69,7 +69,6 @@
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.28</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
@@ -94,6 +93,11 @@
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3.2</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-extension</artifactId>
            <version>3.5.3.2</version>
        </dependency>
        <!-- é˜¿é‡Œfastjson -->
        <dependency>
            <groupId>cglib</groupId>

 pipIrr-platform/pipIrr-global/src/main/java/com/dy/pipIrrGlobal/daoOp/OpeInspectMapper.java

@@ -2,7 +2,11 @@

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.dy.pipIrrGlobal.pojoOp.OpeInspect;
import com.dy.pipIrrGlobal.voOp.VoInspect;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;
import java.util.Map;

/**
 * @author ZhuBaoMin
@@ -24,4 +28,18 @@
    int updateByPrimaryKeySelective(OpeInspect record);

    int updateByPrimaryKey(OpeInspect record);

    /**
     * å·¡æ£€æŸ¥è¯¢
     * @param params
     * @return
     */
    Long getInspectsCount(Map<String, Object> params);

    /**
     * å·¡æ£€æŸ¥è¯¢
     * @param params
     * @return
     */
    List<VoInspect> getInspects(Map<String, Object> params);
}

 pipIrr-platform/pipIrr-global/src/main/java/com/dy/pipIrrGlobal/daoOp/OpeTrackMapper.java

@@ -33,4 +33,11 @@
     * @return
     */
    int insertTracks(List<OpeTrack> list);

    /**
     * é€šè¿‡å·¡æ£€ID查询轨迹
     * @param inspectId
     * @return
     */
    List<OpeTrack> selectByInspectId(Long inspectId);
}

 pipIrr-platform/pipIrr-global/src/main/java/com/dy/pipIrrGlobal/voOp/VoInspect.java

New file
@@ -0,0 +1,53 @@
package com.dy.pipIrrGlobal.voOp;

import com.dy.common.po.BaseEntity;
import com.dy.pipIrrGlobal.pojoOp.OpeTrack;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import lombok.Data;
import java.util.Date;

import java.util.List;

/**
 * @author :WuZeYu
 * @Date :2024/11/20  15:37
 * @LastEditTime :2024/11/20  15:37
 * @Description
 */
@Data
public class VoInspect implements BaseEntity {
    private static final long serialVersionUID = 202411201537001L;

    /**
     * å·¡æ£€å‘˜ID
     */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long inspectorId;

    /**
     * å·¡æ£€å‘˜å§“名
     */
    private String inspectorName;

    /**
     * å·¡æ£€ID
     */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long inspectId;
    /**
     * å¼€å§‹å·¡æ£€æ—¶é—´
     */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date startTime;
    /**
     * ç»“束巡检时间
     */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    private Date stopTime;
    /**
     * å„个巡检点
     */
    private List<OpeTrack> tracks;
}

 pipIrr-platform/pipIrr-global/src/main/java/com/dy/pipIrrGlobal/voUg/VoUgRtuResult.java

New file
@@ -0,0 +1,30 @@
package com.dy.pipIrrGlobal.voUg;

import com.alibaba.excel.annotation.ExcelProperty;
import com.alibaba.excel.annotation.write.style.ColumnWidth;
import com.alibaba.excel.annotation.write.style.ContentRowHeight;
import com.alibaba.excel.annotation.write.style.ContentStyle;
import com.alibaba.excel.annotation.write.style.HeadRowHeight;
import com.alibaba.excel.enums.poi.HorizontalAlignmentEnum;
import com.alibaba.excel.enums.poi.VerticalAlignmentEnum;
import lombok.Data;

/**
 * @Author: liurunyu
 * @Date: 2024/11/22 14:26
 * @Description
 */
@Data
@HeadRowHeight(26)
@ContentRowHeight(22)
public class VoUgRtuResult {
    @ExcelProperty("控制器地址")
    @ColumnWidth(20)
    @ContentStyle(horizontalAlignment = HorizontalAlignmentEnum.CENTER, verticalAlignment = VerticalAlignmentEnum.CENTER)
    public String rtuAddr;

    @ExcelProperty("升级结果")
    @ColumnWidth(30)
    @ContentStyle(horizontalAlignment = HorizontalAlignmentEnum.LEFT, verticalAlignment = VerticalAlignmentEnum.CENTER)
    public String result;
}

 pipIrr-platform/pipIrr-global/src/main/java/com/dy/pipIrrGlobal/voUg/VoWatch.java

@@ -28,15 +28,19 @@
        public String rtuAddr ;     //控制器地址
        public Integer rate ;       //进度
        public String state;        //升级状态
        public Integer status;      //过程状态（0：离线，1：升级中，2：升级成功，3升级失败）
        public Integer status;      //过程状态（0：离线，1：升级中，2：升级成功，3升级失败），前端利用其设置卡片样式
        public Integer reTryTimes ; //重试次数
        public Boolean over ;       //是否结束（true：是，false：否）
        public Boolean success ;    //是否成功（null:进行中，true：是，false：否）

        public void fromCache(UpgradeRtu ugRtu){
            this.rtuAddr = ugRtu.rtuAddr ;

            this.rate = (ugRtu.currentPackage * 1000)/ugRtu.totalPackage ;//前端实现是1000份的进度条

            this.state = UpgradeRtu.getStateName(ugRtu.state) ;

            //过程状态（0：离线，1：升级中，2：升级成功，3升级失败），前端利用其设置卡片样式
            this.status = 1 ;//默认升级中
            if(ugRtu.state == UpgradeRtu.STATE_OFFLINE){
                this.status = 0 ;
@@ -47,8 +51,12 @@
                    this.status = 3;
                }
            }


            this.reTryTimes = ugRtu.reTryTimes ;

            this.over = ugRtu.isOver ;

            if(ugRtu.isOver){
                this.success = (ugRtu.state == UpgradeRtu.STATE_SUCCESS ? true : false) ;
            }else{

 pipIrr-platform/pipIrr-global/src/main/resources/application-global.yml

@@ -313,7 +313,7 @@
    #命令发送地址(中缀是机构tag，其也是数据源后缀名称)
    ym:
        comSendUrl: "http://127.0.0.1:8070/rtuMw/com/send"
        ugTaskSendUrl: "http://192.168.40.132:8070/rtuMw/com/upgradeRtu"
        ugTaskSendUrl: "http://127.0.0.1:8070/rtuMw/com/upgradeRtu"
        rtuLogFileUrl: "http://127.0.0.1:8070/rtuMw/com/rtuLogFile"
        rtuLogTextUrl: "http://127.0.0.1:8070/rtuMw/com/rtuLogText"
    sp:

 pipIrr-platform/pipIrr-global/src/main/resources/mapper/OpeInspectMapper.xml

@@ -88,4 +88,52 @@
      stop_time = #{stopTime,jdbcType=TIMESTAMP}
    where id = #{id,jdbcType=BIGINT}
  </update>
<!-- æŸ¥è¯¢æ€»æ•° -->
  <select id="getInspectsCount" resultType="java.lang.Long">
    SELECT
    count(*)
    FROM    `ope_inspect` oi
    INNER JOIN `ba_user` ON oi.inspector_id = ba_user.id
    <where>
      ba_user.deleted = 0
      <if test="inspectorId != null">
        AND oi.inspector_id = #{inspectorId}
      </if>
      <if test="inspectId != null">
        AND oi.id = #{inspectId}
      </if>
      <if test="inspectorName != null">
        AND ba_user.`name` LIKE CONCAT('%',#{inspectorName},'%')
      </if>
      <if test="timeStart != null and timeStop != null">
        AND oi.start_time BETWEEN #{timeStart} AND #{timeStop}
      </if>
    </where>
    </select>
<!-- æŸ¥è¯¢åˆ—表 -->
  <select id="getInspects" resultType="com.dy.pipIrrGlobal.voOp.VoInspect">
    SELECT
      oi.inspector_id AS inspectorId,
      ba_user.`name` AS inspectorName,
      oi.id AS inspectId,
      oi.start_time AS startTime,
      oi.stop_time AS stopTime
    FROM    `ope_inspect` oi
              INNER JOIN `ba_user` ON oi.inspector_id = ba_user.id
    <where>
      ba_user.deleted = 0
      <if test="inspectorId != null">
        AND oi.inspector_id = #{inspectorId}
      </if>
      <if test="inspectId != null">
        AND oi.id = #{inspectId}
      </if>
      <if test="inspectorName != null">
        AND ba_user.`name` LIKE CONCAT('%',#{inspectorName},'%')
      </if>
      <if test="timeStart != null and timeStop != null">
        AND oi.start_time BETWEEN #{timeStart} AND #{timeStop}
      </if>
    </where>
  </select>
</mapper>

 pipIrr-platform/pipIrr-global/src/main/resources/mapper/OpeTrackMapper.xml

@@ -108,4 +108,15 @@
      (#{item.id}, #{item.inspectId}, #{item.lng}, #{item.lat}, #{item.locateTime})
    </foreach>
  </insert>
    <!--根据巡检id查询轨迹-->
<!--  <select id="selectByInspectId" resultMap="BaseResultMap">-->
  <select id="selectByInspectId" resultType="com.dy.pipIrrGlobal.pojoOp.OpeTrack">
    SELECT
      id,
      inspect_id AS inspectId,
      lng,
      lat,
      locate_time AS locateTime
    FROM ope_track WHERE inspect_id = #{inspectId}
  </select>
</mapper>

 pipIrr-platform/pipIrr-global/src/main/resources/mapper/SeGeneralMapper.xml

@@ -157,7 +157,7 @@
        1 AS auditStatus
    FROM se_card_operate ope
        INNER JOIN ba_user us ON ope.operator = us.id
    WHERE Date(ope.operate_dt) = #{operateDate}
    WHERE Date(ope.operate_dt) = #{operateDate} AND ope.operate_valid = 2
    GROUP BY ope.operator, Date(ope.operate_dt)

    UNION ALL

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/Server.java

@@ -336,11 +336,11 @@
            //RTU远程升级模块
            UpgradeUnitConfigVo ugVo = new UpgradeUnitConfigVo();
            ugVo.enable = conf.getSetAttrBoolean(doc, "config.upgrade", "enable", null, null) ;
            ugVo.noOneRtuUpgradeMaxDuration = conf.getSetAttrPlusInt(doc, "config.upgrade", "noOneRtuUpgradeMaxDuration", null, 5, 3600, null);
            ugVo.noOneRtuUpgradeMaxDuration = conf.getSetAttrPlusInt(doc, "config.upgrade", "noOneRtuUpgradeMaxDuration", null, 5, 360000, null);
            ugVo.noOneRtuUpgradeMaxDuration = ugVo.noOneRtuUpgradeMaxDuration * 1000 ;//变成毫秒
            ugVo.failTryTimes = conf.getSetAttrPlusInt(doc, "config.upgrade", "failTryTimes", null, 0, 100, null);
            ugVo.ugMaxRtuAtOnce = conf.getSetAttrPlusInt(doc, "config.upgrade", "ugMaxRtuAtOnce", null, 0, 1000000, null);
            ugVo.rtuOffLineWaitDuration = conf.getSetAttrPlusInt(doc, "config.upgrade", "rtuOffLineWaitDuration", null, 1, 36000, null);
            ugVo.rtuOffLineWaitDuration = conf.getSetAttrPlusInt(doc, "config.upgrade", "rtuOffLineWaitDuration", null, 1, 3600000, null);
            ugVo.rtuOffLineWaitDuration = ugVo.rtuOffLineWaitDuration * 1000;//变成毫秒
            ugVo.notifyStateInterval = conf.getSetAttrPlusInt(doc, "config.upgrade", "notifyStateInterval", null, 1, 300, null);
            ugVo.notifyStateInterval = ugVo.notifyStateInterval * 1000;//变成毫秒
@@ -370,8 +370,7 @@
            // ///////////////
            // æ ¸å¿ƒ
            CoreUnitConfigVo coreConfVo = new CoreUnitConfigVo();
            coreConfVo.sleepBigBusy = conf.getSetAttrPlusInt(doc, "config.core", "sleepBigBusy", null, 1, 200, null).longValue() ;
            coreConfVo.sleepSmallBusy = conf.getSetAttrPlusInt(doc, "config.core", "sleepSmallBusy", null, 2, 1000, null).longValue();
            coreConfVo.coreInterval = conf.getSetAttrPlusInt(doc, "config.core", "coreInterval", null, 1, 200, null).longValue() ;
            coreConfVo.queueWarnSize = ServerProperties.cacheUpDownDataWarnCount ;
            coreConfVo.queueMaxSize = ServerProperties.cacheUpDownDataMaxCount ;
            coreConfVo.showStartInfo = showStartInfo ;

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/upgrade/UpgradeManager.java

@@ -64,6 +64,11 @@
                this.task = new UpgradeTask();
                this.task.initOption(this.failTryTimes, this.ugMaxRtuSameTime);
                this.task.setTask(vo);
                log.error("==================================================") ;
                log.error("=                                                =") ;
                log.error("=当前设置了升级任务，其中RTU有" + vo.rtuAddrList.size() + "个                    =") ;
                log.error("=                                                =") ;
                log.error("==================================================") ;
            }catch (Exception e){
                ex = e ;
            }finally {
@@ -182,22 +187,51 @@
                //升级任务未完成
                //工作1：判断是否无任何一个RTU进行过升级，并且达到时限，则认为当前升级任务完成
                //-1:无一RTU升级且超时，0：无RTU升级但未超时等待，1有RTU升级正常执行
                //int temp = 1 ;
                int temp = this.task.countNoOneRtuUpgradeInDuration() ;
                if(temp == -1){
                    //当前没有RTU进行过升级，而且超时了，认为任务已经完成
                    log.error("==================================================") ;
                    log.error("=                                                =") ;
                    log.error("=当前没有RTU进行过升级，而且超时了，认为任务已经完成      =") ;
                    log.error("=                                                =") ;
                    log.error("==================================================") ;
                    this.task.taskIsOver = true ;
                    //任务已经完成
                    this.stop();
                }else if(temp == 1){
                    //当前有RTU进行过升级
                    //工作2：统计当前正在升级的RTU数量，为同时升级数量限制做准备
                    this.task.countRunningRtuCount() ;

                    //工作3：统计需要升级但当前离线RTU的情况，超过时限的设备为升级完成
                    this.task.countOffRtuAndSetIfOver() ;

                    //工作3：统计需要升级但当前离线RTU的情况，超过时限的设置为升级完成
                    int tmp = this.task.countOffRtuAndSetIfOver() ;
                    if(tmp >= 1){
                        //超时，强制设置一些RTU升级失败并且升级完成）
                        log.error("==================================================") ;
                        log.error("=                                                =") ;
                        log.error("=超时，强制设置" + tmp + "个RTU升级失败并且升级完成     =") ;
                        log.error("=                                                =") ;
                        log.error("==================================================") ;
                    }else if(tmp == 0){
                        log.error("==================================================") ;
                        log.error("=                                                =") ;
                        log.error("=超时，强制设置0个RTU升级失败并且升级完成               =") ;
                        log.error("=                                                =") ;
                        log.error("==================================================") ;
                    }else{//tmp = -1
                        //无任务逻辑
                    }
                    //工作4：统计是否全部升级完成
                    this.task.taskIsOver = this.task.countIsAllOver() ;
                    if(this.task.taskIsOver){
                        log.error("==================================================") ;
                        log.error("=                                                =") ;
                        log.error("=升级全部结束，设置升级任务完成                       =") ;
                        log.error("=                                                =") ;
                        log.error("==================================================") ;
                    }
                }else if(temp == 0){
                    //不作为
                    //当前没有一个RTU进行过升级，也没有超时，不作为
                }
                if(this.task.taskIsOver){
                    if(!this.task.taskOverType.equals(UpgradeTask.TaskOverType_Force)){

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/upgrade/UpgradeTask.java

@@ -13,6 +13,7 @@

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * @Author: liurunyu
@@ -136,8 +137,7 @@
                    //rtu不在升级之列
                    return ;
                }
            }
            if(ugRtu != null){
            }else{
                if(ugRtu.isOver){
                    //当前RTU已经升级完成，无需再升级
                    return;
@@ -173,9 +173,6 @@
                         ugRtu.trigger(code, protocolName, protocolVersion, this.softFileDataGrp, callbackCom) ;
                    }
                }
            }else{
                //rtu不在升级之列
                return ;
            }
        }
    }
@@ -202,19 +199,21 @@
        if(this.taskVo.rtuAddrList != null && this.taskVo.rtuAddrList.size() > 0){
            state.rtuTotal = this.taskVo.rtuAddrList.size() ;
            if(this.upgradeRtus != null && this.upgradeRtus.size() > 0){
                this.upgradeRtus.values().stream().forEach(info ->{
                AtomicBoolean hasRunning = new AtomicBoolean(false);
                this.upgradeRtus.values().forEach(info ->{
                    if(info.state == UpgradeRtu.STATE_OFFLINE){
                        state.offLineTotal ++ ;
                        state.offLineTotal++ ;
                    }else if(info.state == UpgradeRtu.STATE_UNSTART){
                        state.unStartTotal ++ ;
                    }else if(info.state == UpgradeRtu.STATE_RUNNING){
                        state.runningTotal ++ ;
                    }else if(info.state == UpgradeRtu.STATE_SUCCESS) {
                        state.successTotal++;
                    }else if(info.state == UpgradeRtu.STATE_FAIL) {
                        state.failTotal++;
                    }else if(info.state == UpgradeRtu.STATE_FAILONE) {
                        state.failOneTotal++;
                        state.failTotal++;
                    }else if(info.state == UpgradeRtu.STATE_FAIL) {
                        state.failMultiTotal++;
                        state.failTotal++;
                    }else if(info.state == UpgradeRtu.STATE_FAILOFFLINE) {
                        state.failTotal++;
@@ -222,8 +221,15 @@
                    }
                    if(info.isOver){
                        state.overTotal++;
                    }else{
                        hasRunning.set(true);
                    }
                });
                if(!hasRunning.get()){
                    state.allOver = true ;
                }else{
                    state.allOver = false ;
                }
            }
        }
        return state ;
@@ -266,7 +272,9 @@
    }

    ///////////////////////////////////////////////////////////
    //以下方法为内部服务，不对外提供服务
    //
    //   ä»¥ä¸‹æ–¹æ³•ä¸ºå†…部服务，不对外提供服务
    //
    ///////////////////////////////////////////////////////////

    /**
@@ -312,20 +320,26 @@

    /**
     * ç»Ÿè®¡éœ€è¦å‡çº§ä½†å½“前离线RTU的情况，超过时限的设备为升级完成
     * @return -1:没有超时，0超时了且无因离线被强制设置升级完成的RTU，>0离线被强制设置升级完成的RTU数量
     */
    protected void countOffRtuAndSetIfOver() {
    protected int countOffRtuAndSetIfOver() {
        Long now = System.currentTimeMillis() ;
        if(now - this.setupDtLong > UpgradeUnit.confVo.rtuOffLineWaitDuration){
            //rtu离线，等待其升级的时长(毫秒)，超过配置的最大时长，设置其升级失败，且设置升级任务完成
            int count = 0 ;
            if (this.taskVo.rtuAddrList != null && this.taskVo.rtuAddrList.size() > 0) {
                Collection<UpgradeRtu> col = this.upgradeRtus.values() ;
                for(UpgradeRtu info : col){
                    if(info.state == UpgradeRtu.STATE_OFFLINE){
                        info.isOver = true ;
                        info.state = UpgradeRtu.STATE_FAILOFFLINE ;
                        count ++ ;
                    }
                }
            }
            return count ;
        }else{
            return -1 ;
        }
    }


 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/resources/config(spɳÅÌ).xml

@@ -124,14 +124,12 @@
    />

    <!--
    sleepBigBusy：主线程大忙时每次执行间隔时长（毫秒）
    sleepSmallBusy：主线程小忙时每次执行间隔时长（毫秒）
    coreInterval：主线程每次执行间隔时长（毫秒）
    queueWarnSize: ç¼“存队列节点数警告数量
    queueMaxSize: ç¼“存队列节点数最大数量
     -->
    <core
            sleepBigBusy="100"
            sleepSmallBusy="500"
            coreInterval="100"
            queueWarnSize="100000"
            queueMaxSize="300000"
    />

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/resources/config(test²âÊÔ).xml

@@ -124,14 +124,12 @@
    />

    <!--
    sleepBigBusy：主线程大忙时每次执行间隔时长（毫秒）
    sleepSmallBusy：主线程小忙时每次执行间隔时长（毫秒）
    coreInterval：主线程每次执行间隔时长（毫秒）
    queueWarnSize: ç¼“存队列节点数警告数量
    queueMaxSize: ç¼“存队列节点数最大数量
     -->
    <core
            sleepBigBusy="100"
            sleepSmallBusy="500"
            coreInterval="100"
            queueWarnSize="100000"
            queueMaxSize="300000"
    />

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/resources/config(ymԪı).xml

@@ -124,14 +124,12 @@
    />

    <!--
    sleepBigBusy：主线程大忙时每次执行间隔时长（毫秒）
    sleepSmallBusy：主线程小忙时每次执行间隔时长（毫秒）
    coreInterval：主线程每次执行间隔时长（毫秒）
    queueWarnSize: ç¼“存队列节点数警告数量
    queueMaxSize: ç¼“存队列节点数最大数量
     -->
    <core
            sleepBigBusy="100"
            sleepSmallBusy="500"
            coreInterval="100"
            queueWarnSize="100000"
            queueMaxSize="300000"
    />

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/resources/config.xml

@@ -63,10 +63,10 @@
    notifyStateInterval: å‡çº§çŠ¶æ€é€šçŸ¥é—´éš”（秒）
    -->
    <upgrade enable="true"
             noOneRtuUpgradeMaxDuration="600"
             noOneRtuUpgradeMaxDuration="1200"
             failTryTimes="1"
             ugMaxRtuAtOnce="1000"
             rtuOffLineWaitDuration="1200"
             rtuOffLineWaitDuration="1800"
             notifyStateInterval="2"
    />

@@ -124,14 +124,12 @@
    />

    <!--
    sleepBigBusy：主线程大忙时每次执行间隔时长（毫秒）
    sleepSmallBusy：主线程小忙时每次执行间隔时长（毫秒）
    coreInterval：主线程每次执行间隔时长（毫秒）
    queueWarnSize: ç¼“存队列节点数警告数量
    queueMaxSize: ç¼“存队列节点数最大数量
     -->
    <core
            sleepBigBusy="100"
            sleepSmallBusy="500"
            coreInterval="100"
            queueWarnSize="100000"
            queueMaxSize="300000"
    />

 pipIrr-platform/pipIrr-mw/pipIrr-mw-simulate-rtu/src/main/java/com/dy/simRtu/PipIrrMwSimulateRtuApplication.java

@@ -34,6 +34,27 @@
public class PipIrrMwSimulateRtuApplication implements CommandLineRunner {

    public static void main(String[] args) {
        if(args != null && args.length > 0){
            if(args.length == 3){
                if(args[0] instanceof String){
                    if(args[0] != null && !args[0].trim().equals("")){
                        String rtuAddr = (String)args[0] ;//本模拟器模拟RTU地址
                        ServerProperties.argRtuAddr = rtuAddr ;
                    }
                    if(args[1] != null && !args[1].trim().equals("")){
                        Integer oneDie = Integer.parseInt(args[1]) ;//一包死：1是，0否
                        ServerProperties.argOneDie = oneDie == 1?true:false ;
                    }
                    if(args[2] != null && !args[2].trim().equals("")){
                        Integer multiDie = Integer.parseInt(args[2]) ;//多包死：1是，0否
                        ServerProperties.argMultiDie = multiDie == 1?true:false ;
                    }
                    if(ServerProperties.argOneDie && ServerProperties.argMultiDie){
                        ServerProperties.argOneDie = false ;
                    }
                }
            }
        }
        new SpringApplicationBuilder(PipIrrMwSimulateRtuApplication.class)
                .web(WebApplicationType.NONE)//不启动web服务
                .run(args);

 pipIrr-platform/pipIrr-mw/pipIrr-mw-simulate-rtu/src/main/java/com/dy/simRtu/Server.java

@@ -44,6 +44,16 @@

            this.startUnits() ;

            if(ServerProperties.argRtuAddr != null && !ServerProperties.argRtuAddr.trim().equals("")){
                System.out.println("参数RTU地址：" + ServerProperties.argRtuAddr) ;
                ServerProperties.rtuAddr = ServerProperties.argRtuAddr ;
            }else{
                 System.out.println("配置RTU地址：" + ServerProperties.rtuAddr) ;
            }

            System.out.println("启动一包死：" + (ServerProperties.argOneDie==null?"否":(ServerProperties.argOneDie?"是":"否"))) ;
            System.out.println("启动多包死：" + (ServerProperties.argMultiDie==null?"否":(ServerProperties.argMultiDie?"是":"否"))) ;

            String svName ;
            try{
                svName = this.conf.getSetAttrTxt(this.doc, "config.server", "name", null, false, null) ;

 pipIrr-platform/pipIrr-mw/pipIrr-mw-simulate-rtu/src/main/java/com/dy/simRtu/ServerProperties.java

@@ -9,4 +9,10 @@
public class ServerProperties {

    public static String rtuAddr ;

    //程序启动参数：
    public static String argRtuAddr ;
    public static Boolean argOneDie = false ;
    public static Boolean argMultiDie = false ;

}

 pipIrr-platform/pipIrr-mw/pipIrr-mw-simulate-rtu/src/main/java/com/dy/simRtu/tcpClient/TcpHandler.java

@@ -67,11 +67,11 @@
     */
    @Override
    public void messageSent(IoSession session, Object message) throws Exception {
        log.info("网络发送了数据，"
                + (session==null?"":(session.getRemoteAddress() != null?("中间件网址是：" + session.getRemoteAddress().toString()):"")) );
        if(message != null){
            byte[] bs = (byte[])message ;
            log.info("网络发送了数据：" + ByteUtil.bytes2Hex(bs, true));
            log.info("\n网络发送了数据，"
                    + (session==null?"":(session.getRemoteAddress() != null?("中间件网址是：" + session.getRemoteAddress().toString()):""))
                    + ("\n数据：" + ByteUtil.bytes2Hex(bs, true)));
        }
    }


 pipIrr-platform/pipIrr-mw/pipIrr-mw-simulate-rtu/src/main/java/com/dy/simRtu/tcpClient/downData/DownData.java

@@ -2,6 +2,8 @@

import com.dy.common.mw.protocol.p206V1.ProtocolConstantV206V1;
import com.dy.common.util.ByteUtil;
import com.dy.common.util.CreateRandom;
import com.dy.simRtu.ServerProperties;
import com.dy.simRtu.tcpClient.upData.*;

/**
@@ -10,6 +12,8 @@
 * @Description ä¸­é—´ä»¶çš„下行数据
 */
public class DownData {

    private static int count9602 = 0;

    public void parseData(byte[] bs){
        if(bs != null && bs.length > 0){
@@ -32,16 +36,34 @@
        String cdPre = ByteUtil.bytes2Hex(bs, false, ProtocolConstantV206V1.UG_codeIndex, 1);
        if(cdPre.equals("16")){
            //升级功能码
            UpHeartBeat.upHeartBeat = false ;//不上行心跳
            UpHeartBeat.upHeartBeat = false ;//禁止上行心跳
            if(bs.length >= ProtocolConstantV206V1.UG_lenHead2Cmd + 1){
                String cdSuf = ByteUtil.bytes2Hex(bs, false, ProtocolConstantV206V1.UG_codeIndex + 1, 1);
                String cd = cdPre + cdSuf;
                if(cd.equals("1601")){
                    //升级配置
                    UpCd9601.upData() ;
                    if(ServerProperties.argOneDie){
                        UpHeartBeat.upHeartBeat = true ;//使能上行心跳
                    }else{
                        UpCd9601.upData() ;
                    }
                }else if(cd.equals("1602")){
                    //升级数据
                    UpCd9602.upData() ;
                    count9602 ++ ;
                    if(ServerProperties.argMultiDie){
                        if(count9602 > 10){
                            int random =  CreateRandom.create_between(10, 100) ;
                            if(random > 50){
                                UpHeartBeat.upHeartBeat = true ;//使能上行心跳
                            }else{
                                UpCd9602.upData() ;
                            }
                        }else{
                            UpCd9602.upData() ;
                        }
                    }else{
                        UpCd9602.upData() ;
                    }
                }else if(cd.equals("1603")){
                    //升级校验
                    UpCd9603.upData() ;

 pipIrr-platform/pipIrr-mw/pipIrr-mw-simulate-rtu/src/main/resources/config.xml

@@ -10,5 +10,5 @@
     -->
    <base rtuAddr="532328000214"></base>
    <!-- -->
    <tcpCl mwServerIp="192.168.40.132" mwServerPort="60000" connectTimeout="3000" />
    <tcpCl mwServerIp="192.168.40.166" mwServerPort="60000" connectTimeout="3000" />
</config>        

 pipIrr-platform/pipIrr-mw/pipIrr-mw-simulate-rtu/˵Ã÷.txt

New file
@@ -0,0 +1 @@
本模块是RTU模拟器，模拟RTU升级过程

 pipIrr-platform/pipIrr-web/pipIrr-web-app/src/main/java/com/dy/pipIrrApp/captcha/CaptchaCtrl.java

@@ -74,7 +74,7 @@
            baCaptcha.setCode(captchaDomain.getCode());
            baCaptcha.setExpiration(calendar.getTimeInMillis());
            Long rec = captchaSV.addCaptcha(baCaptcha);
            System.out.println("token: " + captchaDomain.getToken() + "; code: " + captchaDomain.getCode());
            //System.out.println("token: " + captchaDomain.getToken() + "; code: " + captchaDomain.getCode());

            // æ— ç”¨ä¿¡æ¯è®¾ç©º
            captchaDomain.setText(null);
@@ -118,7 +118,7 @@
        baCaptcha.setCode(captchaDomain.getCode());
        baCaptcha.setExpiration(calendar.getTimeInMillis());
        Long rec = captchaSV.addCaptcha(baCaptcha);
        System.out.println("token: " + captchaDomain.getToken() + "; code: " + captchaDomain.getCode());
        //System.out.println("token: " + captchaDomain.getToken() + "; code: " + captchaDomain.getCode());

        // ä»¥æ–‡ä»¶æµçš„形式，输出验证码图片
        ServletOutputStream out = null;

 pipIrr-platform/pipIrr-web/pipIrr-web-app/src/main/java/com/dy/pipIrrApp/inspect/InspectCtrl.java

@@ -4,19 +4,20 @@
import com.dy.common.util.IDLongGenerator;
import com.dy.common.webUtil.BaseResponse;
import com.dy.common.webUtil.BaseResponseUtils;
import com.dy.common.webUtil.QueryResultVo;
import com.dy.pipIrrApp.inspect.dto.Inspects;
import com.dy.pipIrrApp.inspect.qo.QoInspect;
import com.dy.pipIrrGlobal.pojoOp.OpeInspect;
import com.dy.pipIrrGlobal.pojoOp.OpeTrack;
import com.dy.pipIrrGlobal.voOp.VoInspect;
import com.dy.pipIrrGlobal.voOp.VoIssueReport;
import jakarta.validation.Valid;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;

import java.util.Date;
import java.util.List;
@@ -121,4 +122,21 @@
        return BaseResponseUtils.buildErrorMsg("您提交的巡检轨迹为空");
    }

    /**
     * æŸ¥è¯¢å·¡æ£€è½¨è¿¹
     * @param qo
     * @return
     */
    @GetMapping(path = "/getInspects")
    @SsoAop()
    public BaseResponse<QueryResultVo<List<VoInspect>>> getInspects(QoInspect qo){

        try{
            QueryResultVo<List<VoInspect>> res = inspectSv.getInspects(qo);
            return BaseResponseUtils.buildSuccess(res);
        }catch (Exception e){
            log.error("获取巡检列表异常", e);
            return BaseResponseUtils.buildException(e.getMessage());
        }
    }
}

 pipIrr-platform/pipIrr-web/pipIrr-web-app/src/main/java/com/dy/pipIrrApp/inspect/InspectSv.java

@@ -1,14 +1,20 @@
package com.dy.pipIrrApp.inspect;

import com.dy.common.webUtil.QueryResultVo;
import com.dy.pipIrrApp.inspect.qo.QoInspect;
import com.dy.pipIrrGlobal.daoOp.OpeInspectMapper;
import com.dy.pipIrrGlobal.daoOp.OpeTrackMapper;
import com.dy.pipIrrGlobal.pojoOp.OpeInspect;
import com.dy.pipIrrGlobal.pojoOp.OpeTrack;
import com.dy.pipIrrGlobal.voOp.VoInspect;
import com.dy.pipIrrGlobal.voOp.VoIssueReport;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.common.utils.PojoUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;

/**
 * @author ZhuBaoMin
@@ -28,6 +34,7 @@

    /**
     * æ·»åŠ å·¡æ£€è®°å½•
     *
     * @param po
     * @return
     */
@@ -38,6 +45,7 @@

    /**
     * ä¿®æ”¹å·¡æ£€è®°å½•
     *
     * @param po
     * @return
     */
@@ -47,6 +55,7 @@

    /**
     * æ‰¹é‡æ·»åŠ å·¡æ£€è½¨è¿¹
     *
     * @param list
     * @return
     */
@@ -54,5 +63,41 @@
        return opeTrackMapper.insertTracks(list);
    }

    /**
     * å·¡æ£€æŸ¥è¯¢
     *
     * @param queryVo
     * @return
     */
    public QueryResultVo<List<VoInspect>> getInspects(QoInspect queryVo) {
        //完善查询充值记录的起止时间
        String timeStart = queryVo.getTimeStart();
        String timeStop = queryVo.getTimeStop();
        if (timeStart != null) {
            timeStart = timeStart + " 00:00:00";
            queryVo.setTimeStart(timeStart);
        }
        if (timeStop != null) {
            timeStop = timeStop + " 23:59:59";
            queryVo.setTimeStop(timeStop);
        }

        Map<String, Object> params = (Map<String, Object>) PojoUtils.generalize(queryVo);

        Long itemTotal = opeInspectMapper.getInspectsCount(params);
        QueryResultVo<List<VoInspect>> rsVo = new QueryResultVo<>();

        rsVo.pageSize = queryVo.pageSize;
        rsVo.pageCurr = queryVo.pageCurr;

        rsVo.calculateAndSet(itemTotal, params);

        List<VoInspect> inspects = opeInspectMapper.getInspects(params);
        for (int i = 0; i < inspects.size(); i++) {
            List<OpeTrack> tracks = opeTrackMapper.selectByInspectId(inspects.get(i).getInspectId());
            inspects.get(i).setTracks(tracks);
        }
        rsVo.obj = inspects;
        return rsVo;
    }
}

 pipIrr-platform/pipIrr-web/pipIrr-web-app/src/main/java/com/dy/pipIrrApp/inspect/qo/QoInspect.java

New file
@@ -0,0 +1,41 @@
package com.dy.pipIrrApp.inspect.qo;

import com.dy.common.webUtil.QueryConditionVo;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import lombok.Data;

/**
 * @author :WuZeYu
 * @Date :2024/11/20  15:19
 * @LastEditTime :2024/11/20  15:19
 * @Description
 */
@Data
public class QoInspect extends QueryConditionVo {
    /**
     * å·¡æ£€ID
     */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long inspectId;
    /**
     * å·¡æ£€å‘˜ID
     */
    @JsonSerialize(using = ToStringSerializer.class)
    private Long inspectorId;

    /**
     * å·¡æ£€å‘˜å§“名
     */
    private String inspectorName;

    /**
     * ã€å¼€å§‹å·¡æ£€çš„时间，开始范围
     */
    private String timeStart;

    /**
     * ã€å¼€å§‹å·¡æ£€çš„时间，结束范围
     */
    private String timeStop;
}

 pipIrr-platform/pipIrr-web/pipIrr-web-base/src/main/java/com/dy/pipIrrBase/rtuUpgrade/program/UgRtuProgramCtrl.java

@@ -75,7 +75,7 @@
            }
            return BaseResponseUtils.buildSuccess(po);
        }else{
            return BaseResponseUtils.buildException("未查询到对应的记录") ;
            return BaseResponseUtils.buildErrorMsg("未查询到对应的记录") ;
        }
    }
    /**
@@ -99,7 +99,7 @@
            return BaseResponseUtils.buildSuccess(res);
        } catch (Exception e) {
            log.error("查询RTU升级程序异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
            return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
        }
    }

@@ -124,7 +124,7 @@
            return BaseResponseUtils.buildSuccess(res);
        } catch (Exception e) {
            log.error("查询RTU升级程序异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
            return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
        }
    }

@@ -146,26 +146,26 @@
    @SsoAop()
    public BaseResponse<Boolean> save(@Parameter(description = "form表单数据", required = true) @Valid VoRtuProgram vo,  @Parameter(hidden = true) BindingResult bindingResult){
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
            return BaseResponseUtils.buildErrorMsg(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }
        if(vo.storeRamAddr == null
                || vo.storeRamAddr.trim().equals("")
                || vo.storeRamAddr.length() != 8
                || !HexUtil.isHexNumber(vo.storeRamAddr)){
            return BaseResponseUtils.buildFail("升级程序存放地址(4字节，8位十六进制数)不正确") ;
            return BaseResponseUtils.buildErrorMsg("升级程序存放地址(4字节，8位十六进制数)不正确") ;
        }
        if(vo.startRamAddr == null
                || vo.startRamAddr.trim().equals("")
                || vo.startRamAddr.length() != 8
                || !HexUtil.isHexNumber(vo.startRamAddr)){
            return BaseResponseUtils.buildFail("程序覆盖起始地址(4字节，8位十六进制数)不正确") ;
            return BaseResponseUtils.buildErrorMsg("程序覆盖起始地址(4字节，8位十六进制数)不正确") ;
        }
        if(vo.file == null){
            return BaseResponseUtils.buildFail("RTU程序文件必须上传") ;
            return BaseResponseUtils.buildErrorMsg("RTU程序文件必须上传") ;
        }
        String fileName = vo.file.getOriginalFilename() ;
        if(this.sv.existFileName(fileName)){
            return BaseResponseUtils.buildFail("RTU程序文件名已存在") ;
            return BaseResponseUtils.buildErrorMsg("RTU程序文件名已存在") ;
        }

        HexFileVo fileVo = null ;
@@ -178,7 +178,7 @@
            }
        }catch (Exception e){
            fileVo = null ;
            return BaseResponseUtils.buildFail("解析RTU程序文件异常：" + e.getMessage()) ;
            return BaseResponseUtils.buildErrorMsg("解析RTU程序文件异常：" + e.getMessage()) ;
        }
        if(fileVo != null){
            UgRtuProgram po = new UgRtuProgram();
@@ -197,15 +197,15 @@
                count = this.sv.save(po);
            } catch (Exception e) {
                log.error("保存RTU升级程序异常", e);
                return BaseResponseUtils.buildException(e.getMessage()) ;
                return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
            }
            if(count <= 0){
                return BaseResponseUtils.buildFail("数据库存储失败") ;
                return BaseResponseUtils.buildErrorMsg("数据库存储失败") ;
            }else{
                return BaseResponseUtils.buildSuccess(true) ;
            }
        }else{
            return BaseResponseUtils.buildFail("解析RTU程序文件异常") ;
            return BaseResponseUtils.buildErrorMsg("解析RTU程序文件异常") ;
        }
    }
    /**
@@ -245,17 +245,17 @@
    @SsoAop()
    public BaseResponse<Boolean> delete(Long id){
        if(id == null){
            return BaseResponseUtils.buildFail("id不能为空") ;
            return BaseResponseUtils.buildErrorMsg("id不能为空") ;
        }
        int count;
        try {
            count = this.sv.delete(id);
        } catch (Exception e) {
            log.error("删除RTU升级程序异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
            return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
        }
        if(count <= 0){
            return BaseResponseUtils.buildFail("数据库存储失败") ;
            return BaseResponseUtils.buildErrorMsg("数据库存储失败") ;
        }else{
            return BaseResponseUtils.buildSuccess(true) ;
        }

 pipIrr-platform/pipIrr-web/pipIrr-web-base/src/main/java/com/dy/pipIrrBase/rtuUpgrade/task/UgRtuAddControllerCtrl.java

@@ -65,7 +65,7 @@
            return BaseResponseUtils.buildSuccess(res);
        } catch (Exception e) {
            log.error("查询RTU升级任务异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
            return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
        }
    }

@@ -129,7 +129,7 @@
            return BaseResponseUtils.buildSuccess(res);
        } catch (Exception e) {
            log.error("查询RTU升级任务异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
            return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
        }
    }

@@ -165,14 +165,14 @@
                ugRtuController.setRtuAddr(rtuAddr) ;
                int count = this.addedSv.save(ugRtuController);
                if(count <= 0){
                    return BaseResponseUtils.buildFail("数据库存储失败") ;
                    return BaseResponseUtils.buildErrorMsg("数据库存储失败") ;
                }else{
                    return BaseResponseUtils.buildSuccess(true) ;
                }
            }
        } catch (Exception e) {
            log.error("查询RTU升级任务异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
            return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
        }
    }
}

 pipIrr-platform/pipIrr-web/pipIrr-web-base/src/main/java/com/dy/pipIrrBase/rtuUpgrade/task/UgRtuControllerCtrl.java

@@ -70,7 +70,7 @@
            return BaseResponseUtils.buildSuccess(res);
        } catch (Exception e) {
            log.error("查询RTU升级任务异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
            return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
        }
    }

@@ -92,17 +92,17 @@
    @SsoAop()
    public BaseResponse<Boolean> deleteAll(Long taskId){
        if(taskId == null){
            return BaseResponseUtils.buildFail("任务id不能为空") ;
            return BaseResponseUtils.buildErrorMsg("任务id不能为空") ;
        }
        int count;
        try {
            count = this.sv.deleteAll(taskId);
        } catch (Exception e) {
            log.error("删除升级所有对象控制器异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
            return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
        }
        if(count <= 0){
            return BaseResponseUtils.buildFail("数据库操作失败") ;
            return BaseResponseUtils.buildErrorMsg("数据库操作失败") ;
        }else{
            return BaseResponseUtils.buildSuccess(true) ;
        }
@@ -127,17 +127,17 @@
    @SsoAop()
    public BaseResponse<Boolean> deleteOne(Long id){
        if(id == null){
            return BaseResponseUtils.buildFail("id不能为空") ;
            return BaseResponseUtils.buildErrorMsg("id不能为空") ;
        }
        int count;
        try {
            count = this.sv.deleteOne(id);
        } catch (Exception e) {
            log.error("删除升级对象控制器异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
            return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
        }
        if(count <= 0){
            return BaseResponseUtils.buildFail("数据库操作失败") ;
            return BaseResponseUtils.buildErrorMsg("数据库操作失败") ;
        }else{
            return BaseResponseUtils.buildSuccess(true) ;
        }

 pipIrr-platform/pipIrr-web/pipIrr-web-base/src/main/java/com/dy/pipIrrBase/rtuUpgrade/task/UgRtuResultCtrl.java

@@ -64,7 +64,7 @@
            return BaseResponseUtils.buildSuccess(res);
        } catch (Exception e) {
            log.error("查询RTU升级任务异常", e);
            return BaseResponseUtils.buildException(e.getMessage());
            return BaseResponseUtils.buildErrorMsg(e.getMessage());
        }
    }
}

 pipIrr-platform/pipIrr-web/pipIrr-web-base/src/main/java/com/dy/pipIrrBase/rtuUpgrade/task/UgRtuTaskCtrl.java

@@ -85,7 +85,7 @@
            return BaseResponseUtils.buildSuccess(res);
        } catch (Exception e) {
            log.error("查询RTU升级任务异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
            return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
        }
    }

@@ -110,7 +110,7 @@
            return BaseResponseUtils.buildSuccess(res);
        } catch (Exception e) {
            log.error("查询RTU升级任务异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
            return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
        }
    }

@@ -132,7 +132,7 @@
    @SsoAop()
    public BaseResponse<Boolean> save(@Parameter(description = "form表单数据", required = true) @Valid VoRtuTask vo, @Parameter(hidden = true) BindingResult bindingResult){
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
            return BaseResponseUtils.buildErrorMsg(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }
        UgRtuTask po = new UgRtuTask();
        vo.toPo(po);
@@ -142,10 +142,10 @@
            count = this.sv.save(po);
        } catch (Exception e) {
            log.error("保存RTU升级任务异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
            return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
        }
        if(count <= 0){
            return BaseResponseUtils.buildFail("数据库存储失败") ;
            return BaseResponseUtils.buildErrorMsg("数据库存储失败") ;
        }else{
            return BaseResponseUtils.buildSuccess(true) ;
        }
@@ -168,20 +168,20 @@
     @SsoAop()
     public BaseResponse<Boolean> update(@Parameter(description = "form表单数据", required = true) @Valid UgRtuTask po, @Parameter(hidden = true) BindingResult bindingResult){
         if(bindingResult != null && bindingResult.hasErrors()){
             return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
             return BaseResponseUtils.buildErrorMsg(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
         }
         if(po.id == null){
             return BaseResponseUtils.buildFail("无数据实体ID") ;
             return BaseResponseUtils.buildErrorMsg("无数据实体ID") ;
         }
         int count;
         try {
             count = this.sv.update(po);
         } catch (Exception e) {
             log.error("保存实体数据异常", e);
             return BaseResponseUtils.buildException(e.getMessage()) ;
             return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
         }
         if(count <= 0){
             return BaseResponseUtils.buildFail("数据库存储失败") ;
             return BaseResponseUtils.buildErrorMsg("数据库存储失败") ;
         }else{
             return BaseResponseUtils.buildSuccess(true) ;
         }
@@ -206,25 +206,25 @@
    @SsoAop()
    public BaseResponse<Boolean> execute(Long id){
        if(id == null){
            return BaseResponseUtils.buildFail("id不能为空") ;
            return BaseResponseUtils.buildErrorMsg("id不能为空") ;
        }
        int count;
        try {
            count = this.sv.isOver(id) ;
            if(count > 0){
                return BaseResponseUtils.buildError("任务已经结束，不能再执行") ;
                return BaseResponseUtils.buildErrorMsg("任务已经结束，不能再执行") ;
            }
            count = this.sv.isExecute(id) ;
            if(count > 0){
                return BaseResponseUtils.buildError("任务已经执行，不能再执行") ;
                return BaseResponseUtils.buildErrorMsg("任务已经执行，不能再执行") ;
            }
            count = this.sv.execute(id);
        } catch (Exception e) {
            log.error("执行RTU升级任务异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
            return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
        }
        if(count <= 0){
            return BaseResponseUtils.buildFail("数据库操作失败") ;
            return BaseResponseUtils.buildErrorMsg("数据库操作失败") ;
        }else{
            return BaseResponseUtils.buildSuccess(true) ;
        }
@@ -248,20 +248,20 @@
    @SsoAop()
    public BaseResponse<Boolean> over(Long id){
        if(id == null){
            return BaseResponseUtils.buildFail("id不能为空") ;
            return BaseResponseUtils.buildErrorMsg("id不能为空") ;
        }
        int count;
        try {count = this.sv.isOver(id) ;
            if(count > 0){
                return BaseResponseUtils.buildError("任务已经结束，不用再结束") ;
                return BaseResponseUtils.buildErrorMsg("任务已经结束，不用再结束") ;
            }
            count = this.sv.over(id);
        } catch (Exception e) {
            log.error("结束RTU升级任务异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
            return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
        }
        if(count <= 0){
            return BaseResponseUtils.buildFail("数据库操作失败") ;
            return BaseResponseUtils.buildErrorMsg("数据库操作失败") ;
        }else{
            return BaseResponseUtils.buildSuccess(true) ;
        }
@@ -285,17 +285,17 @@
    @SsoAop()
    public BaseResponse<Boolean> delete(Long id){
        if(id == null){
            return BaseResponseUtils.buildFail("id不能为空") ;
            return BaseResponseUtils.buildErrorMsg("id不能为空") ;
        }
        int count;
        try {
            count = this.sv.delete(id);
        } catch (Exception e) {
            log.error("删除RTU升级任务异常", e);
            return BaseResponseUtils.buildException(e.getMessage()) ;
            return BaseResponseUtils.buildErrorMsg(e.getMessage()) ;
        }
        if(count <= 0){
            return BaseResponseUtils.buildFail("数据库操作失败") ;
            return BaseResponseUtils.buildErrorMsg("数据库操作失败") ;
        }else{
            return BaseResponseUtils.buildSuccess(true) ;
        }

 pipIrr-platform/pipIrr-web/pipIrr-web-remote/src/main/java/com/dy/pipIrrRemote/common/CommandSv.java

@@ -132,7 +132,7 @@
                    jsonArray.add(jsonObject);
                });
            }
            System.out.println(jsonArray);
            //System.out.println(jsonArray);
        }

        /**

 pipIrr-platform/pipIrr-web/pipIrr-web-remote/src/main/java/com/dy/pipIrrRemote/rtuUpgrage/RtuUpgradeCtrl.java

@@ -1,7 +1,8 @@
package com.dy.pipIrrRemote.rtuUpgrage;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.support.ExcelTypeEnum;
import com.dy.common.aop.SsoAop;
import com.dy.common.multiDataSource.DataSourceContext;
import com.dy.common.softUpgrade.state.UpgradeRtu;
import com.dy.common.softUpgrade.state.UpgradeTaskVo;
import com.dy.common.springUtil.SpringContextUtil;
@@ -12,6 +13,8 @@
import com.dy.pipIrrGlobal.pojoUg.UgRtuProgram;
import com.dy.pipIrrGlobal.pojoUg.UgRtuTask;
import com.dy.pipIrrGlobal.rtuMw.ToRtuMwCom;
import com.dy.pipIrrGlobal.voPr.VoDivide;
import com.dy.pipIrrGlobal.voUg.VoUgRtuResult;
import com.dy.pipIrrGlobal.voUg.VoWatch;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.media.Content;
@@ -19,15 +22,19 @@
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletResponse;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
@@ -44,6 +51,9 @@
public class RtuUpgradeCtrl extends ToRtuMwCom {
    @Autowired
    private RtuUpgradeSv sv ;

    @Autowired
    RtuUpgradeResSv resSv ;

    @Autowired
    private Environment env;
@@ -69,28 +79,28 @@
    @SsoAop()
    public BaseResponse<Boolean> issuedTask(String id){
        if(id == null || id.trim().equals("")){
            return BaseResponseUtils.buildError("任务id不能为空") ;
            return BaseResponseUtils.buildErrorMsg("任务id不能为空") ;
        }
        UgRtuTask tpo = this.sv.selectTaskById(id) ;
        if(tpo == null){
            return BaseResponseUtils.buildError("任务不存在") ;
            return BaseResponseUtils.buildErrorMsg("任务不存在") ;
        }
        if(tpo.isExecute == 1){
            return BaseResponseUtils.buildError("任务已下发，不能重复下发任务") ;
            return BaseResponseUtils.buildErrorMsg("任务已下发，不能重复下发任务") ;
        }
        UgRtuProgram ppo = this.sv.selectProgramById(tpo.programId) ;
        if(ppo == null){
            return BaseResponseUtils.buildError("任务对应的程序不存在") ;
            return BaseResponseUtils.buildErrorMsg("任务对应的程序不存在") ;
        }

        List<String> taskRtuAddrs = this.sv.selectAllRtuAddrByTask(id) ;
        if(taskRtuAddrs == null || taskRtuAddrs.size() == 0){
            return BaseResponseUtils.buildError("任务所涉及的控制器还未设置") ;
            return BaseResponseUtils.buildErrorMsg("任务所涉及的控制器还未设置") ;
        }

        String ugCallbackUrl_rm = env.getProperty("mw.ugCallbackUrl_rm" );
        if(ugCallbackUrl_rm == null || ugCallbackUrl_rm.trim().equals("")){
            return BaseResponseUtils.buildError("未配置升级任务回调网址") ;
            return BaseResponseUtils.buildErrorMsg("未配置升级任务回调网址") ;
        }

        UpgradeTaskVo vo = new UpgradeTaskVo() ;
@@ -110,11 +120,11 @@
                    msg = res.getMsg() ;
                }
                log.error("通信中间件执行下发升级任务失败" + msg) ;
                return BaseResponseUtils.buildFail("通信中间件执行失败" + msg) ;
                return BaseResponseUtils.buildErrorMsg("通信中间件执行失败" + msg) ;
            }
        }else{
            log.error("通信中间件返回结果为null") ;
            return BaseResponseUtils.buildFail("通信中间件返回结果为null") ;
            return BaseResponseUtils.buildErrorMsg("通信中间件返回结果为null") ;
        }
    }

@@ -128,9 +138,10 @@
        vo.softBytesCalculate = ppo.programCalculateBytes ;
        vo.softByteSrc16 = ppo.programCrc16 ;
    }


    /**
     *  ç›‘视：
     * é‡ç½®ï¼Œæ¼”示的重置
     * é‡ç½®è¿œç¨‹å‡çº§æ¼”示程序
     * @return æ“ä½œç»“æžœ
     */
    @GetMapping(path = "/demoReset")
@@ -166,104 +177,58 @@
        if(qvo == null){
            qvo = new QueryVo();
            qvo.pageCurr = 1 ;
            qvo.pageSize = 50 ;
            qvo.pageSize = 49 ;
        }
        if(RtuUpgradeStateReceiverCtrl.cache == null){
            //return BaseResponseUtils.buildError("当前没有升级任务") ;
            return BaseResponseUtils.buildErrorMsg("当前没有升级任务") ;
            //正式运行时，下面两行去掉，上面一行打开
            RtuUpgradeStateReceiverCtrl ctrl = SpringContextUtil.getBean(RtuUpgradeStateReceiverCtrl.class);
            ctrl.demo();
            //RtuUpgradeStateReceiverCtrl ctrl = SpringContextUtil.getBean(RtuUpgradeStateReceiverCtrl.class);
            //ctrl.demo();
        }

        QueryResultVo<VoWatch> rsVo = new QueryResultVo();
        VoWatch vo = new VoWatch() ;
        List<UpgradeRtu> listFiltered = null ;
        if(RtuUpgradeStateReceiverCtrl.cache != null && RtuUpgradeStateReceiverCtrl.cache.ugTaskId != null){
            vo.upgrade = this.sv.selectTaskDetail(RtuUpgradeStateReceiverCtrl.cache.ugTaskId);
            vo.overall = RtuUpgradeStateReceiverCtrl.cache.ugOverallState ;
            vo.rtus = new ArrayList<>() ;
            if(RtuUpgradeStateReceiverCtrl.cache.ugRtuStateList != null && RtuUpgradeStateReceiverCtrl.cache.ugRtuStateList.size() > 0) {
                listFiltered = filterByQuery(qvo) ;
                if (listFiltered.size() > 0) {
                    if(qvo.pageCurr < 1){
                        qvo.pageCurr = 1 ;
                    }
                    int start = (qvo.pageCurr - 1) * qvo.pageSize ;
                    if(start >= listFiltered.size()){
                        if(listFiltered.size()%qvo.pageSize > 0){
                            start = listFiltered.size() - listFiltered.size()%qvo.pageSize ;
                        }else{
                            start = listFiltered.size() - qvo.pageSize ;
                        }
                    }
                    for(int i = start; i < (start + qvo.pageSize) && i < listFiltered.size(); i++){
                        UpgradeRtu ugRtu = listFiltered.get(i) ;
                        VoWatch.VoWatchRtu rtu = new VoWatch.VoWatchRtu() ;
                        rtu.fromCache(ugRtu) ;
                        vo.rtus.add(rtu) ;
                    }
                }
            }
        }

        rsVo.obj = vo ;
        rsVo.pageSize = qvo.pageSize ;
        rsVo.pageCurr = qvo.pageCurr ;
        rsVo.calculateAndSet(0L + (listFiltered==null?0:listFiltered.size()), null);
        QueryResultVo<VoWatch> rsVo = this.resSv.curUpgradeState(qvo) ;
        return BaseResponseUtils.buildSuccess(rsVo) ;
    }

    private List<UpgradeRtu> filterByQuery(QueryVo qvo){
        if (qvo.status != null || qvo.result != null) {
            final Integer qvoStatus = qvo.status ;
            final Integer qvoResult = qvo.result ;
            final String qvoRtuAddr = qvo.rtuAddr ;
            return RtuUpgradeStateReceiverCtrl.cache.ugRtuStateList.stream().filter(rtu -> {
                boolean ok = false;
                if (qvoStatus != null) {
                    if (qvoStatus.intValue() == 1) {
                        if (rtu.state == UpgradeRtu.STATE_RUNNING) {
                            ok = true;
                        }else{
                            ok = false ;
                        }
                    } else if (qvoStatus.intValue() == 0) {
                        if (rtu.isOver) {
                            ok = true;
                        }else{
                            ok = false ;
                        }
                    }
                }
                if (qvoResult != null) {
                    if (qvoResult.intValue() == 1) {
                        if (rtu.state == UpgradeRtu.STATE_SUCCESS) {
                            ok = true;
                        }else{
                            ok = false ;
                        }
                    } else if (qvoResult.intValue() == 0) {
                        if (rtu.state == UpgradeRtu.STATE_OFFLINE
                                || rtu.state == UpgradeRtu.STATE_FAILONE
                                || rtu.state == UpgradeRtu.STATE_FAIL
                                || rtu.state == UpgradeRtu.STATE_FAILOFFLINE) {
                            ok = true;
                        }else{
                            ok = false ;
                        }
                    }
                }
                if(qvoRtuAddr != null && !qvoRtuAddr.trim().equals("")){
                    if(rtu.rtuAddr.equals(qvoRtuAddr)){
                        ok = true;
                    }else{
                        ok = false ;
                    }
                }
                return ok;
            }).toList() ;
        }else{
            return RtuUpgradeStateReceiverCtrl.cache.ugRtuStateList ;
        }
    /**
     * å¯¼å‡ºå‡çº§å¤±è´¥RTU列表
     * @param response
     */
    @RequestMapping(value = "/exportUgFail", method = RequestMethod.GET)
    public void exportUgFail(HttpServletResponse response) throws Exception {
        setExcelRespProp(response, "升级失败RTU列表");
        List<VoUgRtuResult> rsList = resSv.exportUgFail();
        EasyExcel.write(response.getOutputStream())
                .head(VoUgRtuResult.class)
                .excelType(ExcelTypeEnum.XLSX)
                .sheet("升级失败RTU列表")
                .doWrite(rsList);
    }


    /**
     * å¯¼å‡ºé•¿çº§æˆåŠŸRTU列表
     * @param response
     */
    @RequestMapping(value = "/exportUgSuccess", method = RequestMethod.GET)
    public void exportUgSuccess(HttpServletResponse response) throws Exception {
        setExcelRespProp(response, "升级成功RTU列表");
        List<VoUgRtuResult> rsList = resSv.exportUgSuccess();
        EasyExcel.write(response.getOutputStream())
                .head(VoUgRtuResult.class)
                .excelType(ExcelTypeEnum.XLSX)
                .sheet("升级成功RTU列表")
                .doWrite(rsList);
    }


    /**
     * è®¾ç½®excel下载响应头属性
     */
    private void setExcelRespProp(HttpServletResponse response, String rawFileName) throws UnsupportedEncodingException {
        response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
        response.setCharacterEncoding("utf-8");
        String fileName = URLEncoder.encode(rawFileName, "UTF-8").replaceAll("\\+", "%20");
        response.setHeader("Content-disposition", "attachment;filename*=utf-8''" + fileName + ".xlsx");
    }

}

 pipIrr-platform/pipIrr-web/pipIrr-web-remote/src/main/java/com/dy/pipIrrRemote/rtuUpgrage/RtuUpgradeResSv.java

New file
@@ -0,0 +1,160 @@
package com.dy.pipIrrRemote.rtuUpgrage;

import com.dy.common.softUpgrade.state.UpgradeRtu;
import com.dy.common.webUtil.QueryResultVo;
import com.dy.pipIrrGlobal.voUg.VoUgRtuResult;
import com.dy.pipIrrGlobal.voUg.VoWatch;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author liurunyu
 * @Date 2024/11/22 14:40
 * @Description
 */
@Slf4j
@Service
public class RtuUpgradeResSv {
    @Autowired
    private RtuUpgradeSv sv ;

    public QueryResultVo<VoWatch> curUpgradeState(QueryVo qvo){
        QueryResultVo<VoWatch> rsVo = new QueryResultVo<>();
        VoWatch vo = new VoWatch() ;
        List<UpgradeRtu> listFiltered = null ;
        if(RtuUpgradeStateReceiverCtrl.cache != null && RtuUpgradeStateReceiverCtrl.cache.ugTaskId != null){
            vo.upgrade = this.sv.selectTaskDetail(RtuUpgradeStateReceiverCtrl.cache.ugTaskId);
            vo.overall = RtuUpgradeStateReceiverCtrl.cache.ugOverallState ;
            vo.rtus = new ArrayList<>() ;
            if(RtuUpgradeStateReceiverCtrl.cache.ugRtuStateList != null && RtuUpgradeStateReceiverCtrl.cache.ugRtuStateList.size() > 0) {
                listFiltered = filterByQuery(qvo) ;
                if (listFiltered.size() > 0) {
                    if(qvo.pageCurr < 1){
                        qvo.pageCurr = 1 ;
                    }
                    int start = (qvo.pageCurr - 1) * qvo.pageSize ;
                    if(start >= listFiltered.size()){
                        if(listFiltered.size()%qvo.pageSize > 0){
                            start = listFiltered.size() - listFiltered.size()%qvo.pageSize ;
                        }else{
                            start = listFiltered.size() - qvo.pageSize ;
                        }
                    }
                    for(int i = start; i < (start + qvo.pageSize) && i < listFiltered.size(); i++){
                        UpgradeRtu ugRtu = listFiltered.get(i) ;
                        VoWatch.VoWatchRtu rtu = new VoWatch.VoWatchRtu() ;
                        rtu.fromCache(ugRtu) ;
                        vo.rtus.add(rtu) ;
                    }
                }
            }
        }

        rsVo.obj = vo ;
        rsVo.pageSize = qvo.pageSize ;
        rsVo.pageCurr = qvo.pageCurr ;
        rsVo.calculateAndSet((long)(listFiltered==null?0:listFiltered.size()), null);
        return rsVo ;
    }

    /**
     * è¿‡æ»¤ç»“æžœ
     * @param qvo æŸ¥è¯¢å‚æ•°
     * @return é›†åˆ
     */
    private List<UpgradeRtu> filterByQuery(QueryVo qvo){
        if (qvo.status != null || qvo.result != null) {
            Integer qvoStatus = qvo.status ;
            Integer qvoResult = qvo.result ;
            String qvoRtuAddr = qvo.rtuAddr ;
            return RtuUpgradeStateReceiverCtrl.cache.ugRtuStateList.stream().filter(rtu -> {
                boolean ok = false;
                if (qvoStatus != null) {
                    if (qvoStatus == 1) {
                        ok = rtu.state == UpgradeRtu.STATE_RUNNING;
                    } else if (qvoStatus == 0) {
                        ok = rtu.isOver;
                    }
                }
                if (qvoResult != null) {
                    if (qvoResult == 1) {
                        ok = rtu.state == UpgradeRtu.STATE_SUCCESS;
                    } else if (qvoResult == 0) {
                        ok = rtu.state == UpgradeRtu.STATE_OFFLINE
                                || rtu.state == UpgradeRtu.STATE_FAILONE
                                || rtu.state == UpgradeRtu.STATE_FAIL
                                || rtu.state == UpgradeRtu.STATE_FAILOFFLINE;
                    }
                }
                if(qvoRtuAddr != null && !qvoRtuAddr.trim().equals("")){
                    ok = rtu.rtuAddr.equals(qvoRtuAddr);
                }
                return ok;
            }).toList() ;
        }else{
            return RtuUpgradeStateReceiverCtrl.cache.ugRtuStateList ;
        }
    }

    /**
     * è¿‡æ»¤å‡ºå½“前长级任务中升级失败的RTU
     * @return é›†åˆ
     */
    public List<VoUgRtuResult> exportUgFail(){
        List<VoUgRtuResult> list = new ArrayList<>() ;
        if(RtuUpgradeStateReceiverCtrl.cache != null && RtuUpgradeStateReceiverCtrl.cache.ugTaskId != null){
            if(RtuUpgradeStateReceiverCtrl.cache.ugRtuStateList != null && RtuUpgradeStateReceiverCtrl.cache.ugRtuStateList.size() > 0) {
                RtuUpgradeStateReceiverCtrl.cache.ugRtuStateList.forEach(rtu -> {
                    if(rtu.isOver){
                        if(rtu.state == UpgradeRtu.STATE_OFFLINE
                                || rtu.state == UpgradeRtu.STATE_UNSTART
                                || rtu.state == UpgradeRtu.STATE_FAILOFFLINE){
                            VoUgRtuResult vo = new VoUgRtuResult() ;
                            vo.rtuAddr = rtu.rtuAddr ;
                            vo.result = "离线" ;
                            list.add(vo);
                        }else if(rtu.state == UpgradeRtu.STATE_FAILONE){
                            VoUgRtuResult vo = new VoUgRtuResult() ;
                            vo.rtuAddr = rtu.rtuAddr ;
                            vo.result = "一包死" ;
                            list.add(vo);
                        }else if(rtu.state == UpgradeRtu.STATE_FAIL){
                            VoUgRtuResult vo = new VoUgRtuResult() ;
                            vo.rtuAddr = rtu.rtuAddr ;
                            vo.result = "多包死" ;
                            list.add(vo);
                        }
                    }
                });
            }
        }
        return list ;
    }

    /**
     * è¿‡æ»¤å‡ºå½“前长级任务中升级成功的RTU
     * @return é›†åˆ
     */
    public List<VoUgRtuResult> exportUgSuccess(){
        List<VoUgRtuResult> list = new ArrayList<>() ;
        if(RtuUpgradeStateReceiverCtrl.cache != null && RtuUpgradeStateReceiverCtrl.cache.ugTaskId != null){
            if(RtuUpgradeStateReceiverCtrl.cache.ugRtuStateList != null && RtuUpgradeStateReceiverCtrl.cache.ugRtuStateList.size() > 0) {
                RtuUpgradeStateReceiverCtrl.cache.ugRtuStateList.forEach(rtu -> {
                    if(rtu.isOver){
                        if(rtu.state == UpgradeRtu.STATE_SUCCESS){
                            VoUgRtuResult vo = new VoUgRtuResult() ;
                            vo.rtuAddr = rtu.rtuAddr ;
                            vo.result = "升级成功" ;
                            list.add(vo);
                        }
                    }
                });
            }
        }
        return list ;
    }
}

 pipIrr-platform/pipIrr-web/pipIrr-web-remote/src/main/java/com/dy/pipIrrRemote/rtuUpgrage/RtuUpgradeStateReceiverCtrl.java

@@ -65,20 +65,20 @@
            }
        }
        if(cache == null){
            cache = info;
            //此时不做任务操作，只保障cache不为空， ç­‰å¾…下次发来数据
            if(info.ugRtuStateList != null && info.ugRtuStateList.size() > 0){
                List<UpgradeRtu> overList = info.ugRtuStateList.stream().filter(itemVo -> itemVo.isOver).collect(Collectors.toList()) ;
                if(overList != null && overList.size() > 0){
                    cache = info;
                    this.save2Db(info.ugTaskId, overList);
                }
            }
        }else{
            cache = info;
            //当cache中有值时，进行比对存储，对比目的是防止重复操作数据库
            if(info.ugRtuStateList != null && info.ugRtuStateList.size() > 0){
                //此时保证两个集合都不为null
                this.save2Db(info.ugTaskId, info.ugRtuStateList, cache.ugRtuStateList);
                cache = info;
            }
        }
        return null;
@@ -154,7 +154,7 @@
                                @Override
                                public Object execute() throws Exception {
                                    while(!this.stop){
                                        if(!runDemo()){
                                        if(!runInDemo()){
                                            this.stop = true ;
                                        }else{
                                            try {
@@ -188,7 +188,7 @@
            }
        }
    }
    private boolean runDemo(){
    private boolean runInDemo(){
        for(UpgradeRtu rtu : cache.ugRtuStateList){
            this.rtuUpgrade(rtu) ;
        }
@@ -244,7 +244,7 @@
        }

        int n = Integer.parseInt(new CreateRandom().create(3)) ;
        if(n == 540 || n == 541 || n == 542 || n == 543 || n == 544 || n == 545){
        if(n == 540 || n == 541 || n == 542 || n == 543 || n == 544 || n == 545 || n == 546 || n == 547 || n == 548 || n == 549 ){
            if(rtu.currentPackage == 1){
                //1包死
                rtu.state = UpgradeRtu.STATE_FAILONE ;
@@ -296,6 +296,7 @@
            for(UpgradeRtu rtu : cache.ugRtuStateList){
                if(rtu.state == UpgradeRtu.STATE_OFFLINE){
                    cache.ugOverallState.offLineTotal ++ ;
                    cache.ugOverallState.failTotal++;
                }else if(rtu.state == UpgradeRtu.STATE_UNSTART){
                    cache.ugOverallState.unStartTotal ++ ;
                }else if(rtu.state == UpgradeRtu.STATE_RUNNING){
@@ -307,6 +308,7 @@
                    cache.ugOverallState.failOneTotal++;
                    cache.ugOverallState.failTotal++;
                }else if(rtu.state == UpgradeRtu.STATE_FAIL) {
                    cache.ugOverallState.failMultiTotal++;
                    cache.ugOverallState.failTotal++;
                }
                if(rtu.isOver){
@@ -317,6 +319,15 @@
        if(!hasRunning){
            cache.ugOverallState.allOver = true ;
        }
        if(cache.ugOverallState.allOver){
            cache.ugOverallState.overTotal = 0;
            if(cache.ugRtuStateList != null && cache.ugRtuStateList.size() > 0){
                for(UpgradeRtu rtu : cache.ugRtuStateList){
                    rtu.isOver = true ;
                    cache.ugOverallState.overTotal++;
                }
            }
        }
        return hasRunning ;
    }
}

 pipIrr-platform/pipIrr-web/pipIrr-web-remote/src/main/java/com/dy/pipIrrRemote/rtuUpgrage/RtuUpgradeSv.java

@@ -58,28 +58,6 @@
    }

    /**
     * æŸ¥è¯¢ä¸€ä¸ªå‡çº§ä»»åŠ¡æœ‰å…³ä¿¡æ¯
     * @return å‡çº§ä»»åŠ¡æœ‰å…³ä¿¡æ¯
     */
    public VoUpgradeDetail selectTaskDetail(String taskId){
        List<VoUpgradeDetail> list = this.tdao.selectTaskDetail(Long.valueOf(taskId)) ;
        if(list != null && list.size() > 0){
            return list.get(0) ;
        }
        return null ;
    }


    /**
     * ä¿å­˜å‡çº§ä»»åŠ¡ä¸ºæ‰§è¡ŒçŠ¶æ€
     * @param taskId ä»»åŠ¡ID
     */
    public void setUpgradeTaskExecuted(String taskId){
        this.tdao.executeById(Long.valueOf(taskId)) ;
    }


    /**
     * ä¿å­˜RTU升级结束状态
     * @param taskId
     * @param rtu
@@ -91,17 +69,38 @@
        cdao.updateRtuUpgradeState(params) ;
    }

    /////////////////////////////////////////////////////
    //
    // ä»¥ä¸‹æ¨¡æ‹Ÿæ•°æ®
    //
    /////////////////////////////////////////////////////
    /**
     * é€šä¿¡ä¸»é”®æŸ¥è¯¢ä¸€ä¸ªå‡çº§ä»»åŠ¡
     * æŸ¥è¯¢ä¸€ä¸ªå‡çº§ä»»åŠ¡æœ‰å…³ä¿¡æ¯
     * @return å‡çº§ä»»åŠ¡æœ‰å…³ä¿¡æ¯
     */
    public VoUpgradeDetail selectTaskDetail(String taskId){
        List<VoUpgradeDetail> list = this.tdao.selectTaskDetail(Long.valueOf(taskId)) ;
        if(list != null && list.size() > 0){
            return list.get(0) ;
        }
        return null ;
    }

    /**
     * ä¿å­˜å‡çº§ä»»åŠ¡ä¸ºæ‰§è¡ŒçŠ¶æ€
     * @param taskId ä»»åŠ¡ID
     */
    public void setUpgradeTaskExecuted(String taskId){
        this.tdao.executeById(Long.valueOf(taskId)) ;
    }


    /////////////////////////////////////////////////////
    //
    // ä»¥ä¸‹æ¼”示升级功能用到
    //
    /////////////////////////////////////////////////////

    /**
     * æŸ¥è¯¢æœ€æ–°ä¸€ä¸ªå‡çº§ä»»åŠ¡
     * @return
     */
    public UgRtuTask selectLastTask(){
        return tdao.selectLastTask();
    }

}

 pipIrr-platform/pom.xml

@@ -186,6 +186,13 @@
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-extension</artifactId>
                <version>3.5.3.2</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!-- é˜¿é‡Œfastjson -->
            <dependency>
@@ -271,11 +278,11 @@
                <scope>import</scope>
            </dependency>

            <!-- quartz -->
            <!-- rocketmq-client -->
            <dependency>
                <groupId>org.apache.rocketmq</groupId>
                <artifactId>rocketmq-client</artifactId>
                <version>4.9.7</version>
                <version>5.3.1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>