zhubaomin
2 天以前 b2abd25927c39e849e592f1abdc08879d8d35245
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
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.CommandBackParam;
import com.dy.common.mw.protocol.p206V1.CodeV1;
import com.dy.common.mw.protocol.p206V1.ProtocolConstantV206V1;
import com.dy.common.mw.protocol.p206V2.CodeV2;
import com.dy.common.mw.protocol.p206V2.ProtocolConstantV206V2;
import com.dy.common.mw.protocol.p206V202404.CodeV202404;
import com.dy.common.mw.protocol.p206V202404.ProtocolConstantV206V202404;
import com.dy.common.webUtil.BaseResponse;
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.pipIrrGlobal.rtuMw.Web2RtuMw;
 
import java.util.Date;
 
/**
 * @Author: liurunyu
 * @Date: 2025/5/6 11:41
 * @Description
 */
public class CommandSv extends Web2RtuMw {
 
 
    /**
     * 从数据库中查询控制器对象
     * @param prControllerDao
     * @param intakeId
     * @return
     */
    public PrController getRtu(PrControllerMapper prControllerDao, Long intakeId){
        return prControllerDao.getRtu(intakeId, null);
    }
 
    /**
     * 检查协议是否支持
     * @param ctrlPo
     * @return
     */
    public String checkProtocol(PrController ctrlPo){
        if(!ctrlPo.getProtocol().equals(ProtocolConstantV206V1.protocolName)
                && !ctrlPo.getProtocol().equals(ProtocolConstantV206V2.protocolName)
                && !ctrlPo.getProtocol().equals(ProtocolConstantV206V202404.protocolName)) {
            return "对应控制器协议" + ctrlPo.getProtocol() + "未实现命令发送逻辑" ;
        }
        return null ;
    }
 
    /**
     * 根据协议获取命令名称
     * @param nowComCode
     * @param ctrlPo
     * @return
     */
    public String getCommandName(String nowComCode, PrController ctrlPo){
        if(ctrlPo.getProtocol().equals(ProtocolConstantV206V1.protocolName)) {
            return CodeV1.getCodeName(nowComCode) ;
        }else if(ctrlPo.getProtocol().equals(ProtocolConstantV206V2.protocolName)) {
            return CodeV2.getCodeName(nowComCode) ;
        }else if(ctrlPo.getProtocol().equals(ProtocolConstantV206V202404.protocolName)) {
            return CodeV202404.getCodeName(nowComCode) ;
        }
        return null ;
    }
 
    /**
     * 保存命令历史记录
     * @param rmCommandHistoryDao
     * @param comId
     * @param protocol
     * @param commandCode
     * @param commandName
     * @param intakeId
     * @param rtuAddr
     * @param param
     * @param operator
     * @return
     */
    public RmCommandHistory saveComHistoryPo(RmCommandHistoryMapper rmCommandHistoryDao,
                                             Long comId,
                                             String protocol,
                                             String commandCode,
                                             String commandName,
                                             Long intakeId,
                                             String rtuAddr,
                                             Object param,
                                             Long operator) {
        RmCommandHistory po = new RmCommandHistory();
        po.setComId(comId);
        po.setCommandCode(commandCode);
        po.setCommandName(commandName);
        po.setIntakeId(intakeId);
        po.setRtuAddr(rtuAddr);
        po.setProtocol(protocol);
        po.setParam((JSONObject) JSON.toJSON(param));
        po.setSendTime(new Date());
        po.setOperator(operator);
        rmCommandHistoryDao.insertSelective(po) ;
        return po;
    }
 
    /**
     * 处理通信中间件返回的命令处理结果
     * @param res
     * @return
     */
    public String dealMwDealResponse(BaseResponse res){
        if(res != null){
            Command reCom = JSON.parseObject(res.getContent() == null ? null : JSON.toJSONString(res.getContent()), Command.class) ;
            CommandBackParam bakParam = JSON.parseObject((reCom== null || reCom.param == null) ? null : JSON.toJSONString(reCom.param), CommandBackParam.class) ;
            if(res.isSuccess()){
                if(bakParam != null){
                    if(bakParam.getSuccess().booleanValue()){
                        //通信中间件成功处理了命令
                        //等待控制器接收并执行命令后的应答,然后通信中间件通知本模块
                        return null ;
                    }else{
                        return "通信中间件处理命令失败,失败信息:" + bakParam.getMessage();
                    }
                }else{
                    return "通信中间件返回命令结果中不包含CommandBackParam类型参数";
                }
            }else{
                if(bakParam != null){
                    if(bakParam.getSuccess().booleanValue()){
                        //通信中间件成功处理了命令
                        //等待控制器接收并执行命令后的应答,然后通信中间件通知本模块
                        return "通信中间件处理命令失败,失败信息:" + (res.getMsg() == null? "" : ("," + res.getMsg())) ;
                    }else{
                        return "通信中间件处理命令失败,失败信息:" + bakParam.getMessage();
                    }
                }else{
                    return "通信中间件处理命令失败,失败信息:" + (res.getMsg() == null? "" : ("," + res.getMsg())) ;
                }
            }
        }else{
            return "通信中间件返回命令结果为null";
        }
    }
 
}