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

liurunyu

2024-06-11 2e914bc2c2fc2fae4803b4c3b6483e205e4eb8a5

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

New file
@@ -0,0 +1,293 @@
package com.dy.pipIrrGlobal.command;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.dy.common.mw.protocol.Command;
import com.dy.common.mw.protocol.CommandType;
import com.dy.common.mw.protocol.Data;
import com.dy.common.mw.protocol.p206V202404.CodeV202404;
import com.dy.common.webUtil.BaseResponse;
import com.dy.common.webUtil.BaseResponseUtils;
import com.dy.pipIrrGlobal.command.dto.Param;
import com.dy.pipIrrGlobal.command.result.CommandResultCode;
import com.dy.pipIrrGlobal.daoBa.BaSettingsMapper;
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 jakarta.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponentsBuilder;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * @author ZhuBaoMin
 * @date 2024-05-30 15:45
 * @LastEditTime 2024-05-30 15:45
 * @Description 命令支撑类
 */

//@Component
//@DependsOn({"baSettingsMapper", "prControllerMapper"})
public class ComSupport {
    protected static String mwUrlSendCom = "http://127.0.0.1:8070/rtuMw/com/send" ;

    protected static String controllerType = null;
    protected static Integer projectNo = null;
    protected String commandTypeOuter = CommandType.outerCommand;

    // 存储实例化的 CompletableFuture<Data> 对象
    protected static Map<Long, Object> features = new HashMap<>();
    protected static Boolean setuped = false;

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private BaSettingsMapper baSettingsMapper;

    @Autowired
    private PrControllerMapper prControllerMapper;

    //@Autowired
    //private CommandSv commandSv;

    @Autowired
    private RmCommandHistoryMapper rmCommandHistoryMapper;

    public static ComSupport comSupport;

    /**
     * 引入BaSettingsMapper
     */
    @PostConstruct
    public void init() {
        comSupport = this;
        comSupport.baSettingsMapper = this.baSettingsMapper;
        comSupport.prControllerMapper = this.prControllerMapper;
    }

    /**
     * 获取系统配置参数
     */
    public void setUp() {
        controllerType = comSupport.baSettingsMapper.getItemValue("controllerType");
        projectNo = Integer.parseInt(comSupport.baSettingsMapper.getItemValue("projectNo"));
        setuped = true;
    }

    /**
     * 生成订单号
     * @return
     */
    public String generateOrderNo() {
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyMMddHHmmss");
        LocalDateTime dateTime = LocalDateTime.now();
        Random random = new Random();
        String CHARACTERS = "0123456789";
        StringBuilder sb = new StringBuilder(4);
        for (int i = 0; i < 4; i++) {
            int index = random.nextInt(CHARACTERS.length());
            sb.append(CHARACTERS.charAt(index));
        }
        return dtf.format(dateTime) + sb.toString();
    }

    /**
     * 根据取水口ID或阀控器地址获取阀控器对象
     * @param intakeId
     * @return
     */
    public JSONObject getRtu(Long intakeId, String rtuAddr) {
        PrController prController = prControllerMapper.getRtu(intakeId, rtuAddr);
        if(prController == null) {
            return null;
        }
        JSONObject job_rtu = new JSONObject();
        job_rtu.put("rtuAddr", prController.getRtuAddr());
        job_rtu.put("protocol", prController.getProtocol());
        job_rtu.put("intakeId", prController.getIntakeId());

        return job_rtu;
    }

    /**
     * 创建命令日志对象
     * @param comId 主键
     * @param commandCode 功能码
     * @param rtuAddr 阀控器地址
     * @param protocol 通讯协议名称
     * @param param 参数数据
     * @param operator 操作员
     * @return
     */
    protected RmCommandHistory getComHistory(Long comId, String commandCode, String commandName, Long intakeId, String rtuAddr, String protocol, Object param, Long operator ) {
        RmCommandHistory rmCommandHistory = new RmCommandHistory();
        rmCommandHistory.setId(comId);
        rmCommandHistory.setCommandCode(commandCode);
        //rmCommandHistory.setCommandName(CodeV202404.getCodeName(commandCode));
        rmCommandHistory.setCommandName(commandName);
        rmCommandHistory.setIntakeId(intakeId);
        rmCommandHistory.setRtuAddr(rtuAddr);
        rmCommandHistory.setProtocol(protocol);
        rmCommandHistory.setParam((JSONObject) JSON.toJSON(param));
        rmCommandHistory.setSendTime(new Date());
        rmCommandHistory.setOperator(operator);
        return rmCommandHistory;
    }

    /**
     * 构造命令对象
     * @param comId 命令ID
     * @param commandCode 功能码
     * @param rtuAddr RTU地址
     * @param param 参数数据
     * @return 构造好的命令对象
     */
    protected Command command(Long comId, String commandCode, String rtuAddr, String protocol, String rtuResultSendWebUrl, Object param){
        Command com = new Command() ;
        com.id = String.valueOf(comId);
        com.code = commandCode ;
        com.rtuAddr = rtuAddr ;

        com.protocol = protocol;
        com.type = commandTypeOuter;
        com.rtuResultSendWebUrl = rtuResultSendWebUrl ;

        com.param = param ;

        return com ;
    }

    /**
     * 处理回调内容
     * @param comId
     * @return
     */
    protected BaseResponse<Data> dealWithCallBack(Long comId) {
        CompletableFuture<Data> featureObject = new CompletableFuture<>();
        features.put(comId, featureObject);
        try {
            CompletableFuture<Data> feature = (CompletableFuture<Data>) features.get(comId);
            System.out.println("receive result ID:" + comId);
            Data resultData = feature.get(30, TimeUnit.SECONDS);
            features.remove(comId);
            Long commandId = Long.parseLong(resultData.getCommandId());
            if(commandId.equals(comId)) {
                return BaseResponseUtils.buildSuccess(resultData);
            }else {
                return BaseResponseUtils.buildSuccess();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            return BaseResponseUtils.buildFail(CommandResultCode.GET_RESULT_ERROR.getMessage());
        } catch (ExecutionException e) {
            e.printStackTrace();
            return BaseResponseUtils.buildFail(CommandResultCode.GET_RESULT_ERROR.getMessage());
        } catch (TimeoutException e) {
            return BaseResponseUtils.buildSuccess(CommandResultCode.GET_RESULT_IN_ONE_MINUTE.getMessage());
        }
    }

    /**
     * 发送命令
     * @return
     */
    protected BaseResponse sendCom2Mw(Command com){
        String url = UriComponentsBuilder.fromUriString(mwUrlSendCom)
                .build()
                .toUriString();
        HttpHeaders headers = new HttpHeaders();
        HttpEntity<Command> httpEntity = new HttpEntity<>(com, headers);
        ResponseEntity<BaseResponse> response = null;
        try {
            // 通过Post方式调用接口
            response = restTemplate.exchange(url, HttpMethod.POST, httpEntity, BaseResponse.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return response.getBody();
    }

    /**
     * 发送命令并处理请求结果及执行结果
     * @param po
     * @return
     */
    protected BaseResponse dealWithCommandResult(Param po) {
        Long comId = po.getComId();
        String commandCode = po.getCommandCode();
        Long intakeId = po.getIntakeId();
        String rtuAddr = po.getRtuAddr();
        String protocol = po.getProtocol();
        Object param = po.getParam();
        String rtuResultSendWebUrl = po.getRtuResultSendWebUrl();
        Long operator = po.getOperator();

        // 构造命令
        Command com = command(comId, commandCode, rtuAddr, protocol, rtuResultSendWebUrl, param);

        // 发送命令
        JSONObject response_SendCom= (JSONObject) JSON.toJSON(sendCom2Mw(com));
        if(response_SendCom != null && response_SendCom.getString("code").equals("0001")) {
            //if(1 > 0) {
            // 请求成功

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

            // 处理回调
            BaseResponse response_CallBack = dealWithCallBack(comId);

            // 回调失败
            if(!response_CallBack.getCode().equals("0001")) {
                // 命令日志执行结果改为失败
                rmCommandHistory = new RmCommandHistory();
                rmCommandHistory.setId(comId);
                rmCommandHistory.setResult((byte)0);
                //commandSv.updateCommandResult(rmCommandHistory);
                rmCommandHistoryMapper.updateByPrimaryKeySelective(rmCommandHistory);
                return BaseResponseUtils.buildFail(response_CallBack.getMsg());
                //return BaseResponseUtils.buildFail(response_CallBack.getContent().toString());
            }

            // 回调成功，再判断执行是否成功
            JSONObject job_content = (JSONObject)JSON.toJSON(response_CallBack.getContent());
            System.out.println(job_content);
            JSONObject job_subData = (JSONObject) job_content.getJSONObject("subData").getJSONObject("subData");
            System.out.println(job_subData);
            Boolean dealResult = job_subData.getBoolean("success");
            if(!dealResult) {
                return BaseResponseUtils.buildFail(response_CallBack.getContent().toString());
            }

            /**
             * 执行成功，返回回调内容
             */
            Data myData = (Data)response_CallBack.getContent();
            return BaseResponseUtils.buildSuccess(myData) ;
        } else {
            // 请求失败
            JSONObject job_param = response_SendCom.getJSONObject("content").getJSONObject("param");
            return BaseResponseUtils.buildFail(job_param.getString("message"));
        }
    }
}