bug
zhangzeli
2022-01-25 e31d4d2d3cecab2fb56508c0f5b82d821719e7bb
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
package cn.exrick.xboot.core.serviceimpl;
 
import cn.exrick.xboot.core.common.constant.CommonConstant;
import cn.exrick.xboot.core.common.exception.XbootException;
import cn.exrick.xboot.core.dao.MessageDao;
import cn.exrick.xboot.core.dao.MessageSendDao;
import cn.exrick.xboot.core.entity.Message;
import cn.exrick.xboot.core.entity.MessageSend;
import cn.exrick.xboot.core.service.MessageSendService;
import cn.hutool.core.util.StrUtil;
import com.google.gson.Gson;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.lang.Nullable;
import org.springframework.messaging.simp.SimpMessagingTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import javax.persistence.criteria.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
 
/**
 * 消息发送接口实现
 * @author Exrick
 */
@Slf4j
@Service
@Transactional
public class MessageSendServiceImpl implements MessageSendService {
 
    @Autowired
    private MessageDao messageDao;
 
    @Autowired
    private MessageSendDao messageSendDao;
 
    @Autowired
    private SimpMessagingTemplate messagingTemplate;
 
    @Override
    public MessageSendDao getRepository() {
        return messageSendDao;
    }
 
    @Override
    public MessageSend send(MessageSend messageSend) {
 
        MessageSend ms = messageSendDao.save(messageSend);
        messagingTemplate.convertAndSendToUser(messageSend.getUserId(), "/queue/subscribe", "您收到了新的消息");
        return ms;
    }
 
    @Override
    public void deleteByMessageId(String messageId) {
 
        messageSendDao.deleteByMessageId(messageId);
    }
 
    @Override
    public Page<MessageSend> findByCondition(MessageSend messageSend, Pageable pageable) {
 
        return messageSendDao.findAll(new Specification<MessageSend>() {
            @Nullable
            @Override
            public Predicate toPredicate(Root<MessageSend> root, CriteriaQuery<?> cq, CriteriaBuilder cb) {
 
                Path<String> messageIdField = root.get("messageId");
                Path<String> userIdField = root.get("userId");
                Path<Integer> statusField = root.get("status");
 
                List<Predicate> list = new ArrayList<>();
 
                if (StrUtil.isNotBlank(messageSend.getMessageId())) {
                    list.add(cb.equal(messageIdField, messageSend.getMessageId()));
                }
                if (StrUtil.isNotBlank(messageSend.getUserId())) {
                    list.add(cb.equal(userIdField, messageSend.getUserId()));
                }
                if (messageSend.getStatus() != null) {
                    list.add(cb.equal(statusField, messageSend.getStatus()));
                }
 
                Predicate[] arr = new Predicate[list.size()];
                cq.where(list.toArray(arr));
                return null;
            }
        }, pageable);
    }
 
    @Override
    public void updateStatusByUserId(String userId, Integer status) {
 
        messageSendDao.updateStatusByUserId(userId, status);
    }
 
    @Override
    public void deleteByUserId(String userId) {
 
        messageSendDao.deleteByUserId(userId, CommonConstant.MESSAGE_STATUS_READ);
    }
 
    @Override
    public Message getTemplateMessage(String messageId, Map<String, String> params) {
 
        Message message = messageDao.findById(messageId).orElse(null);
        if (message == null) {
            throw new XbootException("消息ID:" + messageId + "不存在");
        }
        // 放入变量
        Message newMessage = new Message();
        newMessage.setTitle(changeParams(message.getTitle(), params));
        newMessage.setContent(changeParams(message.getContent(), params));
        return newMessage;
    }
 
    @Override
    public void sendTemplateMessage(List<String> userIds, String messageId, Map<String, String> params) {
 
        Message message = messageDao.findById(messageId).orElse(null);
        if (message == null) {
            throw new XbootException("消息ID:" + messageId + "不存在");
        }
        List<MessageSend> messageSends = new ArrayList<>();
        for (String userId : userIds) {
            MessageSend ms = new MessageSend();
            ms.setUserId(userId).setMessageId(messageId);
            // 放入变量
            ms.setTitle(changeParams(message.getTitle(), params));
            ms.setContent(changeParams(message.getContent(), params));
            ms.setParams(new Gson().toJson(params));
            messageSends.add(ms);
            messagingTemplate.convertAndSendToUser(userId, "/queue/subscribe", "您收到了新的消息");
        }
        messageSendDao.saveAll(messageSends);
    }
 
    @Override
    public void sendTemplateMessage(String userId, String messageId, Map<String, String> params) {
 
        List<String> users = new ArrayList<>();
        users.add(userId);
        this.sendTemplateMessage(users, messageId, params);
    }
 
    public String changeParams(String v, Map<String, String> params) {
 
        if (v == null || params == null) {
            return "";
        }
        for (Map.Entry entry : params.entrySet()) {
            String key = entry.getKey().toString();
            String value = entry.getValue().toString();
            v = v.replaceAll("\\$\\{" + key + "\\}", value);
        }
        return v;
    }
}