pipIrr-platform/pipIrr-global/src/main/java/com/dy/pipIrrGlobal/command/ComResultWait.java

@@ -21,6 +21,10 @@
        return features.get(key);
    }

    public static boolean contain(Long key) {
        return features.containsKey(key);
    }

    public static void remove(Long key){
        features.remove(key) ;
    }

 pipIrr-platform/pipIrr-global/src/main/java/com/dy/pipIrrGlobal/command/CommandSv.java

@@ -100,7 +100,10 @@
        po.setParam((JSONObject) JSON.toJSON(param));
        po.setSendTime(new Date());
        po.setOperator(operator);
        rmCommandHistoryDao.insertSelective(po) ;
        int count = rmCommandHistoryDao.insertSelective(po) ;
        if(count == 0){
            po = null ;
        }
        return po;
    }


 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/rtuData/p206V1/TkDealCloseValveReport.java

@@ -121,7 +121,7 @@
                                if(poHistory.openDt.equals(DateTime.dateFrom_yyyy_MM_dd_HH_mm_ss(dataCd83CloseVo.openDt))){
                                    //匹配成功
                                    //当前关阀是原记录中开阀的对应关阀
                                    this.updateCloseValve(clientVo, controller, poLast, poHistory, dV1, dataCd83CloseVo, false) ;
                                    this.updateCloseValve(clientVo, controller, rtuAddr, poLast, poHistory, dV1, dataCd83CloseVo, false) ;
                                    sv.updateRmOpenCloseValveHistory(poHistory);
                                }else if(poHistory.openDt.after(DateTime.dateFrom_yyyy_MM_dd_HH_mm_ss(dataCd83CloseVo.openDt))){
                                    //匹配失败(对于after:等于或晚于都返回true)
@@ -162,28 +162,28 @@
                        if (poHistory != null) {
                            if(poHistory.openDt.equals(DateTime.dateFrom_yyyy_MM_dd_HH_mm_ss(dataCd83CloseVo.openDt))){
                                //匹配上了
                                this.updateCloseValve(clientVo, controller, poLast, poHistory, dV1, dataCd83CloseVo, false) ;
                                this.updateCloseValve(clientVo, controller, rtuAddr, poLast, poHistory, dV1, dataCd83CloseVo, false) ;
                                sv.updateRmOpenCloseValveHistory(poHistory);
                            }else{
                                //上个关阀报未上报
                                this.updateCloseValve(clientVo, controller, poLast, null, dV1, dataCd83CloseVo, true) ;
                                this.updateCloseValve(clientVo, controller, rtuAddr, poLast, null, dV1, dataCd83CloseVo, true) ;
                                this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV1, dataCd83CloseVo, poLast, null);
                            }
                        }else{
                            //这种情况不存在，但为安全也进行处理，也认为上个关阀报未上报
                            this.updateCloseValve(clientVo, controller, poLast, null, dV1, dataCd83CloseVo, true) ;
                            this.updateCloseValve(clientVo, controller, rtuAddr, poLast, null, dV1, dataCd83CloseVo, true) ;
                            this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV1, dataCd83CloseVo, poLast, null);
                        }
                    }else{
                        //这种情况不存在，但为安全也进行处理，也认为上个关阀报未上报
                        this.updateCloseValve(clientVo, controller, poLast, null, dV1, dataCd83CloseVo, true) ;
                        this.updateCloseValve(clientVo, controller, rtuAddr, poLast, null, dV1, dataCd83CloseVo, true) ;
                        this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV1, dataCd83CloseVo, poLast, null);
                    }
                }
            }else{
                //if(po.opType == null)
                //原记录不存在开阀数据也不存在关阀数据，这种情况不存在，但为安全也进行处理，也认为上个关阀报未上报
                this.updateCloseValve(clientVo, controller, poLast, null, dV1, dataCd83CloseVo, true) ;
                this.updateCloseValve(clientVo, controller, rtuAddr, poLast, null, dV1, dataCd83CloseVo, true) ;
                //生成并保存新的关阀上报历史数据记录，没有对应的开发数据
                this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV1, dataCd83CloseVo, poLast, null);
            }
@@ -291,6 +291,7 @@
     */
    private void updateCloseValve(SeClient clientVo,
                                  PrController controller,
                                  String rtuAddr,
                                  RmOpenCloseValveLast poLast,
                                  RmOpenCloseValveHistory poHistory,
                                  DataV1 dV1,
@@ -300,17 +301,15 @@
        poLast.clientName = clientVo==null?null:clientVo.getName() ;
        poLast.controllerId = controller==null?null:controller.getId();
        poLast.intakeId = controller==null?null:controller.getIntakeId();

        poLast.rtuAddr = rtuAddr;
        poLast.updateFrom(dV1, dataCd83CloseVo, clearLastOpenValue);

        if(poHistory != null){
            poHistory.clientId = clientVo==null?null:clientVo.getId() ;
            poHistory.clientName = clientVo==null?null:clientVo.getName() ;
            poHistory.controllerId = controller==null?null:controller.getId();
            poHistory.intakeId = controller==null?null:controller.getIntakeId();

            poHistory.rtuAddr = rtuAddr;
            poHistory.updateFrom(dV1, dataCd83CloseVo, false);
        }

    }
}

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/rtuData/p206V1/TkDealOpenValveReport.java

@@ -111,7 +111,7 @@
                    this.dealSupplyReport() ;
                }else {
                    //当前开阀上报是新的一次开阀，不管原记录是否存在关阀数据，一律清空关阀数据
                    this.updateOpenValve(clientVo, controller, poLast, null, dV1, dataCd83OpenVo, true) ;
                    this.updateOpenValve(clientVo, controller, rtuAddr, poLast, null, dV1, dataCd83OpenVo, true) ;
                    //生成并保存新的开阀上报历史数据记录
                    this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV1, dataCd83OpenVo, poLast);
                }
@@ -119,7 +119,7 @@
                //原记录不存在开阀数据，但存在关阀数据，首先进行时间比对
                if(poLast.clOpenDt != null && poLast.clOpenDt.before(DateTime.dateFrom_yyyy_MM_dd_HH_mm_ss(dataCd83OpenVo.openDt))){
                    //当前上报是新的开阀数据，把最新(last)数据中的关阀内容清空
                    this.updateOpenValve(clientVo, controller, poLast, null, dV1, dataCd83OpenVo, true) ;
                    this.updateOpenValve(clientVo, controller, rtuAddr, poLast, null, dV1, dataCd83OpenVo, true) ;
                    //生成并保存新的开阀上报历史数据记录
                    this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV1, dataCd83OpenVo, poLast);
                }else if(poLast.clOpenDt != null && poLast.clOpenDt.after(DateTime.dateFrom_yyyy_MM_dd_HH_mm_ss(dataCd83OpenVo.openDt))){
@@ -131,7 +131,7 @@
                    if(poLast.lastHistoryId != null){
                        poHistory = sv.getRmOpenCloseValveHistory(poLast.lastHistoryId) ;
                    }
                    this.updateOpenValve(clientVo, controller, poLast, poHistory, dV1, dataCd83OpenVo, false) ;
                    this.updateOpenValve(clientVo, controller, rtuAddr, poLast, poHistory, dV1, dataCd83OpenVo, false) ;
                    if(poHistory != null){
                        sv.updateRmOpenCloseValveHistory(poHistory);
                    }
@@ -139,7 +139,7 @@
            }else{
                //if(poLast.opType == null && po.clType == null)
                //原记录不存在开阀数据也不存在关阀数据，这种情况不存在，但为安全也进行处理
                this.updateOpenValve(clientVo, controller, poLast, null, dV1, dataCd83OpenVo, true) ;
                this.updateOpenValve(clientVo, controller, rtuAddr, poLast, null, dV1, dataCd83OpenVo, true) ;
                //生成并保存新的开阀上报历史数据记录
                this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV1, dataCd83OpenVo, poLast);
            }
@@ -229,6 +229,7 @@
     */
    private void updateOpenValve(SeClient clientVo,
                                 PrController controller,
                                 String rtuAddr,
                                 RmOpenCloseValveLast poLast,
                                 RmOpenCloseValveHistory poHistory,
                                 DataV1 dV1,
@@ -238,13 +239,15 @@
        poLast.clientName = clientVo==null?null:clientVo.getName() ;
        poLast.controllerId = controller==null?null:controller.getId();
        poLast.intakeId = controller==null?null:controller.getIntakeId();
        poLast.rtuAddr = rtuAddr;
        poLast.updateFrom(dV1, dataCd83OpenVo, clearLastCloseValve);

        if(poHistory != null){
            poLast.clientId = clientVo==null?null:clientVo.getId() ;
            poLast.clientName = clientVo==null?null:clientVo.getName() ;
            poHistory.clientId = clientVo==null?null:clientVo.getId() ;
            poHistory.clientName = clientVo==null?null:clientVo.getName() ;
            poHistory.controllerId = controller==null?null:controller.getId();
            poHistory.intakeId = controller==null?null:controller.getIntakeId();
            poHistory.rtuAddr = rtuAddr;
            poHistory.updateFrom(dV1, dataCd83OpenVo, false);
        }
    }

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/rtuData/p206V2/TkDealCloseValveReportV2.java

@@ -122,7 +122,7 @@
                                if(poHistory.openDt.equals(DateTime.dateFrom_yyyy_MM_dd_HH_mm_ss(dataCd83CloseVo.openDt))){
                                    //匹配成功
                                    //当前关阀是原记录中开阀的对应关阀
                                    this.updateCloseValve(clientVo, controller, poLast, poHistory, dV2, dataCd83CloseVo, false) ;
                                    this.updateCloseValve(clientVo, controller, rtuAddr, poLast, poHistory, dV2, dataCd83CloseVo, false) ;
                                    sv.updateRmOpenCloseValveHistory(poHistory);
                                }else if(poHistory.openDt.after(DateTime.dateFrom_yyyy_MM_dd_HH_mm_ss(dataCd83CloseVo.openDt))){
                                    //匹配失败(对于after:等于或晚于都返回true)
@@ -163,28 +163,28 @@
                        if (poHistory != null) {
                            if(poHistory.openDt.equals(DateTime.dateFrom_yyyy_MM_dd_HH_mm_ss(dataCd83CloseVo.openDt))){
                                //匹配上了
                                this.updateCloseValve(clientVo, controller, poLast, poHistory, dV2, dataCd83CloseVo, false) ;
                                this.updateCloseValve(clientVo, controller, rtuAddr, poLast, poHistory, dV2, dataCd83CloseVo, false) ;
                                sv.updateRmOpenCloseValveHistory(poHistory);
                            }else{
                                //上个关阀报未上报
                                this.updateCloseValve(clientVo, controller, poLast, null, dV2, dataCd83CloseVo, true) ;
                                this.updateCloseValve(clientVo, controller, rtuAddr, poLast, null, dV2, dataCd83CloseVo, true) ;
                                this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV2, dataCd83CloseVo, poLast, null);
                            }
                        }else{
                            //这种情况不存在，但为安全也进行处理，也认为上个关阀报未上报
                            this.updateCloseValve(clientVo, controller, poLast, null, dV2, dataCd83CloseVo, true) ;
                            this.updateCloseValve(clientVo, controller, rtuAddr, poLast, null, dV2, dataCd83CloseVo, true) ;
                            this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV2, dataCd83CloseVo, poLast, null);
                        }
                    }else{
                        //这种情况不存在，但为安全也进行处理，也认为上个关阀报未上报
                        this.updateCloseValve(clientVo, controller, poLast, null, dV2, dataCd83CloseVo, true) ;
                        this.updateCloseValve(clientVo, controller, rtuAddr, poLast, null, dV2, dataCd83CloseVo, true) ;
                        this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV2, dataCd83CloseVo, poLast, null);
                    }
                }
            }else{
                //if(po.opType == null)
                //原记录不存在开阀数据也不存在关阀数据，这种情况不存在，但为安全也进行处理，也认为上个关阀报未上报
                this.updateCloseValve(clientVo, controller, poLast, null, dV2, dataCd83CloseVo, true) ;
                this.updateCloseValve(clientVo, controller, rtuAddr, poLast, null, dV2, dataCd83CloseVo, true) ;
                //生成并保存新的关阀上报历史数据记录，没有对应的开发数据
                this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV2, dataCd83CloseVo, poLast, null);
            }
@@ -292,6 +292,7 @@
     */
    private void updateCloseValve(SeClient clientVo,
                                  PrController controller,
                                  String rtuAddr,
                                  RmOpenCloseValveLast poLast,
                                  RmOpenCloseValveHistory poHistory,
                                  DataV2 dV2,
@@ -301,17 +302,15 @@
        poLast.clientName = clientVo==null?null:clientVo.getName() ;
        poLast.controllerId = controller==null?null:controller.getId();
        poLast.intakeId = controller==null?null:controller.getIntakeId();

        poLast.rtuAddr = rtuAddr;
        poLast.updateFrom(dV2, dataCd83CloseVo, clearLastOpenValue);

        if(poHistory != null){
            poHistory.clientId = clientVo==null?null:clientVo.getId() ;
            poHistory.clientName = clientVo==null?null:clientVo.getName() ;
            poHistory.controllerId = controller==null?null:controller.getId();
            poHistory.intakeId = controller==null?null:controller.getIntakeId();

            poHistory.rtuAddr = rtuAddr;
            poHistory.updateFrom(dV2, dataCd83CloseVo, false);
        }

    }
}

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/rtuData/p206V2/TkDealOpenValveReportV2.java

@@ -110,7 +110,7 @@
                    this.dealSupplyReport() ;
                }else {
                    //当前开阀上报是新的一次开阀，不管原记录是否存在关阀数据，一律清空关阀数据
                    this.updateOpenValve(clientVo, controller, poLast, null, dV2, dataCd83OpenVo, true) ;
                    this.updateOpenValve(clientVo, controller, rtuAddr, poLast, null, dV2, dataCd83OpenVo, true) ;
                    //生成并保存新的开阀上报历史数据记录
                    this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV2, dataCd83OpenVo, poLast);
                }
@@ -118,7 +118,7 @@
                //原记录不存在开阀数据，但存在关阀数据，首先进行时间比对
                 if(poLast.clOpenDt != null && poLast.clOpenDt.before(DateTime.dateFrom_yyyy_MM_dd_HH_mm_ss(dataCd83OpenVo.openDt))){
                     //当前上报是新的开阀数据，把最新(last)数据中的关阀内容清空
                     this.updateOpenValve(clientVo, controller, poLast, null, dV2, dataCd83OpenVo, true) ;
                     this.updateOpenValve(clientVo, controller, rtuAddr, poLast, null, dV2, dataCd83OpenVo, true) ;
                     //生成并保存新的开阀上报历史数据记录
                     this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV2, dataCd83OpenVo, poLast);
                 }else if(poLast.clOpenDt != null && poLast.clOpenDt.after(DateTime.dateFrom_yyyy_MM_dd_HH_mm_ss(dataCd83OpenVo.openDt))){
@@ -130,7 +130,7 @@
                    if(poLast.lastHistoryId != null){
                        poHistory = sv.getRmOpenCloseValveHistory(poLast.lastHistoryId) ;
                    }
                    this.updateOpenValve(clientVo, controller, poLast, poHistory, dV2, dataCd83OpenVo, false) ;
                    this.updateOpenValve(clientVo, controller, rtuAddr, poLast, poHistory, dV2, dataCd83OpenVo, false) ;
                    if(poHistory != null){
                        sv.updateRmOpenCloseValveHistory(poHistory);
                    }
@@ -138,7 +138,7 @@
            }else{
                //if(poLast.opType == null && po.clType == null)
                //原记录不存在开阀数据也不存在关阀数据，这种情况不存在，但为安全也进行处理
                this.updateOpenValve(clientVo, controller, poLast, null, dV2, dataCd83OpenVo, true) ;
                this.updateOpenValve(clientVo, controller, rtuAddr, poLast, null, dV2, dataCd83OpenVo, true) ;
                //生成并保存新的开阀上报历史数据记录
                this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV2, dataCd83OpenVo, poLast);
            }
@@ -228,6 +228,7 @@
     */
    private void updateOpenValve(SeClient clientVo,
                                 PrController controller,
                                 String rtuAddr,
                                 RmOpenCloseValveLast poLast,
                                 RmOpenCloseValveHistory poHistory,
                                 DataV2 dV2,
@@ -237,13 +238,14 @@
        poLast.clientName = clientVo==null?null:clientVo.getName() ;
        poLast.controllerId = controller==null?null:controller.getId();
        poLast.intakeId = controller==null?null:controller.getIntakeId();
        poLast.rtuAddr = rtuAddr;
        poLast.updateFrom(dV2, dataCd83OpenVo, clearLastCloseValve);

        if(poHistory != null){
            poLast.clientId = clientVo==null?null:clientVo.getId() ;
            poLast.clientName = clientVo==null?null:clientVo.getName() ;
            poHistory.clientId = clientVo==null?null:clientVo.getId() ;
            poHistory.clientName = clientVo==null?null:clientVo.getName() ;
            poHistory.controllerId = controller==null?null:controller.getId();
            poHistory.intakeId = controller==null?null:controller.getIntakeId();
            poHistory.rtuAddr = rtuAddr;
            poHistory.updateFrom(dV2, dataCd83OpenVo, false);
        }
    }

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/rtuData/p206V202404/TkDealCloseValveReportV202404.java

@@ -119,7 +119,7 @@
                                if(poHistory.openDt.equals(DateTime.dateFrom_yyyy_MM_dd_HH_mm_ss(dataCd85Vo.startDt))){
                                    //匹配成功
                                    //当前关阀是原记录中开阀的对应关阀
                                    this.updateCloseValve(clientVo, controller, poLast, poHistory, dV202404, dataCd85Vo, false) ;
                                    this.updateCloseValve(clientVo, controller, rtuAddr, poLast, poHistory, dV202404, dataCd85Vo, false) ;
                                    sv.updateRmOpenCloseValveHistory(poHistory);
                                }else if(poHistory.openDt.after(DateTime.dateFrom_yyyy_MM_dd_HH_mm_ss(dataCd85Vo.startDt))){
                                    //匹配失败(对于after:等于或晚于都返回true)
@@ -160,28 +160,28 @@
                        if (poHistory != null) {
                            if(poHistory.openDt.equals(DateTime.dateFrom_yyyy_MM_dd_HH_mm_ss(dataCd85Vo.startDt))){
                                //匹配上了
                                this.updateCloseValve(clientVo, controller, poLast, poHistory, dV202404, dataCd85Vo, false) ;
                                this.updateCloseValve(clientVo, controller, rtuAddr, poLast, poHistory, dV202404, dataCd85Vo, false) ;
                                sv.updateRmOpenCloseValveHistory(poHistory);
                            }else{
                                //上个关阀报未上报
                                this.updateCloseValve(clientVo, controller, poLast, null, dV202404, dataCd85Vo, true) ;
                                this.updateCloseValve(clientVo, controller, rtuAddr, poLast, null, dV202404, dataCd85Vo, true) ;
                                this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV202404, dataCd85Vo, poLast, null);
                            }
                        }else{
                            //这种情况不存在，但为安全也进行处理，也认为上个关阀报未上报
                            this.updateCloseValve(clientVo, controller, poLast, null, dV202404, dataCd85Vo, true) ;
                            this.updateCloseValve(clientVo, controller, rtuAddr, poLast, null, dV202404, dataCd85Vo, true) ;
                            this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV202404, dataCd85Vo, poLast, null);
                        }
                    }else{
                        //这种情况不存在，但为安全也进行处理，也认为上个关阀报未上报
                        this.updateCloseValve(clientVo, controller, poLast, null, dV202404, dataCd85Vo, true) ;
                        this.updateCloseValve(clientVo, controller, rtuAddr, poLast, null, dV202404, dataCd85Vo, true) ;
                        this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV202404, dataCd85Vo, poLast, null);
                    }
                }
            }else{
                //if(po.opType == null)
                //原记录不存在开阀数据也不存在关阀数据，这种情况不存在，但为安全也进行处理，也认为上个关阀报未上报
                this.updateCloseValve(clientVo, controller, poLast, null, dV202404, dataCd85Vo, true) ;
                this.updateCloseValve(clientVo, controller, rtuAddr, poLast, null, dV202404, dataCd85Vo, true) ;
                //生成并保存新的关阀上报历史数据记录，没有对应的开发数据
                this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dV202404, dataCd85Vo, poLast, null);
            }
@@ -289,6 +289,7 @@
     */
    private void updateCloseValve(SeClient clientVo,
                                  PrController controller,
                                  String rtuAddr,
                                  RmOpenCloseValveLast poLast,
                                  RmOpenCloseValveHistory poHistory,
                                  DataV202404 dV202404,
@@ -298,15 +299,14 @@
        poLast.clientName = clientVo==null?null:clientVo.getName() ;
        poLast.controllerId = controller==null?null:controller.getId();
        poLast.intakeId = controller==null?null:controller.getIntakeId();

        poLast.rtuAddr = rtuAddr;
        poLast.updateFrom(dV202404, dataCd85Vo, clearLastOpenValue);

        if(poHistory != null){
            poHistory.clientId = clientVo==null?null:clientVo.getId() ;
            poHistory.clientName = clientVo==null?null:clientVo.getName() ;
            poHistory.controllerId = controller==null?null:controller.getId();
            poHistory.intakeId = controller==null?null:controller.getIntakeId();

            poHistory.rtuAddr = rtuAddr;
            poHistory.updateFrom(dV202404, dataCd85Vo, false);
        }
    }

 pipIrr-platform/pipIrr-mw/pipIrr-mw-rtu/src/main/java/com/dy/rtuMw/server/rtuData/p206V202404/TkDealOpenValveReportV202404.java

@@ -110,7 +110,7 @@
                    this.dealSupplyReport() ;
                }else {
                    //当前开阀上报是新的一次开阀，不管原记录是否存在关阀数据，一律清空关阀数据
                    this.updateOpenValve(clientVo, controller, poLast, null, dataV202404, dataCd84Vo, true) ;
                    this.updateOpenValve(clientVo, controller, rtuAddr, poLast, null, dataV202404, dataCd84Vo, true) ;
                    //生成并保存新的开阀上报历史数据记录
                    this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dataV202404, dataCd84Vo, poLast);
                }
@@ -118,7 +118,7 @@
                //原记录不存在开阀数据，但存在关阀数据，首先进行时间比对
                if(poLast.clOpenDt != null && poLast.clOpenDt.before(DateTime.dateFrom_yyyy_MM_dd_HH_mm_ss(dataCd84Vo.openDt))){
                    //当前上报是新的开阀数据，把最新(last)数据中的关阀内容清空
                    this.updateOpenValve(clientVo, controller, poLast, null, dataV202404, dataCd84Vo, true) ;
                    this.updateOpenValve(clientVo, controller, rtuAddr, poLast, null, dataV202404, dataCd84Vo, true) ;
                    //生成并保存新的开阀上报历史数据记录
                    this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dataV202404, dataCd84Vo, poLast);
                }else if(poLast.clOpenDt != null && poLast.clOpenDt.after(DateTime.dateFrom_yyyy_MM_dd_HH_mm_ss(dataCd84Vo.openDt))){
@@ -130,7 +130,7 @@
                    if(poLast.lastHistoryId != null){
                        poHistory = sv.getRmOpenCloseValveHistory(poLast.lastHistoryId) ;
                    }
                    this.updateOpenValve(clientVo, controller, poLast, poHistory, dataV202404, dataCd84Vo, false) ;
                    this.updateOpenValve(clientVo, controller, rtuAddr, poLast, poHistory, dataV202404, dataCd84Vo, false) ;
                    if(poHistory != null){
                        sv.updateRmOpenCloseValveHistory(poHistory);
                    }
@@ -138,7 +138,7 @@
            }else{
                //if(poLast.opType == null && po.clType == null)
                //原记录不存在开阀数据也不存在关阀数据，这种情况不存在，但为安全也进行处理
                this.updateOpenValve(clientVo, controller, poLast, null, dataV202404, dataCd84Vo, true) ;
                this.updateOpenValve(clientVo, controller, rtuAddr, poLast, null, dataV202404, dataCd84Vo, true) ;
                //生成并保存新的开阀上报历史数据记录
                this.newHistoryDataDeal(sv, clientVo, controller, rtuAddr, dataV202404, dataCd84Vo, poLast);
            }
@@ -228,6 +228,7 @@
     */
    private void updateOpenValve(SeClient clientVo,
                                 PrController controller,
                                 String rtuAddr,
                                 RmOpenCloseValveLast poLast,
                                 RmOpenCloseValveHistory poHistory,
                                 DataV202404 dataV202404,
@@ -237,16 +238,15 @@
        poLast.clientName = clientVo==null?null:clientVo.getName() ;
        poLast.controllerId = controller==null?null:controller.getId();
        poLast.intakeId = controller==null?null:controller.getIntakeId();
        poLast.rtuAddr = rtuAddr;
        poLast.updateFrom(dataV202404, dataCd84Vo, clearLastCloseValve);

        if(poHistory != null){
            poHistory.clientId = clientVo==null?null:clientVo.getId() ;
            poHistory.clientName = clientVo==null?null:clientVo.getName() ;
            poHistory.controllerId = controller==null?null:controller.getId();
            poHistory.intakeId = controller==null?null:controller.getIntakeId();
            poHistory.rtuAddr = rtuAddr;
            poHistory.updateFrom(dataV202404, dataCd84Vo, false);
        }
    }


}

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

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

import jakarta.validation.constraints.NotNull;
import lombok.Data;
import lombok.experimental.SuperBuilder;

/**
 * @author ZhuBaoMin

 pipIrr-platform/pipIrr-web/pipIrr-web-remote/src/main/java/com/dy/pipIrrRemote/monitor/ComTransCtrl.java

@@ -3,30 +3,23 @@
import com.alibaba.fastjson2.JSONObject;
import com.dy.common.aop.SsoAop;
import com.dy.common.mw.protocol.Command;
import com.dy.common.util.IDLongGenerator;
import com.dy.common.util.NumUtil;
import com.dy.common.webUtil.BaseResponse;
import com.dy.common.webUtil.BaseResponseUtils;
import com.dy.pipIrrGlobal.command.ComResultWait;
import com.dy.pipIrrGlobal.pojoPr.PrController;
import com.dy.pipIrrRemote.common.dto.DtoBase;
import com.dy.pipIrrRemote.monitor.common.ComCtrl;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.context.annotation.Scope;
import org.springframework.http.MediaType;
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.client.RestTemplate;

import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

/**
 * @Author: liurunyu
@@ -38,24 +31,13 @@
@RestController
@RequestMapping(path = "comTrans")
@RequiredArgsConstructor
public class ComTransCtrl {
@Scope("prototype") //因为有对象类属性，所以采用原型模式，每次请求新建一个实例对象
public class ComTransCtrl extends ComCtrl {

    private static final String RtuSuccessMsg = "控制器接收并执行命令成功";

    @Autowired
    private Environment env ;

    @Autowired
    private RestTemplate restTemplate ;

    @Value("${mw.waitMwRtnResultTimeout}")
    private int waitMwRtnResultTimeout ;

    @Value("${mw.rtuCallbackUrl_rm}")
    private String rtuResultSendWebUrl;

    @Autowired
    private ComTransSv comSv;
    private ComTransSv sv ;

    /**
     * å‘设备（控制器）发送透传命令
@@ -66,66 +48,43 @@
    @PostMapping(path = "send", consumes = MediaType.APPLICATION_JSON_VALUE)
    @SsoAop()
    public BaseResponse<Object> send(@RequestBody @Valid ComTransDto dto, BindingResult bindingResult) {
        if (bindingResult != null && bindingResult.hasErrors()) {
            return BaseResponseUtils.buildError(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }
        String msg = this.checkDto(dto) ;
        if(msg != null){
            return BaseResponseUtils.buildError(msg) ;
        }
        //得到控制器对象
        PrController ctrlPo = comSv.getRtu(dto.getIntakeId());
        if (ctrlPo == null) {
            return BaseResponseUtils.buildError("从数据库中未得到控制器数据") ;
        }
        //检查协议
        msg = comSv.checkProtocol(ctrlPo) ;
        if(msg != null) {
            return BaseResponseUtils.buildError(msg) ;
        }
        //得到功能码对应的命令名称
        String comName = comSv.getCommandName(dto.comCode, ctrlPo) ;
        if(comName == null) {
            return BaseResponseUtils.buildError("未得到功能码对应命令名称") ;
        }
        Long comId = new IDLongGenerator().generate();
        String comData = dto.comData.toUpperCase() ;
        //生成并保存命令日志
        comSv.saveComHistoryPo(comId, ctrlPo.getProtocol(), dto.comCode, "透传（" + comName + "）",
                dto.getIntakeId(), ctrlPo.getRtuAddr(), new ComTransParam(dto.comCode, comData), dto.getOperator());
        try{
            CompletableFuture<JSONObject> feature = new CompletableFuture<>();
            ComResultWait.put(comId, feature);
            //创建外部透传命令（发给控制器）
            Command com = comSv.createOuterTransparentCommand("" + comId, dto.comCode);
            com.rtuAddr = ctrlPo.getRtuAddr() ;
            com.attachment = comData ;
            com.rtuResultSendWebUrl = rtuResultSendWebUrl;
            //得到通信中间件发送命令的web URL
            String rqUrl = comSv.get2MwRequestUrl(this.env, comSv.ContextComSend) ;
            //向通信中间件发送web请求
            BaseResponse res = comSv.sendPostRequest2Mw(restTemplate, rqUrl, com) ;
            //处理通信中间件对web请求的响应
            msg = comSv.dealMwDealResponse(res) ;
            if(msg != null) {
                return BaseResponseUtils.buildError(msg) ;
            }else{
                try{
                    //等待通信中间件通知控制器执行命令上行数据（命令结果）
                    JSONObject resultData = feature.get(waitMwRtnResultTimeout, TimeUnit.SECONDS);
                    return BaseResponseUtils.buildSuccess(this.createRtnMsg(dto.comCode, resultData));
                }catch (Exception e){
                    return BaseResponseUtils.buildFail("等待通信中间件通知命令结果超时");
        BaseResponse<Object> res ;
        //发送命令前-1：验证
        res = super.pre1(sv, dto.comCode, dto, bindingResult);
        if(res == null) {
            //发送命令前-2：获得数据
            res = super.pre2(sv, dto.comCode, dto, bindingResult);
            if(res == null) {
                //发送命令前-3：保存命令日志
                this.comName = "透传（" + comName + "）" ;
                String comData = dto.comData.toUpperCase() ;
                ComTransParam comParam = ComTransParam.builder().commandCode(dto.comCode).data(comData).build();
                res = super.pre3(sv, dto.getIntakeId(), dto.getOperator(), dto.comCode, comParam);
                if(res == null) {
                    //发送命令前-4：准备Feature
                    super.pre4();
                    try{
                        //创建外部透传命令（发给控制器）
                        Command com = sv.createOuterTransparentCommand("" + comId, dto.comCode);
                        com.rtuAddr = ctrlPo.getRtuAddr() ;
                        com.attachment = comData ;
                        com.rtuResultSendWebUrl = rtuResultSendWebUrl;
                        //发送命令
                        res = super.doSend(sv, com) ;
                        if(res == null) {
                            //发送命令后
                            res = super.after(dto.comCode);
                        }
                    }catch (Exception e){
                        res = BaseResponseUtils.buildFail("服务端构造并向通信中间件发送请求时异常" + (e.getMessage() == null?"":e.getMessage())) ;
                    }finally {
                        //最终
                        super.end() ;
                    }
                }
            }
        }catch (Exception e){
            return BaseResponseUtils.buildFail("服务端构造并向通信中间件发送请求时异常" + (e.getMessage() == null?"":e.getMessage())) ;
        }finally {
            try {
                //最后清除CompletableFuture缓存
                ComResultWait.remove(comId);
            }catch (Exception ee){}
        }
        return res ;
    }

    /**
@@ -133,23 +92,26 @@
     * @param dto
     * @return
     */
    private String checkDto(ComTransDto dto){
        if(!NumUtil.isHex(dto.comCode)){
    @Override
    protected String checkDto(DtoBase dto){
        ComTransDto myDto = (ComTransDto)dto;
        if(!NumUtil.isHex(myDto.comCode)){
            return "命令功能码不是十六进制数";
        }
        if(!NumUtil.isHex(dto.comData)){
        if(!NumUtil.isHex(myDto.comData)){
            return "命令数据不是十六进制数";
        }
        if(dto.comData.length() % 2 != 0){
        if(myDto.comData.length() % 2 != 0){
            return "命令数据不完备（长度不是偶数）";
        }
        if(!dto.comData.contains(dto.comCode)){
        if(!myDto.comData.contains(myDto.comCode)){
            return "命令数据中不包含功能码";
        }
        return null ;
    }

    private String createRtnMsg(String code, JSONObject resultData){
    @Override
    protected String createRtnMsg(String code, JSONObject resultData){
        String msg;
        if(resultData != null){
            JSONObject codeData = resultData.getJSONObject("data") ;

 pipIrr-platform/pipIrr-web/pipIrr-web-remote/src/main/java/com/dy/pipIrrRemote/monitor/ComTransDto.java

@@ -4,6 +4,8 @@
import jakarta.validation.constraints.NotEmpty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;
import lombok.experimental.SuperBuilder;

/**
 * @Author: liurunyu
@@ -12,7 +14,8 @@
 */

@Data
@EqualsAndHashCode(callSuper=true)
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
public class ComTransDto extends DtoBase {
    public static final long serialVersionUID = 202505061021001L;


 pipIrr-platform/pipIrr-web/pipIrr-web-remote/src/main/java/com/dy/pipIrrRemote/monitor/ComTransParam.java

@@ -1,7 +1,11 @@
package com.dy.pipIrrRemote.monitor;

import com.dy.pipIrrRemote.monitor.common.CdParam;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;
import lombok.experimental.SuperBuilder;

/**
 * @Author: liurunyu
@@ -9,8 +13,9 @@
 * @Description
 */
@Data
@AllArgsConstructor
public class ComTransParam {
    public String commandCode;
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
@SuperBuilder
public class ComTransParam extends CdParam {
    public String data ;
}
}

 pipIrr-platform/pipIrr-web/pipIrr-web-remote/src/main/java/com/dy/pipIrrRemote/monitor/ComTransSv.java

@@ -1,14 +1,8 @@
package com.dy.pipIrrRemote.monitor;

import com.dy.pipIrrGlobal.command.CommandSv;
import com.dy.pipIrrGlobal.daoPr.PrControllerMapper;
import com.dy.pipIrrGlobal.daoRm.RmCommandHistoryMapper;
import com.dy.pipIrrGlobal.pojoPr.PrController;
import com.dy.pipIrrGlobal.pojoRm.RmCommandHistory;
import com.dy.pipIrrRemote.monitor.common.ComSv;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * @Author: liurunyu
@@ -17,36 +11,5 @@
 */
@Slf4j
@Service
public class ComTransSv extends CommandSv {

    @Autowired
    private PrControllerMapper prControllerDao ;
    @Autowired
    private RmCommandHistoryMapper rmCommandHistoryDao ;

    public PrController getRtu(Long intakeId){
        return this.getRtu(prControllerDao, intakeId);
    }
    /**
     * åˆ›å»ºå‘½ä»¤æ—¥å¿—对象
     *
     * @param comId       ä¸»é”®
     * @param commandCode åŠŸèƒ½ç 
     * @param rtuAddr     é˜€æŽ§å™¨åœ°å€
     * @param protocol    é€šè®¯åè®®åç§°
     * @param param       å‚数数据
     * @param operator    æ“ä½œå‘˜
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public RmCommandHistory saveComHistoryPo(Long comId,
                                             String protocol,
                                             String commandCode,
                                             String commandName,
                                             Long intakeId,
                                             String rtuAddr,
                                             Object param,
                                             Long operator) {
        return this.saveComHistoryPo(rmCommandHistoryDao, comId, protocol, commandCode, commandName, intakeId, rtuAddr, param, operator) ;
    }
public class ComTransSv extends ComSv {
}

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

New file
@@ -0,0 +1,16 @@
package com.dy.pipIrrRemote.monitor.common;

import lombok.*;
import lombok.experimental.SuperBuilder;

/**
 * @Author: liurunyu
 * @Date: 2025/5/9 16:11
 * @Description
 */
@Data
@SuperBuilder
public class CdParam {
    //命令功能码
    public String commandCode;
}

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

New file
@@ -0,0 +1,189 @@
package com.dy.pipIrrRemote.monitor.common;

import com.alibaba.fastjson2.JSONObject;
import com.dy.common.mw.protocol.Command;
import com.dy.common.util.IDLongGenerator;
import com.dy.common.webUtil.BaseResponse;
import com.dy.common.webUtil.BaseResponseUtils;
import com.dy.pipIrrGlobal.command.ComResultWait;
import com.dy.pipIrrGlobal.pojoPr.PrController;
import com.dy.pipIrrGlobal.pojoRm.RmCommandHistory;
import com.dy.pipIrrRemote.common.dto.DtoBase;
import com.dy.pipIrrRemote.monitor.p202404V201.Cd50Param;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.validation.BindingResult;
import org.springframework.web.client.RestTemplate;

import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

/**
 * @Author: liurunyu
 * @Date: 2025/5/9 14:53
 * @Description
 */
public abstract class ComCtrl {

    @Autowired
    protected Environment env ;

    @Autowired
    protected RestTemplate restTemplate ;

    @Value("${mw.waitMwRtnResultTimeout}")
    protected int waitMwRtnResultTimeout ;

    @Value("${mw.rtuCallbackUrl_rm}")
    protected String rtuResultSendWebUrl;

    //控制器对象
    protected PrController ctrlPo ;
    //异步等待器
    protected CompletableFuture<JSONObject> feature;
    //命令名称
    protected String comName ;
    //命令日志id
    protected Long comId ;

    /**
     * å‘送命令前-1：验证
     * @param comSv
     * @param comCode
     * @param dto
     * @param bindingResult
     * @return
     */
    public BaseResponse<Object> pre1(ComSv comSv, String comCode, DtoBase dto, BindingResult bindingResult) {
        if (bindingResult != null && bindingResult.hasErrors()) {
            return BaseResponseUtils.buildError(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }
        String msg = this.checkDto(dto) ;
        if(msg != null){
            return BaseResponseUtils.buildError("服务端出错，" + msg) ;
        }
        return  null ;
    }

    /**
     * å‘送命令前-2：获得数据
     * @param comSv
     * @param comCode
     * @param dto
     * @param bindingResult
     * @return
     */
    public BaseResponse<Object> pre2(ComSv comSv, String comCode, DtoBase dto, BindingResult bindingResult) {
        //得到控制器对象
        ctrlPo = comSv.getRtu(dto.getIntakeId());
        if (ctrlPo == null) {
            return BaseResponseUtils.buildError("服务端出错，从数据库中未得到控制器数据") ;
        }
        //检查协议
        String msg = comSv.checkProtocol(ctrlPo) ;
        if(msg != null) {
            return BaseResponseUtils.buildError("服务端出错，" + msg) ;
        }
        //得到功能码对应的命令名称
        comName = comSv.getCommandName(comCode, ctrlPo) ;
        if(comName == null) {
            return BaseResponseUtils.buildError("服务端出错，未得到功能码对应命令名称") ;
        }
        return  null ;
    }
    /**
     * å‘送命令前-3：保存命令日志
     * @param comSv sv对象
     * @param intakeId å–水口ID
     * @param operator å½“前用登录用户id(操作人)
     * @param comCode åŠŸèƒ½ç 
     * @param param å‘½ä»¤å‚æ•°
     * @return
     */
    public BaseResponse<Object> pre3(ComSv comSv, Long intakeId, Long operator, String comCode, CdParam param) {
        comId = new IDLongGenerator().generate();
        //生成并保存命令日志
        RmCommandHistory po = comSv.saveComHistoryPo(comId,
                ctrlPo.getProtocol(),
                comCode, comName,
                intakeId,
                ctrlPo.getRtuAddr(),
                param,
                operator);
        if(po == null){
            return BaseResponseUtils.buildError("服务端出错，未能生成并保存命令日志") ;
        }
        return  null ;
    }
    /**
     * å‘送命令前-4：准备Feature
     * @return
     */
    public void pre4() {
        feature = new CompletableFuture<>();
        ComResultWait.put(comId, feature);
    }

    /**
     * å‘送命令
     * @param comSv
     * @param com
     * @return
     */
    public BaseResponse<Object> doSend(ComSv comSv, Command com){
        //得到通信中间件发送命令的web URL
        String rqUrl = comSv.get2MwRequestUrl(env, comSv.ContextComSend) ;
        //向通信中间件发送web请求
        BaseResponse res = comSv.sendPostRequest2Mw(restTemplate, rqUrl, com) ;
        //处理通信中间件对web请求的响应
        String msg = comSv.dealMwDealResponse(res) ;
        if(msg != null) {
            return BaseResponseUtils.buildError(msg) ;
        }else{
            return null ;
        }
    }

    /**
     * å‘送命令后
     * @return
     */
    public BaseResponse<Object> after(String comCode) {
        try{
            //等待通信中间件通知控制器执行命令上行数据（命令结果）
            JSONObject resultData = feature.get(waitMwRtnResultTimeout, TimeUnit.SECONDS);
            return BaseResponseUtils.buildSuccess(this.createRtnMsg(comCode, resultData));
        }catch (Exception e){
            return BaseResponseUtils.buildFail("等待通信中间件通知命令结果超时");
        }
    }

    /**
     * å‘送命令最后
     * @return
     */
    public void end(){
        try {
            //最后清除CompletableFuture缓存
            if(ComResultWait.contain(comId)){
                ComResultWait.remove(comId);
            }
        }catch (Exception ee){}
    }

    /**
     * éªŒè¯
     * @param dto
     * @return
     */
    protected abstract String checkDto(DtoBase dto) ;


    /**
     * ç”Ÿæˆå‘½ä»¤è¿”回信息
     */
    protected abstract String createRtnMsg(String code, JSONObject resultData);
}

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

New file
@@ -0,0 +1,48 @@
package com.dy.pipIrrRemote.monitor.common;

import com.dy.pipIrrGlobal.command.CommandSv;
import com.dy.pipIrrGlobal.daoPr.PrControllerMapper;
import com.dy.pipIrrGlobal.daoRm.RmCommandHistoryMapper;
import com.dy.pipIrrGlobal.pojoPr.PrController;
import com.dy.pipIrrGlobal.pojoRm.RmCommandHistory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

/**
 * @Author: liurunyu
 * @Date: 2025/5/9 14:45
 * @Description
 */
public class ComSv extends CommandSv {

    @Autowired
    protected PrControllerMapper prControllerDao ;
    @Autowired
    protected RmCommandHistoryMapper rmCommandHistoryDao ;

    public PrController getRtu(Long intakeId){
        return this.getRtu(prControllerDao, intakeId);
    }
    /**
     * åˆ›å»ºå‘½ä»¤æ—¥å¿—对象
     *
     * @param comId       ä¸»é”®
     * @param commandCode åŠŸèƒ½ç 
     * @param rtuAddr     é˜€æŽ§å™¨åœ°å€
     * @param protocol    é€šè®¯åè®®åç§°
     * @param param       å‚数数据
     * @param operator    æ“ä½œå‘˜
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public RmCommandHistory saveComHistoryPo(Long comId,
                                             String protocol,
                                             String commandCode,
                                             String commandName,
                                             Long intakeId,
                                             String rtuAddr,
                                             Object param,
                                             Long operator) {
        return this.saveComHistoryPo(rmCommandHistoryDao, comId, protocol, commandCode, commandName, intakeId, rtuAddr, param, operator) ;
    }
}

 pipIrr-platform/pipIrr-web/pipIrr-web-remote/src/main/java/com/dy/pipIrrRemote/monitor/p202404V201/Cd50Ctrl.java

New file
@@ -0,0 +1,108 @@
package com.dy.pipIrrRemote.monitor.p202404V201;

import com.alibaba.fastjson2.JSONObject;
import com.dy.common.aop.SsoAop;
import com.dy.common.mw.protocol.Command;
import com.dy.common.webUtil.BaseResponse;
import com.dy.common.webUtil.BaseResponseUtils;
import com.dy.pipIrrRemote.common.dto.DtoBase;
import com.dy.pipIrrRemote.monitor.common.ComCtrl;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.http.MediaType;
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;

/**
 * @Author: liurunyu
 * @Date: 2025/5/9 14:41
 * @Description
 */
@Slf4j
@Tag(name = "远程透传命令", description = "远程透传命令")
@RestController
@RequestMapping(path = "p202404V201")
@RequiredArgsConstructor
@Scope("prototype") //因为有对象类属性，所以采用原型模式，每次请求新建一个实例对象
public class Cd50Ctrl extends ComCtrl {

    private static final String RtuSuccessMsg = "控制器接收并执行命令成功";

    private static final String ComCode = "50" ;

    @Autowired
    private Cd50Sv sv ;
    /**
     * å‘设备（控制器）发送透传命令
     * @param dto å‰ç«¯å‘来的值对象
     * @param bindingResult å¯¹dto验证的结果
     * @return è¿”回前端
     */
    @PostMapping(path = "cd50", consumes = MediaType.APPLICATION_JSON_VALUE)
    @SsoAop()
    public BaseResponse<Object> send(@RequestBody @Valid Cd50Dto dto, BindingResult bindingResult) {
        BaseResponse<Object> res ;
        //发送命令前-1：验证
        res = super.pre1(sv, ComCode, dto, bindingResult);
        if(res == null) {
            //发送命令前-2：获得数据
            res = super.pre2(sv, ComCode, dto, bindingResult);
            if (res == null) {
                //发送命令前-3：保存命令日志
                Cd50Param comParam = Cd50Param.builder().commandCode(ComCode).build();
                res = super.pre3(sv, dto.getIntakeId(), dto.getOperator(), ComCode, comParam);
                if (res == null) {
                    //发送命令前-4：准备Feature
                    super.pre4();
                    try {
                        //创建外部命令（发给控制器）
                        Command com = sv.createOuterCommand("" + comId, ComCode);
                        com.rtuAddr = ctrlPo.getRtuAddr();
                        com.rtuResultSendWebUrl = rtuResultSendWebUrl;
                        //发送命令
                        res = super.doSend(sv, com);
                        if (res == null) {
                            //发送命令后
                            res = super.after(ComCode);
                        }
                    } catch (Exception e) {
                        res = BaseResponseUtils.buildFail("服务端构造并向通信中间件发送请求时异常" + (e.getMessage() == null ? "" : e.getMessage()));
                    } finally {
                        //最终
                        super.end();
                    }
                }
            }
        }
        return res ;
    }

    @Override
    protected String checkDto(DtoBase dto) {
        return null;
    }

    @Override
    protected String createRtnMsg(String code, JSONObject resultData){
        String msg;
        if(resultData != null){
            JSONObject codeData = resultData.getJSONObject("data") ;
            if(codeData == null){
                return RtuSuccessMsg ;
            }else {
                Integer minute = codeData.getInteger("minute");
                return "查询成功，自报周期：" + minute + "分钟";
            }
        }else{
            msg = RtuSuccessMsg ;
        }
        return msg;
    }
}

 pipIrr-platform/pipIrr-web/pipIrr-web-remote/src/main/java/com/dy/pipIrrRemote/monitor/p202404V201/Cd50Dto.java

New file
@@ -0,0 +1,17 @@
package com.dy.pipIrrRemote.monitor.p202404V201;

import com.dy.pipIrrRemote.common.dto.DtoBase;
import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * @Author: liurunyu
 * @Date: 2025/5/9 14:42
 * @Description
 */

@Data
@EqualsAndHashCode(callSuper=true)
public class Cd50Dto extends DtoBase {
    public static final long serialVersionUID = 202505091450001L;
}

 pipIrr-platform/pipIrr-web/pipIrr-web-remote/src/main/java/com/dy/pipIrrRemote/monitor/p202404V201/Cd50Param.java

New file
@@ -0,0 +1,17 @@
package com.dy.pipIrrRemote.monitor.p202404V201;

import com.dy.pipIrrRemote.monitor.common.CdParam;
import lombok.*;
import lombok.experimental.SuperBuilder;

/**
 * @Author: liurunyu
 * @Date: 2025/5/9 14:43
 * @Description
 */
@Data
@ToString(callSuper = true)
@EqualsAndHashCode(callSuper = true)
@SuperBuilder
public class Cd50Param extends CdParam {
}

 pipIrr-platform/pipIrr-web/pipIrr-web-remote/src/main/java/com/dy/pipIrrRemote/monitor/p202404V201/Cd50Sv.java

New file
@@ -0,0 +1,15 @@
package com.dy.pipIrrRemote.monitor.p202404V201;

import com.dy.pipIrrRemote.monitor.common.ComSv;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

/**
 * @Author: liurunyu
 * @Date: 2025/5/9 14:42
 * @Description
 */
@Slf4j
@Service
public class Cd50Sv extends ComSv {
}

 pipIrr-platform/pipIrr-web/pipIrr-web-statistics/src/main/java/com/dy/pipIrrStatistics/client/ClientSv.java

@@ -3,6 +3,7 @@
import com.dy.common.webUtil.QueryResultVo;
import com.dy.pipIrrGlobal.daoRm.RmClientAmountDayLastMapper;
import com.dy.pipIrrGlobal.daoRm.RmOpenCloseValveHistoryMapper;
import com.dy.pipIrrGlobal.daoSe.SeCardOperateMapper;
import com.dy.pipIrrGlobal.daoSe.SeClientMapper;
import com.dy.pipIrrGlobal.voSt.*;
import com.dy.pipIrrStatistics.card.IcCardqo.CommonQO;

 pipIrr-platform/Îĵµ/´ò°ü·¢²¼/´ò°ü·¢²¼ÅäÖÃÐÞ¸Ä.docx

Binary files differ