liusheng
2025-02-19 a0e46d75fd50924c8e9ac0cf24a8daa0471bbed2
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
package com.smartor.common;
 
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ruoyi.common.utils.http.HttpUtils;
import com.smartor.domain.*;
import com.smartor.mapper.PatWildcardMapper;
import com.smartor.service.DingTalkService;
import com.smartor.service.ISmsParamService;
import com.smartor.service.WeChatService;
import com.smartor.service.impl.BaseSmsaccountServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
 
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
/**
 * 发送服务工具类
 */
@Slf4j
@Component
public class SendService {
    @Autowired
    private BaseSmsaccountServiceImpl baseSmsaccountService;
 
    @Autowired
    private DingTalkService dingTalkService;
 
    @Autowired
    private PatWildcardMapper patWildcardMapper;
 
    @Autowired
    private WeChatService weChatService;
 
    @Autowired
    ISmsParamService iSmsParamService;
 
    @Value("${xhsmsPath}")
    private String xhsmsPath;
    // 帐号
    @Value("${xhsmsAccount}")
    private String xhsmsAccount;
    //  接口密码
    @Value("${xhsmsPwd}")
    private String xhsmsPwd;
    // 虚拟接入码
    @Value("${xhsmsjrm}")
    private String xhsmsjrm;
 
    public Boolean sendMsg(SendMagParam sendMagParam) throws UnsupportedEncodingException, JsonProcessingException {
        // 1,多媒体 2,纸质  3,电话  4,短信  5.微信公众号 6.微信小程序 7.支付宝  8.智能小程序  9.钉钉
        switch (sendMagParam.getType()) {
            case ("1"):
 
            case ("2"):
 
            case ("3"):
 
            case ("4"):
                //短信
                Map<String, String> map2 = new HashMap<>();
                map2.put("action", "send");
                map2.put("account", xhsmsAccount);
                map2.put("password", xhsmsPwd);
                map2.put("mobile", sendMagParam.getPhone());
                map2.put("content", sendMagParam.getContent());
                map2.put("extno", xhsmsjrm);
                map2.put("rt", "json");
                StringBuilder encodedParams = new StringBuilder();
 
                for (Map.Entry<String, String> entry : map2.entrySet()) {
                    if (encodedParams.length() > 0) {
                        encodedParams.append("&");
                    }
                    // 对键和值进行URL编码
                    String encodedKey = URLEncoder.encode(entry.getKey(), "UTF-8");
                    String encodedValue = URLEncoder.encode(entry.getValue(), "UTF-8");
                    encodedParams.append(encodedKey).append("=").append(encodedValue);
                }
 
                String result = HttpUtils.sendPost(xhsmsPath, encodedParams.toString());
                ObjectMapper objectMapper2 = new ObjectMapper();
                Map<String, Object> map3 = objectMapper2.readValue(result, new TypeReference<Map<String, Object>>() {
                });
                if (ObjectUtils.isNotEmpty(map3)) {
                    String status = map3.get("status").toString();
                    if (status.equals("0")) {
                        return true;
                    }
                }
                log.error("短信发送失败map:{},  返回的信息为:{}", map2, result);
                return false;
            case ("5"):
                //公众号
//                String params = "service=smarthos.yygh.ApiService.push&idcard=" + sendMagParam.getIdcard() + "&url=" + sendMagParam.getUrl() + "&keyword1=null&keyword2=null&keyword3=null&keyword4=null";
//                String result = HttpUtils.sendPost("/api", params);
//                JSONObject jsonObject = JSONObject.parseObject(result);
//                String code = (String) jsonObject.get("code");
//                if (!code.equals(0)) {
//                    log.error("微信公众号消息发送失败了:{}", sendMagParam);
//                    return false;
//                }
//                 return true;
 
                WeChatSendVo weChatSendVo = new WeChatSendVo();
                weChatSendVo.setUrl(sendMagParam.getUrl());
                weChatSendVo.setTemplateId(sendMagParam.getTmpCode());
                ObjectMapper objectMapper = new ObjectMapper();
                Map map = null;
                try {
                    map = objectMapper.readValue(sendMagParam.getContent(), Map.class);
                } catch (JsonProcessingException e) {
                    e.printStackTrace();
                }
                weChatSendVo.setContent(map);
                weChatSendVo.setOpenid(sendMagParam.getOpenid());
                Boolean aBoolean1 = weChatService.sendMessageToFollowers(weChatSendVo);
                return aBoolean1;
            case ("6"):
 
            case ("7"):
 
            case ("8"):
 
            case ("9"):
                DingTalkReqVo dingTalkReqVo = new DingTalkReqVo();
                Boolean aBoolean = dingTalkService.sendNotification(dingTalkReqVo);
                if (aBoolean) {
                    return true;
                }
            default:
                return false;
        }
 
    }
 
    /**
     * 对问题中的通配符进行匹配
     *
     * @param script
     * @param patArchive
     * @return
     */
    public String patWildcard(String script, PatArchive patArchive) {
        List<PatWildcard> patWildcards = patWildcardMapper.selectPatWildcardList(new PatWildcard());
        for (PatWildcard patWildcard : patWildcards) {
            try {
                //获取患者对应的字段的值
                Field field = patArchive.getClass().getField(patWildcard.getPatField());
                field.setAccessible(true);
                String value = field.get(patArchive).toString();
                //将问题中的通配符进行替换
                script.replaceAll(patWildcard.getWildcard(), value);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
 
        return script;
    }
}