1、优化代码； 2、实现新功能：查询RTU设备在通信中间件中的状态。

liurunyu

2024-12-05 267e622c876bea09b61af34fc93cd08b022aa423

 pipIrr-platform/pipIrr-web/pipIrr-web-remote/src/main/java/com/dy/pipIrrRemote/rtu/RtuCtrl.java

@@ -1,21 +1,31 @@
package com.dy.pipIrrRemote.rtu;

import com.alibaba.fastjson2.JSONObject;
import com.dy.common.aop.SsoAop;
import com.dy.common.mw.protocol.Command;
import com.dy.common.multiDataSource.DataSourceContext;
import com.dy.common.mw.protocol.p206V1.CodeV1;
import com.dy.common.mw.protocol.p206V1.ProtocolConstantV206V1;
import com.dy.common.mw.protocol.p206V1.downVos.*;
import com.dy.common.mw.protocol.p206V2.ProtocolConstantV206V2;
import com.dy.common.mw.protocol.p206V202404.CodeV202404;
import com.dy.common.mw.protocol.p206V202404.downVos.ComCd10Vo;
import com.dy.common.mw.protocol.p206V202404.ProtocolConstantV206V202404;
import com.dy.common.mw.protocol.p206V202404.downVos.ComCdXyVo;
import com.dy.common.util.IDLongGenerator;
import com.dy.common.webUtil.BaseResponse;
import com.dy.common.webUtil.BaseResponseUtils;
import com.dy.pipIrrGlobal.pojoRm.RmCommandHistory;
import com.dy.pipIrrRemote.common.ComSupport;
import com.dy.pipIrrGlobal.command.ComSupport;
import com.dy.pipIrrGlobal.command.dto.Param;
import com.dy.pipIrrRemote.common.CommandSv;
import com.dy.pipIrrRemote.common.dto.Alarm;
import com.dy.pipIrrRemote.common.dto.CollectPeriod;
import com.dy.pipIrrRemote.common.dto.CommandGet;
import com.dy.pipIrrRemote.common.dto.Domain;
import com.dy.pipIrrRemote.result.RemoteResultCode;
import com.dy.pipIrrRemote.rtu.dto.Addr;
import com.dy.pipIrrRemote.rtu.dto.DtoBase;
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.http.MediaType;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.BindingResult;
@@ -36,81 +46,361 @@
@Slf4j
@RestController
@RequestMapping(path="rtu")
@RequiredArgsConstructor
//@RequiredArgsConstructor
public class RtuCtrl extends ComSupport {
    private final CommandSv commandSv;
    private final IDLongGenerator idLongGenerator;

    protected static String controllerType = "57";
    @Value("${mw.rtuCallbackUrl_rm}")
    private String rtuCallbackUrl_rm;

    /**
     * 设置设备终端地址
     * @param addr 设置设备终端地址传入对象
     * pro_mw：属性
     * tag从控制器中获取
     * key_mw：url的key
     */
    private Environment env = null;
    private String pro_mw = "mw";
    private String key_mw = "comSendUrl";

    @Autowired
    public RtuCtrl(CommandSv commandSv, IDLongGenerator idLongGenerator, Environment env) {
        this.commandSv = commandSv;
        this.idLongGenerator = idLongGenerator;
        this.env = env;
    }

    /**
     * 通用查询接口
     * p206V1
     *   66     查询IP和端口
     *   67     查询流量采集周期
     *   68     查询用户余额报警值
     *   69     查询电池电压报警值
     *   6A     查询阀门堵转电流值
     *   6B     查询阀门超时时间
     * @param po    查询传入对象
     * @param bindingResult
     * @return 查询结果
     */
    @PostMapping(path = "common_get", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop()
    public BaseResponse<Boolean> commonGet(@RequestBody @Valid CommandGet po, BindingResult bindingResult) {
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        Long intakeId = po.getIntakeId();
        Long operator = po.getOperator();
        Long comId = idLongGenerator.generate();

        // 取水口ID换阀控器地址及通讯协议
        JSONObject job_rtu = getRtu(intakeId, null);
        if(job_rtu == null) {
            return BaseResponseUtils.buildErrorMsg(RemoteResultCode.RTU_NOT_EXIST.getMessage());
        }
        String rtuAddr = job_rtu.getString("rtuAddr");
        String protocol = job_rtu.getString("protocol");
        //String orgTag = job_rtu.getString("orgTag");
        String orgTag = DataSourceContext.get();
        comSendUrl = env.getProperty(pro_mw + "." + orgTag + "." + key_mw);

        // 获取功能码
        String commandCode = po.getCommandCode();
        if(protocol.equals(ProtocolConstantV206V202404.protocolName)) {
            // 创建视图
            ComCdXyVo param = new ComCdXyVo();
            param.controllerType = controllerType;
            param.projectNo = projectNo;

            /**
             * 构造命令、发送命令并处理请求结果及执行结果
             * 1 准备参数
             * 2 调用公共方法
             */
            Param myParam = new Param();
            myParam.setComId(comId);
            myParam.setCommandCode(commandCode);
            myParam.setCommandName(CodeV202404.getCodeName(commandCode));
            myParam.setIntakeId(intakeId);
            myParam.setRtuAddr(rtuAddr);
            myParam.setProtocol(protocol);
            myParam.setParam(param);
            myParam.setRtuResultSendWebUrl(rtuCallbackUrl_rm);
            myParam.setOperator(operator);
            return dealWithCommandResult(myParam);
        } else if(protocol.equals(ProtocolConstantV206V1.protocolName) || protocol.equals(ProtocolConstantV206V2.protocolName)) {
            // 创建视图
            ComXyVo param = new ComXyVo();
            param.setCommandCode(commandCode);

            /**
             * 构造命令、发送命令并处理请求结果及执行结果
             * 1 准备参数
             * 2 调用公共方法
             */
            Param myParam = new Param();
            myParam.setComId(comId);
            myParam.setComType((byte)2);
            myParam.setCommandCode(commandCode);
            myParam.setCommandName(CodeV1.getCodeName(commandCode));
            myParam.setIntakeId(intakeId);
            myParam.setRtuAddr(rtuAddr);
            myParam.setProtocol(protocol);
            //myParam.setVcId(vcId);
            myParam.setParam(param);
            myParam.setRtuResultSendWebUrl(rtuCallbackUrl_rm);
            myParam.setOperator(operator);
            return dealWithCommandResult(myParam);
        } else {
            return BaseResponseUtils.buildFail("系统暂不支持该协议");
        }
    }

    /**
     * 设置流量采集周期
     * @param po
     * @param bindingResult
     * @return
     */
    @PostMapping(path = "set_addr", consumes = MediaType.APPLICATION_JSON_VALUE)
    @PostMapping(path = "set_collect_period", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop()
    public BaseResponse<Boolean> setAddr(@RequestBody @Valid Addr addr, BindingResult bindingResult) {
    public BaseResponse<Boolean> setCollectPeriod(@RequestBody @Valid CollectPeriod po, BindingResult bindingResult) {
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        String commandCode = CodeV202404.cd_10;
        Long intakeId = addr.getIntakeId();
        String newRtuAddr = addr.getNewRtuAddr();
        Long operator = addr.getOperator();

        // 取水口ID换阀控器地址
        String rtuAddr = commandSv.getRtuAddrByIntakeId(intakeId);
        if(rtuAddr == null || rtuAddr.length() == 0) {
            return BaseResponseUtils.buildError(RemoteResultCode.RTU_ADDR_CANNOT_BE_NULL.getMessage());
        }

        // 创建视图
        ComCd10Vo param = new ComCd10Vo() ;
        param.controllerType = controllerType;
        param.projectNo = Integer.parseInt(commandCode);
        param.rtuNewAddr = newRtuAddr;

        // 创建命令日志对象并添加到数据库中
        RmCommandHistory rmCommandHistory = getComHistory(commandCode, rtuAddr, param, operator);
        String comId = commandSv.insert(rmCommandHistory);

        // 构造命令
        Command com = command(comId, commandCode, rtuAddr, param);
        return sendCom2Mw(com);
    }

    @PostMapping(path = "clear_usage_record", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop()
    public BaseResponse<Boolean> clearUsageRecord(@RequestBody @Valid DtoBase po, BindingResult bindingResult) {
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        String commandCode = CodeV202404.cd_97;
        Long intakeId = po.getIntakeId();
        Long operator = po.getOperator();
        Long comId = idLongGenerator.generate();

        // 取水口ID换阀控器地址
        String rtuAddr = commandSv.getRtuAddrByIntakeId(intakeId);
        if(rtuAddr == null || rtuAddr.length() == 0) {
            return BaseResponseUtils.buildError(RemoteResultCode.RTU_ADDR_CANNOT_BE_NULL.getMessage());
        // 取水口ID换阀控器地址及通讯协议
        JSONObject job_rtu = getRtu(intakeId, null);
        if(job_rtu == null) {
            return BaseResponseUtils.buildErrorMsg(RemoteResultCode.RTU_NOT_EXIST.getMessage());
        }
        String rtuAddr = job_rtu.getString("rtuAddr");
        String protocol = job_rtu.getString("protocol");
        //String orgTag = job_rtu.getString("orgTag");
        String orgTag = DataSourceContext.get();
        comSendUrl = env.getProperty(pro_mw + "." + orgTag + "." + key_mw);

        // 获取功能码
        String commandCode = po.getCommandCode();
        if(protocol.equals(ProtocolConstantV206V202404.protocolName)) {
            return BaseResponseUtils.buildSuccess("");
        } else if(protocol.equals(ProtocolConstantV206V1.protocolName) || protocol.equals(ProtocolConstantV206V2.protocolName)) {
            // 创建视图
            Com37Vo param = new Com37Vo();
            param.setSeconds(po.getSeconds());

            /**
             * 构造命令、发送命令并处理请求结果及执行结果
             * 1 准备参数
             * 2 调用公共方法
             */
            Param myParam = new Param();
            myParam.setComId(comId);
            myParam.setComType((byte)2);
            myParam.setCommandCode(commandCode);
            myParam.setCommandName(CodeV1.getCodeName(commandCode));
            myParam.setIntakeId(intakeId);
            myParam.setRtuAddr(rtuAddr);
            myParam.setProtocol(protocol);
            //myParam.setVcId(vcId);
            myParam.setParam(param);
            myParam.setRtuResultSendWebUrl(rtuCallbackUrl_rm);
            myParam.setOperator(operator);
            return dealWithCommandResult(myParam);
        } else {
            return BaseResponseUtils.buildFail("系统暂不支持该协议");
        }
    }

    /**
     * 设置服务端IP和端口
     * @param po
     * @param bindingResult
     * @return
     */
    @PostMapping(path = "set_ip_port", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop()
    public BaseResponse<Boolean> setIpPort(@RequestBody @Valid Domain po, BindingResult bindingResult) {
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        // 创建视图
        ComCdXyVo param = new ComCdXyVo();
        param.controllerType = controllerType;
        param.projectNo = Integer.parseInt(commandCode);
        Long intakeId = po.getIntakeId();
        Long operator = po.getOperator();
        Long comId = idLongGenerator.generate();

        // 创建命令日志对象并添加到数据库中
        RmCommandHistory rmCommandHistory = getComHistory(commandCode, rtuAddr, param, operator);
        String comId = commandSv.insert(rmCommandHistory);
        // 取水口ID换阀控器地址及通讯协议
        JSONObject job_rtu = getRtu(intakeId, null);
        if(job_rtu == null) {
            return BaseResponseUtils.buildErrorMsg(RemoteResultCode.RTU_NOT_EXIST.getMessage());
        }
        String rtuAddr = job_rtu.getString("rtuAddr");
        String protocol = job_rtu.getString("protocol");
        //String orgTag = job_rtu.getString("orgTag");
        String orgTag = DataSourceContext.get();
        comSendUrl = env.getProperty(pro_mw + "." + orgTag + "." + key_mw);

        // 构造命令
        Command com = command(comId, commandCode, rtuAddr, param);
        return sendCom2Mw(com);
        // 获取功能码
        String commandCode = po.getCommandCode();
        if(protocol.equals(ProtocolConstantV206V202404.protocolName)) {
            return BaseResponseUtils.buildSuccess("");
        } else if(protocol.equals(ProtocolConstantV206V1.protocolName) || protocol.equals(ProtocolConstantV206V2.protocolName)) {
            // 创建视图
            Com21Vo param = new Com21Vo();
            param.setIp(po.getIp());
            param.setPort(po.getPort());

            /**
             * 构造命令、发送命令并处理请求结果及执行结果
             * 1 准备参数
             * 2 调用公共方法
             */
            Param myParam = new Param();
            myParam.setComId(comId);
            myParam.setComType((byte)2);
            myParam.setCommandCode(commandCode);
            myParam.setCommandName(CodeV1.getCodeName(commandCode));
            myParam.setIntakeId(intakeId);
            myParam.setRtuAddr(rtuAddr);
            myParam.setProtocol(protocol);
            //myParam.setVcId(vcId);
            myParam.setParam(param);
            myParam.setRtuResultSendWebUrl(rtuCallbackUrl_rm);
            myParam.setOperator(operator);
            return dealWithCommandResult(myParam);
        } else {
            return BaseResponseUtils.buildFail("系统暂不支持该协议");
        }
    }

    /**
     * 设置用户余额报警值
     * @param po
     * @param bindingResult
     * @return
     */
    @PostMapping(path = "set_remain_money_alarm", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop()
    public BaseResponse<Boolean> setRemainMoneyAlarm(@RequestBody @Valid Alarm po, BindingResult bindingResult) {
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        Long intakeId = po.getIntakeId();
        Long operator = po.getOperator();
        Long comId = idLongGenerator.generate();

        // 取水口ID换阀控器地址及通讯协议
        JSONObject job_rtu = getRtu(intakeId, null);
        if(job_rtu == null) {
            return BaseResponseUtils.buildErrorMsg(RemoteResultCode.RTU_NOT_EXIST.getMessage());
        }
        String rtuAddr = job_rtu.getString("rtuAddr");
        String protocol = job_rtu.getString("protocol");
        //String orgTag = job_rtu.getString("orgTag");
        String orgTag = DataSourceContext.get();
        comSendUrl = env.getProperty(pro_mw + "." + orgTag + "." + key_mw);

        // 获取功能码
        String commandCode = po.getCommandCode();
        if(protocol.equals(ProtocolConstantV206V202404.protocolName)) {
            return BaseResponseUtils.buildSuccess("");
        } else if(protocol.equals(ProtocolConstantV206V1.protocolName) || protocol.equals(ProtocolConstantV206V2.protocolName)) {
            // 创建视图
            Com38Vo param = new Com38Vo();
            param.setRemainMoneyAlarm(po.getRemainMoneyAlarm());

            /**
             * 构造命令、发送命令并处理请求结果及执行结果
             * 1 准备参数
             * 2 调用公共方法
             */
            Param myParam = new Param();
            myParam.setComId(comId);
            myParam.setComType((byte)2);
            myParam.setCommandCode(commandCode);
            myParam.setCommandName(CodeV1.getCodeName(commandCode));
            myParam.setIntakeId(intakeId);
            myParam.setRtuAddr(rtuAddr);
            myParam.setProtocol(protocol);
            //myParam.setVcId(vcId);
            myParam.setParam(param);
            myParam.setRtuResultSendWebUrl(rtuCallbackUrl_rm);
            myParam.setOperator(operator);
            return dealWithCommandResult(myParam);
        } else {
            return BaseResponseUtils.buildFail("系统暂不支持该协议");
        }
    }

    /**
     * 设置电池电压报警值
     * @param po
     * @param bindingResult
     * @return
     */
    @PostMapping(path = "set_battery_volt_alarm", consumes = MediaType.APPLICATION_JSON_VALUE)
    @Transactional(rollbackFor = Exception.class)
    @SsoAop()
    public BaseResponse<Boolean> setBatteryVoltAlarm(@RequestBody @Valid Alarm po, BindingResult bindingResult) {
        if(bindingResult != null && bindingResult.hasErrors()){
            return BaseResponseUtils.buildFail(Objects.requireNonNull(bindingResult.getFieldError()).getDefaultMessage());
        }

        Long intakeId = po.getIntakeId();
        Long operator = po.getOperator();
        Long comId = idLongGenerator.generate();

        // 取水口ID换阀控器地址及通讯协议
        JSONObject job_rtu = getRtu(intakeId, null);
        if(job_rtu == null) {
            return BaseResponseUtils.buildErrorMsg(RemoteResultCode.RTU_NOT_EXIST.getMessage());
        }
        String rtuAddr = job_rtu.getString("rtuAddr");
        String protocol = job_rtu.getString("protocol");
        //String orgTag = job_rtu.getString("orgTag");
        String orgTag = DataSourceContext.get();
        comSendUrl = env.getProperty(pro_mw + "." + orgTag + "." + key_mw);

        // 获取功能码
        String commandCode = po.getCommandCode();
        if(protocol.equals(ProtocolConstantV206V202404.protocolName)) {
            return BaseResponseUtils.buildSuccess("");
        } else if(protocol.equals(ProtocolConstantV206V1.protocolName) || protocol.equals(ProtocolConstantV206V2.protocolName)) {
            // 创建视图
            Com39Vo param = new Com39Vo();
            param.setBatteryVoltAlarm(po.getBatteryVoltAlarm());

            /**
             * 构造命令、发送命令并处理请求结果及执行结果
             * 1 准备参数
             * 2 调用公共方法
             */
            Param myParam = new Param();
            myParam.setComId(comId);
            myParam.setComType((byte)2);
            myParam.setCommandCode(commandCode);
            myParam.setCommandName(CodeV1.getCodeName(commandCode));
            myParam.setIntakeId(intakeId);
            myParam.setRtuAddr(rtuAddr);
            myParam.setProtocol(protocol);
            //myParam.setVcId(vcId);
            myParam.setParam(param);
            myParam.setRtuResultSendWebUrl(rtuCallbackUrl_rm);
            myParam.setOperator(operator);
            return dealWithCommandResult(myParam);
        } else {
            return BaseResponseUtils.buildFail("系统暂不支持该协议");
        }
    }

}