link-wechat/linkwe-service/src/main/java/com/linkwechat/service/impl/ISxkWelcomeMsgServiceImpl.java

package com.linkwechat.service.impl;

import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.linkwechat.common.constant.MessageConstants;
import com.linkwechat.common.constant.WeConstans;
import com.linkwechat.common.core.domain.entity.SysUser;
import com.linkwechat.common.enums.CustomerAddWay;
import com.linkwechat.common.enums.MessageNoticeType;
import com.linkwechat.common.enums.message.MessageTypeEnum;
import com.linkwechat.common.utils.StringUtils;
import com.linkwechat.common.utils.xml.XmlUtils;
import com.linkwechat.domain.WeCorpAccount;
import com.linkwechat.domain.WeCustomer;
import com.linkwechat.domain.WeCustomerSeas;
import com.linkwechat.domain.WeUser;
import com.linkwechat.domain.wecom.callback.WeBackCustomerVo;
import com.linkwechat.domain.wecom.callback.xml.*;
import com.linkwechat.domain.wecom.query.customer.WeCustomerQuery;
import com.linkwechat.domain.wecom.vo.customer.WeCustomerDetailVo;
import com.linkwechat.fegin.QwCustomerClient;
import com.linkwechat.mapper.WeCustomerMapper;
import com.linkwechat.service.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: Shixk
 * @Date: 2023/12/29/14:11
 * @Description:
 */
@Slf4j
@Service
public class ISxkWelcomeMsgServiceImpl implements ISxkWelcomeMsgService {


    @Autowired
    private MyWeFissionMsgServiceImpl myWeFissionMsgService;
    @Autowired
    private MyQrCodeMsgServiceImpl myQrCodeMsgService;
    @Autowired
    private CarQrCodeServiceImpl carQrCodeService;
    @Autowired
    private RenewalServiceImpl renewalService;

    @Autowired
    protected IWeMaterialService weMaterialService;

    @Autowired
    private IWeCorpAccountService iWeCorpAccountService;

    @Autowired
    @Lazy
    private IWeCustomerService iWeCustomerService;

    @Autowired
    @Lazy
    private IWeUserService iWeUserService;

    @Autowired
    private WeCustomerMapper weCustomerMapper;

    @Autowired
    @Lazy
    private IWeCustomerTrajectoryService iWeCustomerTrajectoryService;

    @Autowired
    @Lazy
    private IWeMessagePushService iWeMessagePushService;

    @Resource
    @Lazy

    private IWeMessageNotificationService weMessageNotificationService;
    @Resource
    @Lazy
    private IWeCustomerSeasService weCustomerSeasService;

    @Autowired
    private QwCustomerClient qwCustomerClient;


    /**
     * 业务处理
     *
     * 客户删除业务员后，  业务员不能再给客户发送消息，    但是同步客户时，该客户还能同步过来。
     * 业务员删除客户后，  业务员可以给客户发送消息，客户也能给业务员发消息，    同步客户时，该客户将不能再同步过来。
     * 互删后，同步客户，不能再同步过来.
     *
     * @param msg
     */
    @Async
    @Override
    public void msgHandle(String msg) {
        log.info("企微回调：msg:{}", msg);
        try {
            // 解析XML回调报文
            PubExternalContact pubExternalContact = XmlUtils.convertToJavaBean(msg, PubExternalContact.class);
            if (ObjectUtil.isEmpty(pubExternalContact)) {
                log.error("企微回调消息-消息处理失败,解析XML报文为空！");
            }

            String changeType = pubExternalContact.getChangeType();
            String event = pubExternalContact.getEvent();
            // 根据event和ChangeType判断事件类型
            // 添加企业客户事件 add_external_contact
            // 免验证添加成员事件 add_half_external_contact
            if ("change_external_contact".equals(event) && ("add_external_contact".equals(changeType)
                    || "add_half_external_contact".equals(changeType))) {
                log.info("回调 添加企业客户事件/免验证添加成员事件{} ， 配置了客户联系功能的成员添加外部联系人时，回调该事件", changeType);

                // 添加企业客户事件
                AddExternalContact addExternalContact = XmlUtils.convertToJavaBean(msg, AddExternalContact.class);
                String state = addExternalContact.getState() == null ? "" : addExternalContact.getState();

                WeCorpAccount weCorpAccount = iWeCorpAccountService.getCorpAccountByCorpId(null);
                WeBackCustomerVo vo = null;
                if (Objects.nonNull(weCorpAccount)) {
                    vo = new WeBackCustomerVo();
                    vo.setToUserName(weCorpAccount.getCorpId());
                    vo.setState(state);
                    vo.setWelcomeCode(addExternalContact.getWelcomeCode());
                    // 企微人员的账号号
                    vo.setUserID(addExternalContact.getUserID());
                    // 客户的userid
                    vo.setExternalUserID(addExternalContact.getExternalUserID());
                }
                if (vo != null) {
                    if (StringUtils.isNotBlank(state) && state.startsWith(WeConstans.FISSION_PREFIX_RWB)) {
                        log.info("是 裂变-任务宝 推送消息，开始推送消息！");
                        // 是 裂变-任务宝 推送
                        // 推送消息
                        // 设置模板
                        myWeFissionMsgService.setTemplate(vo);
                        log.info("是 裂变-任务宝 推送消息，推送消息完成！");
                    } else if (StringUtils.isNotBlank(state) && state.contains(WeConstans.ZM)) {
                        log.info(" 自定义活动 推送消息......");
                        myQrCodeMsgService.setTemplate(vo);
                        log.info(" 自定义活动 推送消息完成");

                    } else if (StringUtils.isNotBlank(state) && state.contains(WeConstans.WE_QR_CODE_PREFIX)) {
                        log.info(" 活码 推送消息......");
                        myQrCodeMsgService.setTemplate(vo);
                        log.info(" 活码 推送消息完成");

                    } else if (StringUtils.isNotBlank(state) && state.startsWith(WeConstans.CAR)) {
                        log.info(" 自定义渠道[车险] 推送消息......");
                        carQrCodeService.setTemplate(vo);
                        log.info(" 自定义活动[车险]  推送消息完成");

                    } else if (StringUtils.isNotBlank(state) && state.startsWith(WeConstans.RENEWAL)) {
                        log.info(" 自定义渠道[续保管理] 推送消息......");
                        renewalService.setTemplate(vo);
                        log.info(" 自定义活动[续保管理]  推送消息完成");

                    } else {
                        // 不推送消息
                        log.info("不是 指定 推送消息，不推送！");
                    }

                    WeCustomerQuery weCustomerQuery = new WeCustomerQuery();
                    weCustomerQuery.setExternal_userid(addExternalContact.getExternalUserID());
                    weCustomerQuery.setCorpid(addExternalContact.getToUserName());
                    WeCustomerDetailVo customerDetail = qwCustomerClient.getCustomerDetail(weCustomerQuery).getData();
                    // 通过手机更新同步用户的状态时间
                    List<String> mobileList = customerDetail.getFollowUser().get(0).getRemarkMobiles();
                    Date now = new Date();
                    if (!CollectionUtils.isEmpty(mobileList)) {
                        LambdaQueryWrapper<WeUser> wrapper = new LambdaQueryWrapper<>();
                        wrapper.in(WeUser::getPhone, mobileList);
                        List<WeUser> userList = iWeUserService.list(wrapper);
                        if (!CollectionUtils.isEmpty(userList)) {
                            for (WeUser user : userList) {
                                user.setDeliveredStatus(1);
                                user.setAddTime(now);
                                user.setLastInteractionTime(now);
                            }
                            iWeUserService.saveOrUpdateBatch(userList);
                        }
                    }
                }
                // 同步客戶
                log.info("回调， 拉取业务员指定客户信息开始。。。");
//                iWeCustomerService.asyncWeCustomerByAddIds(ListUtil.toList(pubExternalContact.getUserID()));
                iWeCustomerService.addCustomer(addExternalContact.getExternalUserID(), addExternalContact.getUserID(), state);


            } else if ("change_external_contact".equals(event) && "edit_external_contact".equals(changeType)) {
                log.info("回调 编辑企业客户事件， 配置了客户联系功能的成员添加外部联系人时，回调该事件(编辑企业客户事件)");
                // 编辑企业客户事件
                EditExternalContact editExternalContact = XmlUtils.convertToJavaBean(msg, EditExternalContact.class);
                iWeCustomerService.updateCustomer(editExternalContact.getExternalUserID(), editExternalContact.getUserID());
            } else if ("change_external_contact".equals(event) && "del_external_contact".equals(changeType)) {
                // 员工删除客户，  客户还能给员工发信息，员工还能接收到信息， 员工显示 是否添加为联系人,然后企微同步的状态为删除
                // 客户删除员工，  员工不能给客户发信息，员工显示 不是好友，然后企微同步的状态为删除
                // 如果客户先删除员工，会回调事件（删除跟进成员事件）， 紧接着员工删除客户， 会调用事件（删除企业客户事件）
                // 如果员工先删除客户，会回调事件（删除企业客户事件）， 紧接着客户删除员工， 不会调用事件（删除跟进成员事件）

                // 删除企业客户事件（员工删除客户）
                log.info("回调 删除企业客户事件， 配置了客户联系功能的成员添加外部联系人时，回调该事件(业务员删除客户)");

                DelExternalContact delExternalContact = XmlUtils.convertToJavaBean(msg, DelExternalContact.class);

                List<WeCustomer> weCustomers = weCustomerMapper.selectList1(WeCustomer.builder()
                        .addUserId(delExternalContact.getUserID())
                        .externalUserid(delExternalContact.getExternalUserID())
                        .build());
                if (!CollectionUtils.isEmpty(weCustomers)) {
                    iWeCustomerService.update(WeCustomer.builder()
                            .delFlag(1)
                            .delFlagBei(1)
                            .tagIds(weCustomers.get(0).getTagIds())
                            .build(), new LambdaQueryWrapper<WeCustomer>()
                            .eq(WeCustomer::getAddUserId, delExternalContact.getUserID())
                            .eq(WeCustomer::getExternalUserid, delExternalContact.getExternalUserID()));
                    iWeCustomerTrajectoryService.createAddOrRemoveTrajectory(weCustomers.get(0).getExternalUserid(), weCustomers.get(0).getAddUserId(), false, false);

                }
            } else if ("change_external_contact".equals(event) && "del_follow_user".equals(changeType)) {
                // 删除跟进成员事件（客户删除员工）
                log.info("回调 删除跟进成员事件， 配置了客户联系功能的成员添加外部联系人时，回调该事件(企业成员被客户删除)");
                DelFollowUserContact delFollowUserContact = XmlUtils.convertToJavaBean(msg, DelFollowUserContact.class);

                Map<String, SysUser> currentTenantSysUser = iWeCustomerService.findCurrentTenantSysUser();
                SysUser sysUser = currentTenantSysUser.get(delFollowUserContact.getUserID());

                List<WeCustomer> weCustomers = weCustomerMapper.selectList1(WeCustomer.builder()
                        .addUserId(delFollowUserContact.getUserID())
                        .externalUserid(delFollowUserContact.getExternalUserID())
                        .build());
                if (!CollectionUtils.isEmpty(weCustomers)) {

                    iWeCustomerService.update(WeCustomer.builder()
                            .delFlagBa(1)
                            .delFlag(1)
                            .lossTime(new Date())
                            .tagIds(weCustomers.get(0).getTagIds())
                            .build(), new LambdaQueryWrapper<WeCustomer>()
                            .eq(WeCustomer::getAddUserId, delFollowUserContact.getUserID())
                            .eq(WeCustomer::getExternalUserid, delFollowUserContact.getExternalUserID()));
                    // 公海客户删除
                    if (CustomerAddWay.ADD_WAY_SSSJH.getKey().equals(weCustomers.get(0).getAddMethod())) {
                        log.info("删除公海客户.......{}", weCustomers.get(0).getCustomerName());
                        weCustomerSeasService.getBaseMapper().delete(new LambdaQueryWrapper<>(WeCustomerSeas.class)
                                .in(WeCustomerSeas::getPhone, ListUtil.toList(weCustomers.get(0).getPhone().split(",")))
                                .eq(WeCustomerSeas::getAddUserId, weCustomers.get(0).getAddUserId()));

                    }

                    iWeCustomerTrajectoryService.createAddOrRemoveTrajectory(weCustomers.get(0).getExternalUserid(), weCustomers.get(0).getAddUserId(), false, true);

                    //为被删除的员工发送一条消息提醒
                    iWeMessagePushService.pushMessageSelfH5(ListUtil.toList(delFollowUserContact.getUserID()), "【客户动态】<br/><br/> 客户@" + weCustomers.get(0).getCustomerName() + "刚刚删除了您", MessageNoticeType.DELETEWEUSER.getType(), false);
                    //添加消息通知
                    weMessageNotificationService.save(MessageTypeEnum.CUSTOMER.getType(), delFollowUserContact.getUserID(), MessageConstants.CUSTOMER_DELETE, weCustomers.get(0).getCustomerName());


                }


            }else if ("change_external_contact".equals(event) && "transfer_fail".equals(changeType)) {
                log.info("回调 客户接替失败事件， 企业将客户分配给新的成员接替后，客户添加失败时回调该事件");

            }else if ("change_external_chat".equals(event) && "create".equals(changeType)) {
                log.info("回调 客户群创建事件， 有新增客户群时，回调该事件。收到该事件后，企业可以调用获取客户群详情接口获取客户群详情。");

            }else if ("change_external_chat".equals(event) && "update".equals(changeType)) {
                log.info("回调 客户群变更事件， 客户群被修改后（群名变更，群成员增加或移除，群主变更，群公告变更），回调该事件。收到该事件后，企业需要再调用获取客户群详情接口，以获取最新的群详情。");

            }else if ("change_external_chat".equals(event) && "dismiss".equals(changeType)) {
                log.info("回调 客户群解散事件\n， 当客户群被群主解散后，回调该事件。\n" +
                        "需注意的是，如果发生群信息变动，会立即收到此事件，但是部分信息是异步处理，可能需要等一段时间(例如2秒)调用获取客户群详情接口才能得到最新结果");

            }else if ("change_external_tag".equals(event) && "create".equals(changeType)) {
                log.info("回调 企业客户标签创建事件\n， 企业/管理员创建客户标签/标签组时（包括规则组的标签），回调此事件。收到该事件后，企业需要调用获取企业标签库来获取标签/标签组的详细信息。");

            }else if ("change_external_tag".equals(event) && "update".equals(changeType)) {
                log.info("回调 企业客户标签变更事件\n， 当企业客户标签/标签组（包括规则组的标签）被修改时，回调此事件。收到该事件后，企业需要调用获取企业标签库来获取标签/标签组的详细信息");
            }else if ("change_external_tag".equals(event) && "delete".equals(changeType)) {
                log.info("回调 企业客户标签删除事件\n， 当企业客户标签/标签组被删除时，回调此事件。删除标签组时，该标签组下的所有标签将被同时删除，但不会进行回调。\n");
            }else if ("change_external_tag".equals(event) && "shuffle".equals(changeType)) {
                log.info("回调 企业客户标签重排事件\\n，当企业管理员在终端/管理端调整标签顺序时，可能导致标签顺序整体调整重排，引起大部分标签的order值发生变化，此时会回调此事件，收到此事件后企业应尽快全量同步标签的order值，防止后续调用接口排序出现非预期结果。 ");
            }


        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 客户欢迎语
     *
     * @param vo
     */
    @Override
    public void sendSubscribe(WeBackCustomerVo vo) {
        /*rabbitTemplate.convertAndSend(rabbitMQSettingConfig.getWeWelcomeMsgEx(),
                rabbitMQSettingConfig.getWeKfWelcomeMsgRk(),
                JSON.toJSONString(vo));*/
        myWeFissionMsgService.setTemplate(vo);
    }


}