优化

zhanghua

2024-01-21 bc8074c56893eac3eb5002dcefeacd644d827a29

 ycl-platform/src/main/java/com/ycl/service/message/impl/MessageServiceImpl.java

@@ -1,27 +1,44 @@
package com.ycl.service.message.impl;

import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ycl.common.constant.ChannelCode;
import com.ycl.common.util.CommonUtils;
import com.ycl.dto.message.MessageParam;
import com.ycl.entity.message.Message;
import com.ycl.entity.user.UmsAdmin;
import com.ycl.entity.message.SendReq;
import com.ycl.entity.message.SendRes;
import com.ycl.exception.ApiException;
import com.ycl.mapper.message.MessageMapper;
import com.ycl.mapper.user.UmsAdminMapper;
import com.ycl.service.message.IMessageService;
import com.ycl.service.message.Provider;
import com.ycl.service.message.Sender;
import com.ycl.service.message.factory.InnerFactory;
import com.ycl.service.message.factory.MailFactory;
import com.ycl.service.message.factory.SmsFactory;
import com.ycl.utils.MD5Util;
import com.ycl.vo.message.MessageVO;
import lombok.SneakyThrows;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.mail.javamail.JavaMailSenderImpl;
import org.springframework.mail.javamail.MimeMessageHelper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Base64Utils;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import javax.mail.internet.MimeMessage;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Properties;
import java.util.stream.Collectors;

/**
@@ -35,78 +52,258 @@
@Service
public class MessageServiceImpl extends ServiceImpl<MessageMapper, Message> implements IMessageService {

    @Value("${e-mail.sendHost}")
    private String sendHost;

    @Value("${e-mail.username}")
    private String userName;

    @Value("${e-mail.password}")
    private String password;

    @Value(value = "${SMS.ecName}")
    private String ecName;     //集团客户名称

    @Value(value = "${SMS.apId}")
    private String apId;       //用户名

    @Value(value = "${SMS.sign}")
    private String sign;       //网关签名编码，必填，签名编码在中国移动集团开通帐号后分配，可以在云MAS网页端管理子系统-SMS接口管理功能中下载。

    @Value(value = "${SMS.url}")
    private String url;

    @Resource
    private UmsAdminMapper umsAdminMapper;
    @Resource
    private MessageMapper messageMapper;

    @Resource
    RestTemplate restTemplate;

    @Override
    public Message sendMessage(MessageParam messageParam) {
        Message message = null;
        Provider provider = null;
        switch (messageParam.getChannelCode())
        {
            //内站发送
            case ChannelCode.INNER:
                provider = new InnerFactory();
                break;
            //邮件发送
            case ChannelCode.SMS:
                provider = new MailFactory();
                break;
             //短信发送
            case ChannelCode.MAIL:
                provider = new SmsFactory();
                break;
            default:
                throw new ApiException("未匹配到该类型");
    @SneakyThrows
    @Transactional(rollbackFor = Exception.class)
    public void sendSMS(Message message) {
        Integer messageStatus = sendMessages(message);

        if (messageStatus == 2) {
            message.setStatus(2);
            message.setRespondResult("发送成功");
        }
        Sender sender = provider.produce();
        sender.sendMessage(messageParam);
        return message;
        if (messageStatus == 3) {
            message.setStatus(3);
            message.setRespondResult("发送失败");
        }
        message.setUpdateTime(new Date());
        message.setSendTime(new Date());
        messageMapper.updateById(message);
    }

    @Override
    public IPage<Message> list(MessageParam messageParam) {
    @Transactional(rollbackFor = Exception.class)
    public void sendMessage(Message message) {

//        Message savedMessage = messageMapper.selectOne(new LambdaQueryWrapper<Message>()
//                .eq(Message::getTargetTo, message.getTargetTo())
//                .eq(Message::getTargetFrom, message.getTargetFrom())
//                .eq(Message::getBody, message.getBody())
//                .eq(Message::getStatus, 1)
//                .eq(Message::getHead, message.getHead()));
//        if (savedMessage != null) {
//            messageMapper.deleteById(savedMessage);
//        }

        ArrayList<Message> ids = new ArrayList<>();
        message.setTargetFrom(umsAdminMapper.selectById(message.getCreateUser()).getUsername());
        if (message.getId() == null) {
            for (String receive : message.getTargetTo().split(",")) {
                Message sendMessage = new Message();
                BeanUtils.copyProperties(message, sendMessage);
                sendMessage.setCreateTime(new Date());
                sendMessage.setSendTime(new Date());
                sendMessage.setTargetTo(receive);
                sendMessage.setSendTime(new Date());
                sendMessage.setPhoneNumber(message.getTargetTo());

                if (ChannelCode.INNER.equals(message.getChannelCode())) {
                    sendMessage.setIsView(0);
                }
                this.save(sendMessage);
                ids.add(sendMessage);
            }
        }
//        switch (message.getChannelCode()) {
//            //短信发送
//            case ChannelCode.SMS:
//                sendSMS(message, ids);
//                break;
//            //邮件发送
//            case ChannelCode.MAIL:
//                sendMail(message);
//                break;
//            case ChannelCode.INNER:
//                break;
//            default:
//                throw new ApiException("未匹配到该类型");
//        }
    }

    @SneakyThrows
    @Transactional(rollbackFor = Exception.class)
    public void sendSMS(Message message, List<Message> messageList) {
        List<String> mobiles = new ArrayList<>();
        List<Long> mesIds = new ArrayList<>();
        for (Message m : messageList) {
            mobiles.add(m.getPhoneNumber());
            mesIds.add(m.getId());
        }
        message.setPhoneNumber(StringUtils.join(mobiles, ","));
        Integer messageStatus = sendMessages(message);
        Message messaged = new Message();
        for (Long id : mesIds) {
            if (messageStatus == 2) {
                messaged.setStatus(2);
                messaged.setRespondResult("发送成功");
            }
            if (messageStatus == 3) {
                messaged.setStatus(3);
                messaged.setRespondResult("发送失败");
            }
            messaged.setId(id);
            messaged.setUpdateTime(new Date());
            messaged.setSendTime(new Date());
            messageMapper.updateById(messaged);
        }
    }

    @Override
    @SneakyThrows
    @Transactional(rollbackFor = Exception.class)
    public void sendMessageByPhone(Message message) {
        Message sendMessage = new Message();
        BeanUtils.copyProperties(message, sendMessage);
        sendMessage.setCreateTime(new Date());
        sendMessage.setSendTime(new Date());
        sendMessage.setSendTime(new Date());
        sendMessage.setTargetFrom(umsAdminMapper.selectById(message.getCreateUser()).getUsername());
        this.save(sendMessage);
        Integer messageStatus = sendMessages(message);
        Message messaged = new Message();
        if (messageStatus == 2) {
            messaged.setStatus(2);
            messaged.setRespondResult("发送成功");
        }
        if (messageStatus == 3) {
            messaged.setStatus(3);
            messaged.setRespondResult("发送失败");
        }
        messaged.setId(sendMessage.getId());
        messaged.setUpdateTime(new Date());
        messaged.setSendTime(new Date());
        messageMapper.updateById(messaged);
    }

    @SneakyThrows
    private Integer sendMessages(Message message) {
        String context = "【" + message.getHead() + "】" + message.getBody();
        String addSerial = "";
        SendReq sendReq = new SendReq();
        sendReq.setEcName(ecName);
        sendReq.setApId(apId);
        sendReq.setSign(sign);
        sendReq.setContext(context);
        sendReq.setMobiles(message.getPhoneNumber());
        sendReq.setAddSerial(addSerial);

        StringBuffer mac = new StringBuffer();
        mac.append(ecName);
        mac.append(apId);
        mac.append(sendReq.getMobiles());
        mac.append(context);
        mac.append(sign);
        mac.append(addSerial);
        sendReq.setMac(MD5Util.md5Encrypt32Lower(mac.toString()));

        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.setContentType(MediaType.APPLICATION_JSON);

        ObjectMapper objectMapper = new ObjectMapper();

        HttpEntity<String> stringHttpEntity = new HttpEntity<>(Base64Utils.encodeToString(objectMapper.writeValueAsBytes(mac)), httpHeaders);
        ResponseEntity<String> response = restTemplate.postForEntity(url + "/sms/submit", sendReq, String.class);
        SendRes sendRes = objectMapper.readValue(response.getBody(), SendRes.class);
        if (sendRes.getRspcod().equals("success")) {
            return 2;
        } else {
            return 3;
        }
    }

    //发送邮件
    @SneakyThrows
    private void sendMail(Message message) {
        JavaMailSenderImpl javaMailSender = new JavaMailSenderImpl();
        javaMailSender.setHost(sendHost);
        javaMailSender.setUsername(userName);
        javaMailSender.setPassword(password);
        javaMailSender.setPort(465);
        Properties properties = new Properties();
        properties.put("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory");
        properties.put("mail.smtp.auth", "true");//必须是字符串而不能是boolean否则报错
        properties.put("mail.smtp.starttls.enable", "true");
        properties.put("mail.smtp.timeout", "1000");
        properties.put("mail.smtp.host", sendHost);
        javaMailSender.setJavaMailProperties(properties);
        MimeMessage mimeMessage = javaMailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(mimeMessage);
        helper.setText(message.getBody());
        helper.setSubject(message.getHead());
        helper.setFrom(userName);
        String[] ids = message.getTargetTo().split(",");
        String[] address = new String[ids.length];
        for (int i = 0; i < ids.length; i++) {
            address[i] = umsAdminMapper.selectById(ids[i]).getEmail();
        }
        helper.setTo(address);
        javaMailSender.send(mimeMessage);
    }

    @Override
    public Page<MessageVO> list(MessageParam messageParam) {
        Page<Message> page = new Page<>(messageParam.getCurrent(), messageParam.getPageSize());
        LambdaQueryWrapper<Message> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Message::getParentId, 0);
        if (!CommonUtils.isEmpty(messageParam.getHead())) {
            queryWrapper.eq(Message::getHead, messageParam.getHead());
        }
        if (!CommonUtils.isEmpty(messageParam.getChannelCode())) {
            queryWrapper.eq(Message::getChannelCode, messageParam.getChannelCode());
        }
        if (!CommonUtils.isEmpty(messageParam.getStatus())) {
            queryWrapper.eq(Message::getStatus, messageParam.getStatus());
        }
        queryWrapper.orderByDesc(Message::getCreateTime);
        Page<Message> result = baseMapper.selectPage(page, queryWrapper);
        List<Message> messages = result.getRecords();
        if (!CommonUtils.isEmpty(messages)) {
            List<Long> ids = messages.stream().map(e -> Long.parseLong(e.getTargetFrom().trim())).collect(Collectors.toList());
            LambdaQueryWrapper<UmsAdmin> queryUSers = new LambdaQueryWrapper<>();
            queryUSers.in(UmsAdmin::getId, ids);
            List<UmsAdmin> users = umsAdminMapper.selectList(queryUSers);
            if (!CommonUtils.isEmpty(users)) {
                for (UmsAdmin user : users) {
                    for (Message message : messages) {
                        if (message.getTargetFrom().equals(user.getId()+"")) {
                            message.setTargetFrom(user.getUsername());
                        }
        return messageMapper.selectMessagePage(page, messageParam);
    }

    @Override
    public Page<Message> queryMyMessage(Page<Message> page, Long userId) {
        List<Message> list = list();
        ArrayList<Long> ids = new ArrayList<>();
        list.forEach(item -> {
            String targetTo = item.getTargetTo();
            if (StringUtils.isNotBlank(targetTo)) {
                String[] split = targetTo.split(",");
                for (String s : split) {
                    if (userId.equals(Long.getLong(s))) {
                        ids.add(item.getId());
                        break;
                    }
                }
            }
        });
        if (CollUtil.isEmpty(ids)) {
            return new Page<>();
        }
        return result;
        return baseMapper.selectPage(page, new QueryWrapper<Message>().lambda().in(Message::getId, ids));
    }

    @Override
    public Boolean deleteMessages(List<Long> ids) {
        LambdaQueryWrapper<Message> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(Message::getId, ids).or().in(Message::getParentId,ids);
        queryWrapper.in(Message::getId, ids).or().in(Message::getParentId, ids);
        List<Message> messages = baseMapper.selectList(queryWrapper);
        if (CommonUtils.isNotEmpty(messages)) {
            List<Long>  deleteIds = messages.stream().map(Message::getId).collect(Collectors.toList());
            List<Long> deleteIds = messages.stream().map(Message::getId).collect(Collectors.toList());
            baseMapper.deleteBatchIds(deleteIds);
        }
        return true;