valhalla / fw-valhalla

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

import cn.fw.common.cache.locker.DistributedLocker;
import cn.fw.common.page.AppPage;
import cn.fw.common.web.auth.LoginAuthBean;
import cn.fw.valhalla.common.utils.DateUtil;
import cn.fw.valhalla.domain.db.ApproveRecord;
import cn.fw.valhalla.domain.db.OriginalData;
import cn.fw.valhalla.domain.db.follow.FollowRecord;
import cn.fw.valhalla.domain.db.follow.FollowTask;
import cn.fw.valhalla.domain.dto.FollowAttachmentDTO;
import cn.fw.valhalla.domain.enums.ApproveStateEnum;
import cn.fw.valhalla.domain.enums.ApproveTypeEnum;
import cn.fw.valhalla.domain.enums.FollowTypeEnum;
import cn.fw.valhalla.domain.enums.TaskStateEnum;
import cn.fw.valhalla.domain.query.FollowQueryVO;
import cn.fw.valhalla.domain.vo.follow.FollowDetailVO;
import cn.fw.valhalla.domain.vo.follow.FollowRecordVO;
import cn.fw.valhalla.domain.vo.follow.FollowTodoListVO;
import cn.fw.valhalla.domain.vo.setting.SettingVO;
import cn.fw.valhalla.rpc.erp.UserService;
import cn.fw.valhalla.rpc.erp.dto.UserInfoDTO;
import cn.fw.valhalla.rpc.flow.FlowApproveRpc;
import cn.fw.valhalla.rpc.flow.dto.FlowDto;
import cn.fw.valhalla.sdk.enums.DataTypeEnum;
import cn.fw.valhalla.service.bus.follow.strategy.FollowStrategy;
import cn.fw.valhalla.service.data.ApproveRecordService;
import cn.fw.valhalla.service.data.FollowRecordService;
import cn.fw.valhalla.service.data.FollowTaskService;
import cn.fw.valhalla.service.event.TaskCancelEvent;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.tuple.Pair;
import org.redisson.api.RLock;
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.concurrent.TimeUnit;
import java.util.stream.Collectors;

import static cn.fw.common.businessvalidator.Validator.BV;

/**
 * @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 FlowApproveRpc flowApproveRpc;
    private final ApproveRecordService approveRecordService;
    private final FollowTaskService followTaskService;
    private final FollowRecordService followRecordService;
    private final UserService userService;
    private final DistributedLocker distributedLocker;

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

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

    @Autowired
    public FollowBizService(final List<FollowStrategy> followStrategyList,
                            final FlowApproveRpc flowApproveRpc,
                            final ApproveRecordService approveRecordService,
                            final FollowTaskService followTaskService,
                            final FollowRecordService followRecordService,
                            final UserService userService,
                            final DistributedLocker distributedLocker) {
        this.followMap = followStrategyList.stream().collect(Collectors.toMap(FollowStrategy::getFollowType, v -> v));
        this.flowApproveRpc = flowApproveRpc;
        this.approveRecordService = approveRecordService;
        this.followTaskService = followTaskService;
        this.followRecordService = followRecordService;
        this.userService = userService;
        this.distributedLocker = distributedLocker;
    }

    /**
     * 查询待办列表
     *
     * @param queryVO
     * @param currentUser
     * @return
     */
    public AppPage<FollowTodoListVO> todoList(FollowQueryVO queryVO, LoginAuthBean currentUser) {
        Integer pageSize = queryVO.getPageSize();
        Integer current = queryVO.getCurrent();
        Integer startIndex = (current - 1) * pageSize;
        FollowStrategy strategy = followMap.get(queryVO.getType());
        Assert.notNull(strategy, "strategy cannot be null");
        List<FollowTodoListVO> list = strategy.getList(startIndex, pageSize, currentUser.getUserId());
        AppPage<FollowTodoListVO> appPage = AppPage.empty(queryVO);
        appPage.setData(list);
        return appPage;
    }

    /**
     * 查询待办详情
     *
     * @param id
     * @param type
     * @return
     */
    public FollowDetailVO todoDetail(Long id, FollowTypeEnum type) {
        FollowStrategy strategy = followMap.get(type);
        Assert.notNull(strategy, "strategy cannot be null");
        return strategy.getDetail(id);
    }

    /**
     * 查询跟进历史
     *
     * @param taskId
     * @param type
     * @return
     */
    public List<FollowRecordVO> todoRecord(Long taskId, FollowTypeEnum type) {
        FollowStrategy strategy = followMap.get(type);
        Assert.notNull(strategy, "strategy cannot be null");
        return strategy.getRecordList(taskId);
    }

    /**
     * 查询跟进池详情
     *
     * @param taskId
     * @return
     */
    public FollowDetailVO followPoolDetail(Long taskId) {
        FollowTask task = followTaskService.getById(taskId);
        BV.notNull(task, () -> "跟进线索不存在，请刷新列表");
        FollowStrategy strategy = followMap.get(task.getType());
        Assert.notNull(strategy, "strategy cannot be null");
        return strategy.followPoolDetail(task);
    }

    /**
     * 完成跟进
     *
     * @param id
     * @param currentUser
     */
    @Transactional(rollbackFor = Exception.class)
    public void completeRecord(Long id, FollowTypeEnum type, LoginAuthBean currentUser) {
        FollowStrategy strategy = followMap.get(type);
        Assert.notNull(strategy, "strategy cannot be null");
        strategy.completeRecord(id, currentUser);
    }

    /**
     * 完成跟进
     *
     * @param record
     */
    @Transactional(rollbackFor = Exception.class)
    public void completeRecord2(FollowRecord record) {
        FollowStrategy strategy = followMap.get(record.getType());
        Assert.notNull(strategy, "strategy cannot be null");
        strategy.completeRecord2(record);
    }

    /**
     * 查询待办详情
     *
     * @param id
     * @param type
     * @return
     */
    public FollowDetailVO approveDetail(Long id, FollowTypeEnum type) {
        FollowStrategy strategy = followMap.get(type);
        Assert.notNull(strategy, "strategy cannot be null");
        FollowDetailVO detail = strategy.getDetail(id);
        ApproveRecord approveRecord = approveRecordService.getOne(Wrappers.<ApproveRecord>lambdaQuery()
                .eq(ApproveRecord::getDataId, detail.getTaskId())
                .last("limit 1")
        );
        if (Objects.nonNull(approveRecord)) {
            UserInfoDTO user = userService.user(approveRecord.getUserId());
            if (Objects.nonNull(user)) {
                detail.setAdviserId(user.getId());
                detail.setAdviserName(user.getUserName());
            }
            detail.setReason(approveRecord.getReason());
        }
        return detail;
    }

    /**
     * 主动战败
     *
     * @param currentUser
     * @param reason
     * @param recordId
     */
    @Transactional(rollbackFor = Exception.class)
    public void defeat(LoginAuthBean currentUser, String reason, Long recordId) {
        final String lockKey = getLockKey(recordId);
        Pair<Boolean, RLock> pair = distributedLocker.tryLock(lockKey, TimeUnit.SECONDS, 0, 15);
        BV.isTrue(Boolean.TRUE.equals(pair.getKey()), () -> "请勿重复提交");
        try {
            FollowRecord record = followRecordService.getById(recordId);
            BV.notNull(record, () -> "跟进记录不存在");
            FollowTask task = followTaskService.getById(record.getTaskId());
            BV.notNull(task, () -> "跟进信息不存在");
            boolean repetition = isRepetition(record.getTaskId().toString());
            BV.isFalse(repetition, () -> "正在审批处理中，请勿重复申请");
            FlowDto flowDto = FlowDto.create(currentUser.getGroupId(), getFlowNo(), currentUser.getUserId(), currentUser.getUserName(), task.getFollowShop());
            HashMap<String, String> param = new HashMap<>(2);
            param.put("recordId", recordId.toString());
            param.put("type", task.getType().getValue().toString());
            flowDto.setParam(param);
            String name = "";
            String plate = "";
            FollowStrategy strategy = followMap.get(task.getType());
            Assert.notNull(strategy, "strategy cannot be null");
            FollowDetailVO vo = strategy.followPoolDetail(task);
            if (Objects.nonNull(vo)) {
                name = vo.getName();
                plate = vo.getPlateNo();
            }
            List<String> list = Arrays.asList(
                    "申请人: " + currentUser.getUserName(),
                    "客户: " + name,
                    "车辆: " + plate,
                    "跟进类型: " + task.getType().getName(),
                    "战败原因: " + reason
            );
            flowDto.setBriefContentList(list);
            String orderNo = flowApproveRpc.initiate(flowDto);
            ApproveRecord approveRecord = new ApproveRecord();
            approveRecord.setDataId(task.getId());
            approveRecord.setUserId(currentUser.getUserId());
            approveRecord.setOrderNo(orderNo);
            approveRecord.setReason(reason);
            approveRecord.setState(ApproveStateEnum.WAIT);
            approveRecord.setType(ApproveTypeEnum.FOLLOW_DEFEAT);
            approveRecord.setPassed(Boolean.FALSE);
            approveRecord.setCreateTime(DateUtil.localDateTime2Date(LocalDateTime.now()));
            approveRecord.setUpdateTime(DateUtil.localDateTime2Date(LocalDateTime.now()));
            approveRecordService.save(approveRecord);
        } catch (Exception e) {
            distributedLocker.unlock(lockKey);
            throw e;
        }
    }

    /**
     * 上传跟进附件
     *
     * @param dto
     */
    @Transactional(rollbackFor = Exception.class)
    public void uploadAtt(FollowAttachmentDTO dto, LoginAuthBean currentUser) {
        FollowStrategy strategy = followMap.get(dto.getFollowType());
        Assert.notNull(strategy, "strategy cannot be null");
        strategy.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;
        }
        FollowStrategy strategy = followMap.get(typeEnum);
        Assert.notNull(strategy, "strategy cannot be null");
        strategy.cancelFollowTask(event.getCustomerId(), event.getGenerateTime(), event.getGroupId());
    }

    /**
     * 元数据生成任务
     *
     * @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");

        return strategy.origin2task(originalData);
    }

    /**
     * 创建跟进待办
     *
     * @param task
     */
    public Long createTaskRecord(FollowTask task) {
        FollowStrategy strategy = followMap.get(task.getType());
        Assert.notNull(strategy, "strategy cannot be null");

        return strategy.createFirstRecord(task);
    }

    /**
     * 逾期处理
     *
     * @param record
     */
    public void overdueProcessing(FollowRecord record) {
        FollowStrategy strategy = followMap.get(record.getType());
        Assert.notNull(strategy, "strategy cannot be null");

        strategy.overdueProcessing(record);
    }

    /**
     * 终止任务
     *
     * @param customerId
     */
    @Transactional(rollbackFor = Exception.class)
    public void stopTask(Long customerId) {
        List<FollowTypeEnum> typeList = Arrays.asList(FollowTypeEnum.FM, FollowTypeEnum.RM);
        List<FollowTask> list = followTaskService.list(Wrappers.<FollowTask>lambdaQuery()
                .eq(FollowTask::getCustomerId, customerId)
                .eq(FollowTask::getFinished, Boolean.FALSE)
                .eq(FollowTask::getState, TaskStateEnum.ONGOING)
                .in(FollowTask::getType, typeList)
        );
        if (CollectionUtils.isEmpty(list)) {
            return;
        }
        for (FollowTask task : list) {
            FollowStrategy strategy = followMap.get(task.getType());
            if (Objects.nonNull(strategy)) {
                strategy.stopFollowTask(task);
            }
        }
    }

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


    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 String getLockKey(Long recordId) {
        BV.notNull(recordId, "recordId cannot be null");

        return String.format("%s:lock:%s", getKeyPrefix(), recordId);
    }

    /**
     * 审批防重
     *
     * @param taskId
     * @return
     */
    private boolean isRepetition(String taskId) {
        return approveRecordService.count(Wrappers.<ApproveRecord>lambdaQuery()
                .eq(ApproveRecord::getDataId, taskId)
                .eq(ApproveRecord::getType, ApproveTypeEnum.FOLLOW_DEFEAT)
                .eq(ApproveRecord::getState, ApproveStateEnum.WAIT)
        ) > 0;
    }
}