1、表阀一体机新协议开阀报关阀报数据处理逻辑修改； 2、农户月用水统计查询中，缺少农户姓名，进行SQL修改。

liurunyu

2025-03-01 595b66ae8800511fab34e503f94d173613088c08

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

@@ -1,27 +1,43 @@
package com.dy.rtuMw.server.upgrade;

import com.dy.common.softUpgrade.state.UpgradeInfo;
import com.dy.common.softUpgrade.state.UpgradeRtu;
import com.dy.common.softUpgrade.state.UpgradeState;
import com.dy.common.softUpgrade.state.UpgradeTaskVo;
import com.dy.common.springUtil.SpringContextUtil;
import com.dy.common.util.Callback;

import com.dy.common.util.DateTime;
import com.dy.common.util.TimerTaskJob;
import com.dy.rtuMw.web.webRequest.WebRequestDeal;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.List;

/**
 * @Author: liurunyu
 * @Date: 2024/11/4 16:03
 *  升级管理类
 * @Author liurunyu
 * @Date 2024/11/4 16:03
 * @Description
 */
public class UpgradeManager {
public class UpgradeManager extends TimerTaskJob implements Callback {

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

    private static final UpgradeManager INSTANCE = new UpgradeManager();

    private Boolean openNoUpgrade ;//阀开（泵开）不执行升级
    private Integer lastOpenMaxGoOn ;//阀开（泵开）状态设置以来持续最长时间（秒钟），超过这个时间认为状态无效（这个时长取决于工作报间隔）
    private Integer failTryTimes ;//升级失败后，重新偿试升级次数，0表示不重新偿试升级
    private Integer ugMaxRtuSameTime ;//同时升级RTU最大个数
    private Integer notifyTimesAfterOver; //升级结束后，再向web服务系统通知状态的次数
    private int nowNotifyTimesAfterOver; //升级结束后，再向web服务系统通知状态的次数

    private UpgradeTask task ;//升级任务
    private boolean monitorFirst ;//是否是第一次监视

    private boolean taskIsOver = false ;//升级任务是否结束
    private int triggerTimes = 0 ;//连接触发次数

    private UpgradeManager(){}
    private UpgradeManager(){
        monitorFirst = true ;
    }

    public static UpgradeManager getInstance() {
        return UpgradeManager.INSTANCE;
@@ -31,72 +47,82 @@
     *  初始化配置信息
     */
    public void initOption(UpgradeUnitConfigVo configVo) {
        this.openNoUpgrade = configVo.openNoUpgrade;
        this.lastOpenMaxGoOn = configVo.lastOpenMaxGoOn;
        this.failTryTimes = configVo.failTryTimes;
        this.ugMaxRtuSameTime = configVo.ugMaxRtuSameTime;
        this.ugMaxRtuSameTime = configVo.ugMaxRtuAtOnce;
        this.notifyTimesAfterOver = configVo.notifyTimesAfterOver;
    }

    /**
     * 设置升级任务
     * @param softFileName 升级程序文件名
     * @param softStoreAddr 升级程序存放地址
     * @param softStartAddr 程序覆盖起始地址
     * @param softFileData 升级程序字节数组
     * @param softBytesCalculate 升级程序字节数(按公式计算)
     * @param rtuAddrList 升级RTU
     * @throws Exception
     * @param vo UpgradeTaskVo 升级任务对象
     * @throws Exception 异常
     */
    public void setUpgradeTask(String softFileName,
                               String softStoreAddr,
                               String softStartAddr,
                               byte[] softFileData,
                               Integer softBytesCalculate,
                               List<String> rtuAddrList) throws Exception {
        if(this.task != null && !this.task.isOver()){
            throw new Exception("当前存在升级任务，请等待当前任务执行完或强制停止当前任务");
        }else{
            this.task.forceOver();
            this.task = new UpgradeTask();
            this.task.initOption(this.failTryTimes, this.ugMaxRtuSameTime);
            this.task.setTask(softFileName,
                    softStoreAddr,
                    softStartAddr,
                    softFileData,
                    softBytesCalculate,
                    rtuAddrList);
    public void setUpgradeTask(UpgradeTaskVo vo) throws Exception {
        if(this.task != null && !this.task.taskIsOver){
            throw new Exception("当前存在升级任务，请等待当前任务执行完或强制结束当前任务");
        }else {
            Exception ex = null ;
            try{
                if(this.task != null){
                    this.task.forceOver();
                }
                this.task = new UpgradeTask();
                this.task.initOption(this.openNoUpgrade, this.lastOpenMaxGoOn, this.failTryTimes, this.ugMaxRtuSameTime);
                this.task.setTask(vo);
                this.nowNotifyTimesAfterOver = 0 ;
                this.monitorFirst = true ;
                log.info("======================================================") ;
                log.info("=                                                    =") ;
                log.info("=设置了升级任务，涉及RTU" + vo.rtuAddrList.size() + "台                            =") ;
                log.info("=                                                    =") ;
                log.info("======================================================") ;
            }catch (Exception e){
                ex = e ;
            }finally {
                if(ex != null){
                    this.task = null ;
                    throw ex ;
                }else{
                    this.start(1000L, (long) UpgradeUnit.confVo.notifyStateInterval, this);
                }
            }
        }
    }

    /**
     * 停止当前升级任务
     * @throws Exception
     * 强制结束当前升级任务，
     * 此功能可能不会开放出去，
     * 因为强制结束升级任务，对一个未升级完成的RTU就会卡死，
     * 所以当强制结束升级任务，代码逻辑并没有强制结果RTU升级过程，如果升级过程也强制停止，那么RTU真会卡死
     */
    public void stopUpgradeTask() throws Exception {
    public String forceOverUpgradeTask() {
        if(this.task != null){
            this.task.forceOver();
            this.task.countRunningRtuCount();
            if(this.task.curUgRunningRtuTotal > 0){
                return "当前存在升级中的设备，不能结束升级任务" ;
            }else{
                this.stop();
                this.task.forceOver();
                return null ;
            }
        }else{
            return "当前没有升级任务" ;
        }
        this.task = null ;
    }

    /**
     * RTU有上行数据了，触发下发升级数据
     * @param rtuAddr
     * @param code
     * @param protocolName
     * @param protocolVersion
     * @param callback
     * @param rtuAddr 控制器RTU地址
     * @param code 上行数据功能码
     * @param protocolName 上行数据对应的协议名称
     * @param protocolVersion 上行数据对应的协议版本号
     * @param callbackCom 回调函数，处理下行命令
     */
    public void trigger(String rtuAddr, String code, String protocolName, Short protocolVersion, Callback callback){
        if(task != null && !taskIsOver){
            triggerTimes ++ ;
            if(triggerTimes == 100){
                triggerTimes = 0 ;
                if(this.task.isOver()){
                    taskIsOver = true ;
                }
            }
            if(!taskIsOver){
                this.task.trigger(rtuAddr, code, protocolName, protocolVersion, callback);
            }
    public void trigger(String rtuAddr, String code, String protocolName, Short protocolVersion, Callback callbackCom, Object ...objects){
        if(task != null && !task.taskIsOver){
            this.task.trigger(rtuAddr, code, protocolName, protocolVersion, callbackCom, objects);
        }
    }

@@ -107,7 +133,7 @@
    ////////////////////////////////////////////////////
    /**
     * 当前升级状态
     * @return
     * @return 当前升级状态
     */
    public UpgradeState currentUpgradeState() {
        if(task != null){
@@ -119,10 +145,11 @@

    /**
     * Rtu升级信息
     * @param rtuAddr
     * @return
     * @param rtuAddr 控制器RTU地址
     * @return 控制器RTU升级状态
     */
    public UpgradeRtu upgradeInfos(String rtuAddr){
    @SuppressWarnings("unused")
    public UpgradeRtu upgradeRtuInfo(String rtuAddr){
        if(task != null){
            return task.upgradeInfos(rtuAddr) ;
        }else{
@@ -132,10 +159,11 @@

    /**
     * Rtu升级信息
     * @param rtuAddrList
     * @return
     * @param rtuAddrList 控制器地址列表
     * @return 指定列表中的控制器RTU升级状态
     */
    public List<UpgradeRtu> upgradeInfos(List<String> rtuAddrList){
    @SuppressWarnings("unused")
    public List<UpgradeRtu> upgradeRtuInfos(List<String> rtuAddrList){
        if(task != null){
            return task.upgradeInfos(rtuAddrList) ;
        }else{
@@ -144,4 +172,185 @@
    }


    /**
     * 所有Rtu升级信息
     * @return 所有Rtu升级信息
     */
    public List<UpgradeRtu> upgradeRtuInfoAll(){
        if(task != null){
            return task.upgradeInfoAll() ;
        }else{
            return null ;
        }
    }


    ////////////////////////////////////////////////////
    //
    // 升级服务工作线程执行的方法
    // 统计状态 + 状态通知
    //
    ////////////////////////////////////////////////////
    public Object execute() {
        if(this.task == null
                || this.task.taskVo == null
                || this.task.taskVo.rtuAddrList == null
                || this.task.taskVo.rtuAddrList.size() == 0){
            //任务为空
            this.stop() ;
        }else{
            if(!this.task.taskIsOver){
                if(this.openNoUpgrade != null
                        && this.openNoUpgrade.booleanValue()
                        && this.monitorFirst){
                    //第一次进入，进行阀开不升级处理
                    this.task.openNoUpgrade() ;
                }
                this.nowNotifyTimesAfterOver = 0 ;
                //升级任务未完成
                //工作1：判断是否无任何一个RTU进行过升级，并且达到时限，则认为当前升级任务完成
                //-1:无一RTU升级且超时，0：无RTU升级但未超时等待，1有RTU升级正常执行
                //int temp = 1 ;
                int temp = this.task.countNoOneRtuUpgradeInDuration() ;
                if(temp == -1){
                    //当前没有RTU进行过升级，而且超时了，认为任务已经完成
                    this.task.taskIsOver = true ;
                    this.stop();
                    log.info("===========================================================") ;
                    log.info("=                                                         =") ;
                    log.info("=无RTU升级超时，因无一台RTU进行升级，并且等待超时，强制设置升级完成  =") ;
                    log.info("=                                                         =") ;
                    log.info("===========================================================") ;
                }else if(temp == 1){
                    //当前有RTU进行过升级
                    //工作2：统计当前正在升级的RTU数量，为同时升级数量限制做准备
                    temp = this.task.countRunningRtuCount() ;
                    if(temp > 0){
                        //说前当前还有升级中的RTU
                    }

                    //工作3：统计需要升级但当前离线RTU的情况，超过时限的设置为升级完成
                    int tmp = this.task.countOffRtuAndSetIfOver() ;
                    if(tmp >= 1){
                        //超时，强制设置一些RTU升级失败并且升级完成
                        log.info("======================================================") ;
                        log.info("=                                                    =") ;
                        log.info("=因离线超时，强制设置" + tmp + "台RTU升级失败并且升级完成            =") ;
                        log.info("=                                                    =") ;
                        log.info("======================================================") ;
                    }else if(tmp == 0){
                        /*
                        log.info("======================================================") ;
                        log.info("=                                                    =") ;
                        log.info("=离线超时，但无一台RTU因离线而被设置成升级失败并且升级完成     =") ;
                        log.info("=                                                    =") ;
                        log.info("======================================================") ;
                         */
                    }else{//tmp = -1
                        //无任务逻辑
                    }

                    //工作4：统计进行升级过程而后又停止升级，发呆一定时长的设备
                    tmp = this.task.countRunningIdleRtuAndSetIfOver() ;
                    if(tmp >= 1){
                        //升级发呆超时，强制设置一些RTU升级失败并且升级完成
                        log.info("======================================================") ;
                        log.info("=                                                    =") ;
                        log.info("=因升级发呆超时，强制设置" + tmp + "台RTU升级失败并且升级完成          =") ;
                        log.info("=                                                    =") ;
                        log.info("======================================================") ;
                    }

                    //工作5：统计是否全部升级完成
                    this.task.taskIsOver = this.task.countIsAllOver() ;
                    if(this.task.taskIsOver){
                        log.info("==================================================") ;
                        log.info("=                                                =") ;
                        log.info("= 升级全部结束，设置升级任务完成，涉及RTU" + this.task.taskVo.rtuAddrList.size() + "台          =") ;
                        log.info("=                                                =") ;
                        log.info("==================================================") ;
                    }
                }else if(temp == 0){
                    //当前没有一个RTU进行过升级，也没有超时，不作为
                }
                if(this.task.taskIsOver){
                    if(!this.task.taskOverType.equals(UpgradeTask.TaskOverType_Force)){
                        //任务不是强制结束的
                        this.task.taskOverType = UpgradeTask.TaskOverType_Natural ;//任务完成方式（自然，强制）
                        this.task.taskOverDt = DateTime.yyyy_MM_dd_HH_mm_ss() ;//任务完成时间(yyyy-mm-dd HH:MM:SS)
                    }
                    //任务完成，执行最后一次升级状态通知
                    //工作6：升级状态通知
                    //if(!first){
                    //    this.notifyUpgradeStatus() ;
                    //}
                }else{
                    //任务未完成，继续执行升级状态通知
                    //工作6： 升级状态通知
                    //if(!first){
                    //    this.notifyUpgradeStatus() ;
                    //}
                }
                //工作6：升级状态通知
                if(!this.monitorFirst){
                    this.notifyUpgradeStatus() ;
                }
            }else{
                //任务已经完成
                //工作6：任务结束后，最后发升级状态通知
                if(this.nowNotifyTimesAfterOver == 0){
                    this.nowNotifyTimesAfterOver++ ;
                    this.notifyUpgradeStatus() ;//必须通知一次
                }else{
                    //然后重复通知
                    if(this.nowNotifyTimesAfterOver <= this.notifyTimesAfterOver){
                        //保证上面必须通知一次，那此处上面if中就得用<=
                        this.nowNotifyTimesAfterOver++ ;
                        this.notifyUpgradeStatus() ;
                    }else{
                        this.stop();
                    }
                }

            }
        }
        if(this.monitorFirst){
            this.monitorFirst = false ;
        }
        return true ;
    }


    /**
     * 升级状态通知
     */
    private void notifyUpgradeStatus(){
        if(this.task.taskVo.callbackWebUrl != null && this.task.taskVo.callbackWebUrl.length() > 0){
            UpgradeInfo info = new UpgradeInfo() ;
            info.ugTaskId = this.task.taskVo.id ;//任务ID
            info.ugOverallState = this.currentUpgradeState() ;
            info.ugRtuStateList = this.upgradeRtuInfoAll() ;
            WebRequestDeal deal = SpringContextUtil.getBean(WebRequestDeal.class) ;
            deal.deal(this.task.taskVo.callbackWebUrl, info);
        }
    }

    ////////////////////////////////////////////////////
    //
    // 升级状态通知工作线程执行完成后回调的方法，
    // 也就是上面execute方法执行完成返回或抛出异常后，执行下面三个方法
    //
    ////////////////////////////////////////////////////
    @Override
    public void call(Object obj) {
        //线程工作执行完了，obj = Boolean(true)
    }
    @Override
    public void call(Object... objs) {
    }
    @Override
    public void exception(Exception e) {
        log.error("远程升级伺服线程发生异常", e);
    }

}