ps-message/src/main/java/com/uas/ps/message/service/impl/MessageServiceImpl.java

package com.uas.ps.message.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.uas.ps.core.page.PageInfo;
import com.uas.ps.core.page.PageParams;
import com.uas.ps.message.dao.AppDao;
import com.uas.ps.message.dao.MessageDao;
import com.uas.ps.message.domain.App;
import com.uas.ps.message.domain.Message;
import com.uas.ps.message.domain.SmsMessage;
import com.uas.ps.message.domain.User;
import com.uas.ps.message.exception.IllegalOperatorException;
import com.uas.ps.message.exception.ParameterMissingException;
import com.uas.ps.message.service.MessageService;
import com.uas.ps.message.util.Constant;
import com.uas.ps.message.util.ConsumeType;
import com.uas.ps.message.util.FastjsonUtils;
import com.uas.ps.message.util.SMSType;
import com.uas.ps.message.util.SplitChar;
import com.uas.ps.message.util.account.HttpUtil;
import com.uas.ps.message.util.account.HttpUtil.ResponseWrap;
import com.uas.sso.util.AccountUtils;
import com.uas.sso.util.FlexJsonUtil;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Service;
import org.springframework.ui.ModelMap;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

/**
 * Created by wangyc on 2018/1/13.
 *
 * @version 2018/1/13 15:44 wangyc
 */
@Service
public class MessageServiceImpl implements MessageService {

    private final MessageDao messageDao;

    private final AppDao appDao;

    private static final Logger LOGGER = Logger.getLogger(Logger.class);

    private final JdbcTemplate jdbcTemplate;

//    private RestTemplate restTemplate;

//    private static final String EMAIL_REGEX = "\\w[-\\w.+]*@([A-Za-z0-9][-A-Za-z0-9]+\\.)+[A-Za-z]{2,14}";

//    private static final String TEL_REGEXP = "^((\\(\\d{3}\\))|(\\d{3}\\-))?(13|15|18|17)\\d{9}$";

    private static final String PROD_URL = "https://mobile.ubtob.com/tigase/baiduPush";

    private static final String PUBLIC_INQUIRY_IM_URL = "https://mobile.ubtob.com:8443/openapp/?pagekind"
        + "=B&id=%s&uu=%s&telephone=%s";
    /**
     * 邮件服务主机地址
     */
    private static final String MAIL_CONSOLE_HOST = "http://10.10.100.136:8080";

    /**
     * 发送邮件给单个人url
     */
    private static final String MAIL_SEND_URL = "mail/send";

    /**
     * 发送邮件给多个人 url
     */
    private static final String MAIL_SEND_MANY_URL = "mail/send/o2m";
    /**
     * 短信接口
     */
    private final String messageUrl = "http://10.10.100.136:8080/sms/send";

    @Autowired
    public MessageServiceImpl(MessageDao messageDao, AppDao appDao, JdbcTemplate jdbcTemplate) {
        this.messageDao = messageDao;
        this.appDao = appDao;
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public Page<Message> getMessages(String receiverUu, String receiverEnuu, String consumerApp, String isRead,
        String keyword, PageParams pageParams) {
        if (StringUtils.isEmpty(receiverUu) || StringUtils.isEmpty(receiverEnuu)) {
            throw new ParameterMissingException("接收人信息为空");
        }
        if (StringUtils.isEmpty(consumerApp)) {
            throw new ParameterMissingException("接收应用信息为空");
        }
        App consumerAppExists = appDao.findByName(consumerApp);
        if (consumerApp == null) {
            throw new IllegalOperatorException("接收应用不存在");
        }
        final Long consumerAppId = consumerAppExists.getId();

        // 消息接收人过滤
//        SimpleExpression receiverUuExp = PredicateUtils.eq("receiverUu", Long.valueOf(receiverUu), true);
        // 消息接收企业过滤
//        SimpleExpression receiverEnuuExp = PredicateUtils.eq("receiverEnuu", Long.valueOf(receiverEnuu), true);
//        SimpleExpression[] simpleExpressions = new SimpleExpression[] {receiverUuExp, receiverEnuuExp};

        String sql = String.format("select count(1) from messages m where ms_receiveruu = %s and ms_receiverenuu = %s ",
            Long.valueOf(receiverUu), Long.valueOf(receiverEnuu));
        // 读取状态
        if (!StringUtils.isEmpty(isRead)) {
//            SimpleExpression isReadExp = PredicateUtils.eq("isRead", Short.valueOf(isRead), true);
//            simpleExpressions = ArrayUtils.concat(simpleExpressions, new SimpleExpression[] {isReadExp});
            sql += String.format(" and ms_isread = %s", Short.valueOf(isRead));
        }

        // 关键词搜索
        if (!StringUtils.isEmpty(keyword)) {
//            SimpleExpression contentExp = PredicateUtils.like("content", keyword, true);
//            simpleExpressions = ArrayUtils.concat(simpleExpressions, new SimpleExpression[] {contentExp});
            sql += String.format(" and ms_content like '%%%s%%'", keyword);
        }

            sql += String.format(" and exists (select 1 from message$consumeapp where app_id = %s and m.ms_id = ms_id)",
                consumerAppId);

//        final LogicalExpression logicalExpression = PredicateUtils.and(simpleExpressions);
        final PageInfo pageInfo = new PageInfo(pageParams);
        Long count = jdbcTemplate.queryForObject(sql, Long.class);
        List<Message> messageList = new ArrayList<>();
        if (count > 0) {
            sql += String.format("order by ms_createtime %s limit %s,%s", pageInfo.getSort().getOrderFor("createTime").getDirection(), (pageParams.getPage() - 1) * pageParams.getCount(), pageParams.getCount());
            messageList = jdbcTemplate.query(sql.replace("count(1)", "*"), new RowMapper<Message>() {
                @Override
                public Message mapRow(ResultSet resultSet, int i) throws SQLException {
                    Message message = new Message();
                    if (resultSet != null) {
                        message.setId(resultSet.getLong("ms_id"));
                        message.setConsumeType(resultSet.getString("ms_consumeType"));
                        message.setContent(resultSet.getString("ms_content"));
                        message.setCreateTime(resultSet.getTimestamp("ms_createTime"));
                        message.setIsRead(resultSet.getShort("ms_isread"));
                        message.setIsSent(resultSet.getShort("ms_issent"));
                        message.setReceiverEnuu(resultSet.getLong("ms_receiverenuu"));
                        message.setReceiverUu(resultSet.getLong("ms_receiveruu"));
                        message.setSenderEnuu(resultSet.getLong("ms_senderenuu"));
                        message.setSenderUu(resultSet.getLong("ms_senderuu"));
                        message.setType(resultSet.getString("ms_type"));
                        message.setRemark(resultSet.getString("ms_remark"));
                        message.setSourceId(resultSet.getLong("ms_sourceid"));
                    }
                    return message;
                }
            });
        }

        return new PageImpl<Message>(messageList, pageInfo, count);

//        return messageDao.findAll(new Specification<Message>() {
//            @Override
//            public Predicate toPredicate(Root<Message> root, CriteriaQuery<?> criteriaQuery,
//                CriteriaBuilder criteriaBuilder) {
//                Predicate messagePredicate = criteriaBuilder.and(logicalExpression.toPredicate(root, criteriaQuery,
//                    criteriaBuilder));
//                // 消费应用过滤
//                Predicate consumerAppPredicate = criteriaBuilder.equal(root.join("consumerApp").get("id"),
//                    consumerAppId);
//                Predicate all = criteriaBuilder.and(messagePredicate, consumerAppPredicate);
//                criteriaQuery.where(all);
//                return null;
//            }
//        }, pageInfo);
    }

    @Override
    public Map<String, Object> getUnReadMessageCount(String receiverUu, String receiverEnuu, String consumerApp) {
        if (StringUtils.isEmpty(receiverUu) || StringUtils.isEmpty(receiverEnuu)) {
            throw new ParameterMissingException("接收人信息为空");
        }
        if (StringUtils.isEmpty(consumerApp)) {
            throw new ParameterMissingException("接收应用信息为空");
        }
        App consumerAppExists = appDao.findByName(consumerApp);
        if (consumerApp == null) {
            throw new IllegalOperatorException("接收应用不存在");
        }

        Integer messagesCount = messageDao.findCountByReceiverUuAndReceiverEnuuAndIsReadAndConsumerAppId(Long.valueOf(receiverUu),
            Long.valueOf(receiverEnuu), Constant.NO, consumerAppExists.getId());

        Map<String, Object> resultMap = new HashMap<>();
        resultMap.put("success", "success");
        resultMap.put("count", messagesCount);
        return resultMap;
    }

    @Override
    public Map<String, Object> getMessageCount(String receiverUu, String receiverEnuu, String consumerApp,
        String isRead) {
        if (StringUtils.isEmpty(receiverUu) || StringUtils.isEmpty(receiverEnuu)) {
            throw new ParameterMissingException("接收人信息为空");
        }
        if (StringUtils.isEmpty(consumerApp)) {
            throw new ParameterMissingException("接收应用信息为空");
        }
        App consumerAppExists = appDao.findByName(consumerApp);
        if (consumerAppExists == null) {
            throw new IllegalOperatorException("接收应用不存在");
        }

        Integer messagesCount = 0;

        if (StringUtils.isEmpty(isRead) || (!isRead.equals(Constant.NO.toString()) && !isRead.equals(Constant.YES.toString()))) {
            messagesCount = messageDao.findCountByReceiverUuAndReceiverEnuuAndConsumerAppId(Long.valueOf(receiverUu),
                Long.valueOf(receiverEnuu), consumerAppExists.getId());

        } else {
            messagesCount = messageDao.findCountByReceiverUuAndReceiverEnuuAndIsReadAndConsumerAppId(Long.valueOf(receiverUu),
                Long.valueOf(receiverEnuu), Short.valueOf(isRead), consumerAppExists.getId());
        }


        Map<String, Object> resultMap = new HashMap<>();
        resultMap.put("success", "success");
        resultMap.put("count", messagesCount);
        return resultMap;
    }

    @Override
    public List<Message> saveMessages(String messages) {
        List<JSONObject> jsonObjects = FastjsonUtils.fromJsonArray(messages, JSONObject.class);
        List<Message> messageList = convertFromJsonObj(jsonObjects);
        return messageDao.save(messageList);
    }

    @Override
    public Map<String, Object> sendMessage(String consumerApp) {
        JSONObject consumer = FastjsonUtils.parseObject(consumerApp);
        Object consumerAppObj = consumer.get("consumerApp");
        if (consumerAppObj != null && !StringUtils.isEmpty(String.valueOf(consumerAppObj))) {
            App consumerAppExists = appDao.findByName(String.valueOf(consumerAppObj));
            if (consumerAppExists == null) {
                throw new IllegalOperatorException("接收应用不存在");
            }

            // 获取改应用应接收的未读、未发送的需要推送的消息(取前500条)
            List<Message> messages = messageDao.findByConsumerAppIdAndIsReadAndIsSentNeedToSend(
                consumerAppExists.getId(), Constant.NO, Constant.NO);
            LOGGER.info("信息数量：" + messages.size());
            Map<String, Object> resultMap = sendMessageByAPI(messages, consumerApp);
            resultMap.put("success", "success");
            return resultMap;
        } else {
            throw new ParameterMissingException("接收应用信息为空");
        }
    }

    @Override
    public ModelMap readMessage(String consumer) {
        ModelMap map = new ModelMap();
        map.put("success", "false");
        if (StringUtils.isEmpty(consumer)) {
            throw new ParameterMissingException("接收人信息为空，无法阅读消息");
        }

        JSONObject jsonObject = FastjsonUtils.parseObject(consumer);

        // 消息id
        Object messageId = jsonObject.get("messageId");
        Object receiverUu = jsonObject.get("receiverUu");
        Object receiverEnuu = jsonObject.get("receiverEnuu");
        Object consumerApp = jsonObject.get("consumerApp");
        if (StringUtils.isEmpty(messageId)) {
            map.put("data", "消息id为空，请重新确认消息信息");
            return map;
        } else {
            String[] messageIds = String.valueOf(messageId).split(SplitChar.COMMA);
            List<Message> messages = new ArrayList<>();

            for (String id : messageIds) {
                Message message = messageDao.findOne(Long.valueOf(String.valueOf(id)));
                if (message == null) {
                    map.put("data", "消息不存在，请重新确认消息信息");
                    return map;
                }
                if (receiverUu == null || StringUtils.isEmpty(String.valueOf(receiverEnuu)) || receiverEnuu == null
                    || StringUtils.isEmpty(String.valueOf(receiverUu))
                    || StringUtils.isEmpty(String.valueOf(consumerApp))) {
                    map.put("data", "用户信息为空，无法读取消息");
                    return map;
                }
                if (!Long.valueOf(String.valueOf(receiverEnuu)).equals(message.getReceiverEnuu())
                    || !Long.valueOf(String.valueOf(receiverUu)).equals(message.getReceiverUu())) {
                    map.put("data", "此消息不属于当前用户，请重新确认后读取");
                    return map;
                }
                if (Constant.YES.equals(message.getIsRead())) {
                    map.put("data", "消息已阅读");
                    return map;
                }
                App app = appDao.findByName(String.valueOf(consumerApp));
                if (app == null) {
                    map.put("data", "消费应用不存在，请重新确认用户信息");
                    return map;
                }
                if (!message.getConsumerApp().contains(app)) {
                    map.put("data", "消息不属于当前应用");
                    return map;
                }

                message.setIsRead(Constant.YES);
                messages.add(message);
            }

            messages = messageDao.save(messages);
            map.put("success", "success");
            map.put("data", FastjsonUtils.toJson(messages));
            return map;
        }
    }

    /**
     * jsonObject转换为Message
     * @param jsonObjects jsonObjects
     * @return messages
     */
    private List<Message> convertFromJsonObj(List<JSONObject> jsonObjects) {
        List<Message> messages = new ArrayList<>();
        for (JSONObject jsonObject : jsonObjects) {
            Message message = new Message();

            // 消息内容
            Object content = jsonObject.get("content");
            if (StringUtils.isEmpty(content)) {
                throw new ParameterMissingException("消息内容为空");
            } else {
                message.setContent(String.valueOf(content));
            }

            // 发送人
            Object senderUu = jsonObject.get("senderUu");
            Object senderEnuu = jsonObject.get("senderEnuu");
            if (StringUtils.isEmpty(senderUu) || StringUtils.isEmpty(senderEnuu)) {
                throw new ParameterMissingException("发送人信息为空");
            } else {
                message.setSenderUu(Long.valueOf(String.valueOf(senderUu)));
                message.setSenderEnuu(Long.valueOf(String.valueOf(senderEnuu)));
            }

            // 接收人
            Object receiverUu = jsonObject.get("receiverUu");
            Object receiverEnuu = jsonObject.get("receiverEnuu");
            if (StringUtils.isEmpty(receiverUu) || StringUtils.isEmpty(receiverEnuu)) {
                throw new ParameterMissingException("接收人信息为空");
            } else {
                message.setReceiverUu(Long.valueOf(String.valueOf(receiverUu)));
                message.setReceiverEnuu(Long.valueOf(String.valueOf(receiverEnuu)));
            }

            // 发送应用
            Object producerApp = jsonObject.get("producerApp");
            if (StringUtils.isEmpty(producerApp)) {
                throw new ParameterMissingException("发送应用为空");
            } else {
                App app = appDao.findByName(String.valueOf(producerApp));
                if (app == null) {
                    throw new IllegalOperatorException("发送应用不存在");
                }
                message.setProducerApp(app.getId());
            }

            // 接收应用
            Object consumerType = jsonObject.get("consumerType");
            if (StringUtils.isEmpty(consumerType)) {
                throw new ParameterMissingException("接收应用类型为空");
            } else {
                String type = String.valueOf(consumerType);
                // 消息接收类型为公共，即所有子应用共享
                if (ConsumeType.PUBLIC.equals(type)) {
                    List<App> apps = appDao.findAll();
                    message.setConsumerApp(new HashSet<>(apps));
                    message.setConsumeType(type);
                } else {
                    Object consumerApp = jsonObject.get("consumerApp");
                    if (consumerApp == null) {
                        throw new ParameterMissingException("接收应用为空");
                    } else {
                        // 取出通过逗号拼接的接收应用
                        String[] consumers = String.valueOf(consumerApp).split(SplitChar.COMMA);
                        if (consumers.length < 1) {
                            throw new ParameterMissingException("接收应用为空");
                        }

                        Set<App> consumerApps = new HashSet<>();
                        for (String consumer : consumers) {
                            App app = appDao.findByName(consumer);
                            if (app == null) {
                                throw new IllegalOperatorException("接收应用不存在");
                            }
                            consumerApps.add(app);
                        }

                        message.setConsumerApp(consumerApps);
                        message.setConsumeType(consumers.length > 1 ? ConsumeType.MULTI : ConsumeType.SINGLE);
                    }
                }
            }

            // 消息类型（暂时未定）
            Object type = jsonObject.get("type");
            if (!StringUtils.isEmpty(type)) {
                message.setType(String.valueOf(type));
            }

            // 推送类型
            Object smsType = jsonObject.get("smsType");
            if (StringUtils.isEmpty(smsType)) {
                message.setSmsType(SMSType.DONT_SEND);
            } else {
                message.setSmsType(String.valueOf(smsType));
            }

            // 备注
            Object remark = jsonObject.get("remark");
            if (!StringUtils.isEmpty(remark)) {
                message.setRemark(String.valueOf(remark));
            }

            // 来源id
            Object sourceId = jsonObject.get("sourceId");
            if (!StringUtils.isEmpty(sourceId)) {
                message.setSourceId(Long.valueOf(String.valueOf(sourceId)));
            }

            // 邮件模板
            Object mailTemplate = jsonObject.get("mailTemplate");
            if (!StringUtils.isEmpty(mailTemplate)) {
                message.setMailTemplate(String.valueOf(mailTemplate));
            }

            // 短信模板
            Object smTemplate = jsonObject.get("smTemplate");
            if (!StringUtils.isEmpty(smTemplate)) {
                message.setSmTemplate(String.valueOf(smTemplate));
            }

            message.setIsRead(Constant.NO);
            message.setCreateTime(new Date());
            message.setIsSent(Constant.NO);

            messages.add(message);
        }
        return messages;
    }

    /**
     * 推送消息（调用邮件、短信、IM接口）
     * @param messages 消息
     * @param consumerApp 消费app
     * @return resultMap
     */
    private Map<String, Object> sendMessageByAPI(List<Message> messages, String consumerApp) {
        Map<String, Object> resultMap = new HashMap<>();

        if (!CollectionUtils.isEmpty(messages)) {
            for (Message message : messages) {
                try {
                   User receiver = (User) AccountUtils.getUserInfo(message.getReceiverUu(),
                        message.getReceiverEnuu());
                    if (receiver.getVipName() != null) {
                        LOGGER.info("接收人：" + receiver.getVipName());

                        User sender = (User) AccountUtils.getUserInfo(message.getSenderUu(),
                            message.getSenderEnuu());
                        if (sender != null && sender.getVipName() != null && sender.getSpaceName() != null) {
                            LOGGER.info("发送人：" + sender.getVipName());

                            boolean sendSuccess = false;
                            // 发送邮件
//                            if (message.getSmsType().contains(SMSType.MAIL)) {
//                                sendMail(message, receiver);
//                            }

                            // 发送短息
                            if (message.getSmsType().contains(SMSType.SM)) {
                                LOGGER.info("开始推送短信");
                                sendSuccess = sendSM(message, receiver, sender);
                            }

                            // 发送IM
                            if (message.getSmsType().contains(SMSType.IM)) {
                                LOGGER.info("开始推送IM");
                                sendSuccess = sendIM(message, receiver, consumerApp);
                            }

                            // 推送成功
                            if (sendSuccess) {
                                pushSuccess(message, receiver, sender);
                            }
                        } else {
                            LOGGER.info("发送人信息为空，uu:" + message.getSenderUu() + ",enuu:" + message.getSenderEnuu());
                        }
                    } else {
                        LOGGER.info("接收人姓名为空，uu:" + message.getReceiverUu() + ",enuu:" + message.getReceiverEnuu());
                    }
                } catch (Exception e) {
                    message.setIsSent(Constant.ERROR);
                    LOGGER.info(e.getMessage());
                }
            }
            messageDao.save(messages);
        }
        return resultMap;
    }

    /**
     * 发送邮件
     * @param message 消息
     * @param receiver 接收人
     */
    private void sendMail(Message message, User receiver) {
        if (message.getMailTemplate() != null && receiver.getEmail() != null) {
            HttpHeaders headers = new HttpHeaders();
            MediaType type = MediaType.parseMediaType("application/json; charset=UTF-8");
            headers.setContentType(type);
            headers.add("Accept", MediaType.APPLICATION_JSON.toString());

            JSONObject object = new JSONObject();
            object.put("templateId", message.getMailTemplate());
            object.put("receiver", receiver.getEmail());
            object.put("params", message.getContent());

//            HttpEntity<String> formEntity = new HttpEntity<String>(, headers);
            try {
                ResponseWrap responseWrap = HttpUtil.doPost(MAIL_CONSOLE_HOST + MAIL_SEND_URL,
                    FlexJsonUtil.toJson(object));
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

    /**
     * 发送短信
     * @param message 消息
     * @param receiver 接收人
     * @param sender 发送人
     * @return 推送成功状态
     */
    private boolean sendSM(Message message, User receiver, User sender) {
        if (!StringUtils.isEmpty(message.getSmTemplate()) && !StringUtils.isEmpty(receiver.getMobile())) {
            try {
                SmsMessage sms = new SmsMessage();
                List<Object> obj = new ArrayList<Object>();

                switch (message.getSmTemplate()) {
                    // 公共询价单，普通短信
                    case "e14d502a-25b8-40a0-8acf-5c61ae38d763" :
                        obj.add(receiver.getVipName());
                        obj.add(sender.getSpaceName());
                        obj.add(message.getRemark());
                        pushSm(sms, message, obj, receiver, sender);
                        break;
                    // 公共询价单，UU互联
                    case "6e094dcf-f2c7-462a-9686-b2d32d684a78" :
                        obj.add(message.getSourceId());
                        obj.add(message.getReceiverEnuu());
                        obj.add(receiver.getMobile());
                        pushSm(sms, message, obj, receiver, sender);
                        break;
                    // 公共询价统计
                    case "e6320a3c-89ac-4c77-a75f-62a727bce654" :
                        obj.add(receiver.getSpaceName());
                        obj.add(message.getRemark());
                        pushSm(sms, message, obj, receiver, sender);
                    default:
                        break;
                }
                return true;
            } catch (Exception e) {
                LOGGER.info("短信推送异常：" + e.getMessage());
                e.printStackTrace();
                return false;
            }
        }
        return false;
    }

    /**
     * 调用短信接口
     * @param sms 短信model
     * @param message 消息
     * @param param 短信参数
     * @param receiver 接收人
     * @param sender 发送人
     */
    private void pushSm(SmsMessage sms, Message message, List<Object> param, User receiver, User sender) {
        sms.setParams(param);
        sms.setReceiver(receiver.getMobile());
        sms.setTemplateId(message.getSmTemplate());
        String response = com.uas.ps.message.util.HttpUtil
            .sendPost(messageUrl, FastjsonUtils.toJson(sms));
        LOGGER.info("短信推送成功：" + response);
    }

    /**
     * 设置推送送成功
     * @param message 消息
     * @param receiver 接收人
     * @param sender 发送人
     */
    private void pushSuccess(Message message, User receiver, User sender) {
        message.setIsSent(Constant.YES);
        message.setReceiver(FastjsonUtils.toJson(receiver));
        message.setSender(FastjsonUtils.toJson(sender));
    }

    /**
     * 发送IM
     * @param message 消息
     * @param receiver 接收人
     * @param consumerApp 消费app
     * @return 推送成功状态
     */
    private boolean sendIM(Message message, User receiver, String consumerApp) {
        Map<String, Object> params = new HashMap<>();
        if (!StringUtils.isEmpty(receiver.getImId())) {
            params.put("master", receiver.getSpaceName()); // 账套 公司名称
            params.put("userid", receiver.getImId()); // 推送目标用户
            params.put("title", message.getType() == null ? "" : message.getType()); // 推送标题
            params.put("content", message.getContent()); // 正文
            params.put("enUU", message.getReceiverEnuu()); // UU号
            params.put("masterId", null);
            params.put("url", String.format(PUBLIC_INQUIRY_IM_URL, message.getSourceId(),
                message.getReceiverEnuu(), receiver.getMobile())); // 跳转链接地址
            params.put("pageTitle", message.getType() == null ? "" : message.getType());
            params.put("platform", "B2B"); // 系统名称，ERP或B2B
            try {
                ResponseWrap res = HttpUtil.doPost(PROD_URL, params);
                if (res.isSuccess()) {
                    LOGGER.info("IM推送成功");
                    return true;
                } else {
                    LOGGER.info("IM推送失败：" + res.getContent());
                }
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
        return false;
    }
}