valhalla / fw-valhalla

package cn.fw.valhalla.service.bus.follow;

import cn.fw.common.web.annotation.DisLock;
import cn.fw.common.web.auth.LoginAuthBean;
import cn.fw.valhalla.common.utils.DateUtil;
import cn.fw.valhalla.domain.db.OriginalData;
import cn.fw.valhalla.domain.db.SecretReportHistory;
import cn.fw.valhalla.domain.db.customer.Customer;
import cn.fw.valhalla.domain.db.follow.ClueTask;
import cn.fw.valhalla.domain.db.follow.FollowClue;
import cn.fw.valhalla.domain.db.follow.FollowRecord;
import cn.fw.valhalla.domain.db.follow.FollowRecordLog;
import cn.fw.valhalla.domain.db.pool.PublicCluePool;
import cn.fw.valhalla.domain.dto.CallReportDTO;
import cn.fw.valhalla.domain.dto.FollowAttachmentDTO;
import cn.fw.valhalla.domain.enums.AttTypeEnum;
import cn.fw.valhalla.domain.enums.ClueStatusEnum;
import cn.fw.valhalla.domain.enums.FollowTypeEnum;
import cn.fw.valhalla.domain.enums.PublicClueStateEnum;
import cn.fw.valhalla.domain.vo.setting.SettingVO;
import cn.fw.valhalla.rpc.shirasawa.ShirasawaRpcService;
import cn.fw.valhalla.sdk.enums.DataTypeEnum;
import cn.fw.valhalla.service.bus.follow.strategy.FollowStrategy;
import cn.fw.valhalla.service.data.*;
import cn.fw.valhalla.service.event.TaskCancelEvent;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author : kurisu
 * @className : FollowBizService
 * @description : 跟进业务服务
 * @date: 2020-08-14 17:27
 */
@Slf4j
@Service
public class FollowBizService {
    /**
     * 跟进处理器map
     */
    private final Map<FollowTypeEnum, FollowStrategy> followMap;
    private final PublicCluePoolService publicCluePoolService;
    private final FollowRecordService followRecordService;
    private final PCFollowBizService pcFollowBizService;
    private final SecretReportHistoryService secretReportHistoryService;
    private final FollowRecordLogService followRecordLogService;
    private final CustomerService customerService;
    private final FollowClueService followClueService;
    private final ShirasawaRpcService shirasawaRpcService;

    @Value("${follow.flowNo}")
    @Getter
    private String flowNo;

    @Value("${spring.cache.custom.global-prefix}:follow:defeat")
    @Getter
    private String keyPrefix;

    @Value("${spring.cache.custom.global-prefix}:follow:rpc:complete")
    @Getter
    private String completeKeyPrefix;

    @Autowired
    public FollowBizService(final List<FollowStrategy> followStrategyList,
                            final PublicCluePoolService publicCluePoolService,
                            final FollowRecordService followRecordService,
                            final PCFollowBizService pcFollowBizService,
                            final SecretReportHistoryService secretReportHistoryService,
                            final FollowRecordLogService followRecordLogService,
                            final CustomerService customerService,
                            final FollowClueService followClueService,
                            final ShirasawaRpcService shirasawaRpcService) {
        this.followMap = followStrategyList.stream().collect(Collectors.toMap(FollowStrategy::getFollowType, v -> v));
        this.publicCluePoolService = publicCluePoolService;
        this.followRecordService = followRecordService;
        this.pcFollowBizService = pcFollowBizService;
        this.secretReportHistoryService = secretReportHistoryService;
        this.followRecordLogService = followRecordLogService;
        this.customerService = customerService;
        this.followClueService = followClueService;
        this.shirasawaRpcService = shirasawaRpcService;
    }


    /**
     * 完成跟进
     *
     * @param recordId
     * @param userId
     */
    @DisLock(prefix = "#this.getCompleteKeyPrefix()", key = "#recordId + ':user-id:' + #userId", message = "请勿重复提交")
    public void completeRecord(final Long recordId, final Long userId) {
        shirasawaRpcService.completeRecordTodo(recordId, userId);
    }

    /**
     * 公共客户线索池上传跟进附件
     *
     * @param dto
     */
    @Transactional(rollbackFor = Exception.class)
    public void uploadAtt(FollowAttachmentDTO dto, LoginAuthBean currentUser) {
        pcFollowBizService.uploadAtt(dto, currentUser.getUserId());
    }

    /**
     * 更新跟进任务
     *
     * @param setting
     * @param type
     * @param groupId
     */
    public void synFollowTask(List<SettingVO> setting, FollowTypeEnum type, Long groupId) {
        FollowStrategy strategy = followMap.get(type);
        Assert.notNull(strategy, "strategy cannot be null");
        strategy.settingChanged(setting, groupId);
    }

    /**
     * 当业务数据取消的时候
     *
     * @param event
     */
    public void onDataCancel(TaskCancelEvent event) {
        FollowTypeEnum typeEnum = conv(event.getDataTypeEnum());
        if (Objects.isNull(typeEnum) || FollowTypeEnum.AC.equals(typeEnum)) {
            return;
        }
        Long customerId = event.getCustomerId();
        Long groupId = event.getGroupId();
        Customer customer = customerService.queryById(customerId);
        if (Objects.isNull(customer)) {
            return;
        }
        FollowClue followClue = followClueService.getOne(Wrappers.<FollowClue>lambdaQuery()
                        .eq(FollowClue::getVin, customer.getFrameNo())
                        .eq(FollowClue::getGroupId, groupId)
                        .eq(FollowClue::getClueType, typeEnum)
                        .eq(FollowClue::getClueState, ClueStatusEnum.WAITING)
                , Boolean.FALSE);
        if (Objects.isNull(followClue)) {
            return;
        }
        followClueService.removeById(followClue.getId());
    }

    /**
     * 元数据生成任务
     *
     * @param originalData
     * @param typeEnum
     */
    public boolean origin2task(OriginalData originalData, DataTypeEnum typeEnum) {
        if (Objects.isNull(originalData)) {
            return true;
        }
        FollowTypeEnum type = conv(typeEnum);
        FollowStrategy strategy = followMap.get(type);
        Assert.notNull(strategy, "strategy cannot be null");
        try {
            return strategy.origin2task(originalData);
        } catch (Exception exception) {
            log.error("处理元数据失败 data: [{}]", originalData, exception);
            return false;
        }
    }

    /**
     * 开始线索
     *
     * @param cluePool
     */
    public void startClue(FollowClue cluePool) {
        try {
            FollowStrategy strategy = followMap.get(cluePool.getClueType());
            Assert.notNull(strategy, "strategy cannot be null");

            strategy.startClue(cluePool);
        } catch (Exception e) {
            log.error("开始线索失败 data: [{}]", cluePool, e);
        }
    }

    /**
     * 定时任务结束任务
     *
     * @param task
     */
    public void endTask(ClueTask task) {
        FollowStrategy strategy = followMap.get(task.getType());
        Assert.notNull(strategy, "strategy cannot be null");
        try {
            strategy.closeTask(task);
        } catch (Exception ex) {
            log.error("定时任务结束任务失败 taskId: [{}]", task.getId(), ex);
        }
    }

    /**
     * 角色变动结束任务
     *
     * @param task
     */
    public void roleChangeEndTask(ClueTask task) {
        FollowStrategy strategy = followMap.get(task.getType());
        Assert.notNull(strategy, "strategy cannot be null");
        strategy.onRoleChangeCloseTask(task);
    }

    /**
     * 任务结束同步状态到跟进系统
     *
     * @param task
     */
    public void syncEndTask(ClueTask task) {
        FollowStrategy strategy = followMap.get(task.getType());
        Assert.notNull(strategy, "strategy cannot be null");
        try {
            strategy.syncEndTask(task);
        } catch (Exception ex) {
            log.error("任务结束同步状态到跟进系统失败 taskId: [{}]", task.getId(), ex);
        }
    }

    /**
     * 推送下一次跟进待办
     *
     * @param clue
     */
    public void createNextFollowTodo(FollowClue clue) {
        FollowStrategy strategy = followMap.get(clue.getClueType());
        Assert.notNull(strategy, "strategy cannot be null");
        try {
            strategy.createNextFollowTodo(clue);
        } catch (Exception ex) {
            log.error("推送下一次跟进待办失败 ckueId: [{}]", clue.getId(), ex);
        }
    }

    /**
     * 跟进完成
     *
     * @param task
     * @param preRecordId
     * @param originTime
     * @param overdue     逾期
     */
    public void afterFollowComplete(ClueTask task, Long preRecordId, Date originTime, boolean overdue) {
        FollowStrategy strategy = followMap.get(task.getType());
        Assert.notNull(strategy, "strategy cannot be null");
        strategy.onFollowComplete(task, preRecordId, DateUtil.date2LocalDate(originTime), overdue);
    }

    /**
     * 档案进入公共池任务战败
     *
     * @param vin
     * @param groupId
     */
    @Transactional(rollbackFor = Exception.class)
    public void stopTask(String vin, Long groupId) {
        List<FollowTypeEnum> typeList = Arrays.asList(FollowTypeEnum.FM, FollowTypeEnum.RM);

        List<FollowClue> cluePoolList = followClueService.list(Wrappers.<FollowClue>lambdaQuery()
                .eq(FollowClue::getClueState, ClueStatusEnum.ONGOING)
                .in(FollowClue::getClueType, typeList)
                .eq(FollowClue::getVin, vin)
                .eq(FollowClue::getGroupId, groupId)
        );
        if (!CollectionUtils.isEmpty(cluePoolList)) {
            for (FollowClue clue : cluePoolList) {
                FollowStrategy strategy = followMap.get(clue.getClueType());
                if (Objects.nonNull(strategy)) {
                    strategy.forceStopClue(clue);
                }
            }
        }
    }

    /**
     * 终止任务
     *
     * @param task
     */
    @Transactional(rollbackFor = Exception.class)
    public void stopTask(ClueTask task) {
        FollowStrategy strategy = followMap.get(task.getType());
        if (Objects.nonNull(strategy)) {
            strategy.forceStopTask(task);
        }
    }

    /**
     * 监听智能电话通话记录
     *
     * @param dto
     * @param idArr
     */
    public void readCallReport(CallReportDTO dto, Long... idArr) {
        if (Objects.isNull(dto) || idArr == null || idArr.length <= 0) {
            return;
        }
        final Long talkTime = dto.getTalkTime();
        if (Objects.isNull(talkTime) || talkTime <= 0) {
            return;
        }
        completePublicRecord(dto, idArr);
    }


    /**
     * 手动开始任务
     */
    public void manualStartClue() {
        List<FollowClue> list = followClueService.list(Wrappers.<FollowClue>lambdaQuery()
                .eq(FollowClue::getClueState, ClueStatusEnum.WAITING)
                .le(FollowClue::getStartTime, DateUtil.localDateTime2Date(LocalDateTime.now()))
                .last("limit 0, 2000")
        );
        if (CollectionUtils.isEmpty(list)) {
            return;
        }
        for (FollowClue cluePool : list) {
            startClue(cluePool);
        }
    }


    private FollowTypeEnum conv(DataTypeEnum type) {
        switch (type) {
            case AS:
                return FollowTypeEnum.AC;
            case OD:
            case FM:
                return FollowTypeEnum.FM;
            case BI:
                return FollowTypeEnum.IR;
            case FS:
                return FollowTypeEnum.RM;
            default:
                return null;
        }
    }

    private void completePublicRecord(CallReportDTO reportDTO, Long... custIds) {
        try {
            List<PublicCluePool> cluePools = publicCluePoolService.list(Wrappers.<PublicCluePool>lambdaQuery()
                    .in(PublicCluePool::getCustomerId, Arrays.asList(custIds))
                    .eq(PublicCluePool::getState, PublicClueStateEnum.ONGOING)
                    .eq(PublicCluePool::getAdviserId, reportDTO.getStaffId())
            );
            if (CollectionUtils.isEmpty(cluePools)) {
                return;
            }

            List<Long> clueIds = cluePools.stream().map(PublicCluePool::getId).collect(Collectors.toList());

            List<FollowRecord> list = followRecordService.list(Wrappers.<FollowRecord>lambdaQuery()
                    .in(FollowRecord::getTaskId, clueIds)
                    .eq(FollowRecord::getType, FollowTypeEnum.OT)
                    .eq(FollowRecord::getAddTodo, Boolean.TRUE)
                    .eq(FollowRecord::getOutTime, Boolean.FALSE)
            );
            if (CollectionUtils.isEmpty(list)) {
                return;
            }
            List<SecretReportHistory> reportHistoryList = new ArrayList<>();

            for (FollowRecord record : list) {
                FollowAttachmentDTO dto = new FollowAttachmentDTO();
                dto.setAttachments(reportDTO.getCallId());
                dto.setTaskId(record.getTaskId());
                dto.setFollowType(FollowTypeEnum.OT.getValue());
                dto.setRecordId(record.getId());
                dto.setAttType(AttTypeEnum.SMART_PHONE.getValue());
                reportHistoryList.add(createHistory(reportDTO, record));
                pcFollowBizService.uploadAtt(dto, reportDTO.getStaffId());
            }
            secretReportHistoryService.saveBatch(reportHistoryList);
        } catch (Exception ex) {
            log.error("通话记录同步到跟进公共线索池客户记录失败：", ex);
        }
    }


    private SecretReportHistory createHistory(CallReportDTO reportDTO, FollowRecord record) {
        SecretReportHistory history = new SecretReportHistory();
        history.setTaskId(record.getTaskId());
        history.setTaskType(FollowTypeEnum.OT);
        history.setFollowRecordId(record.getId());
        history.setCallId(reportDTO.getCallId());
        history.setStaffId(reportDTO.getStaffId());
        history.setStaffName(reportDTO.getStaffName());
        history.setCustomerId(record.getCustomerId());
        history.setCallType(reportDTO.getDialType());
        history.setCallTime(reportDTO.getCallTime());
        history.setCallDuration(reportDTO.getTalkTime());
        history.setShopId(record.getShopId());
        history.setGroupId(record.getGroupId());
        int count = followRecordLogService.count(Wrappers.<FollowRecordLog>lambdaQuery()
                .eq(FollowRecordLog::getTaskId, record.getTaskId())
                .eq(FollowRecordLog::getAttType, AttTypeEnum.SMART_PHONE)
        );
        history.setFirstCall(count <= 0);
        return history;
    }
}