valhalla / fw-valhalla

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

  import cn.fw.common.cache.locker.DistributedLocker;

  import cn.fw.common.exception.BusinessException;

  import cn.fw.common.web.auth.LoginAuthBean;

  import cn.fw.valhalla.common.constant.RoleCode;

  import cn.fw.valhalla.common.utils.DateUtil;

  import cn.fw.valhalla.common.utils.StringUtils;

  import cn.fw.valhalla.domain.db.OriginalData;

  import cn.fw.valhalla.domain.db.customer.Customer;

  import cn.fw.valhalla.domain.db.follow.FollowNoticeRecord;

  import cn.fw.valhalla.domain.db.follow.FollowRecord;

  import cn.fw.valhalla.domain.db.follow.FollowRecordLog;

  import cn.fw.valhalla.domain.db.follow.FollowTask;

  import cn.fw.valhalla.domain.db.pool.CustomerCluePool;
  import cn.fw.valhalla.domain.db.pool.StammkundePool;

  import cn.fw.valhalla.domain.dto.FollowAttachmentDTO;

  import cn.fw.valhalla.domain.enums.*;

  import cn.fw.valhalla.domain.vo.follow.FollowDetailVO;

  import cn.fw.valhalla.domain.vo.follow.FollowRecordVO;

  import cn.fw.valhalla.domain.vo.setting.SettingVO;

  import cn.fw.valhalla.rpc.angel.InsurerRpcService;
  import cn.fw.valhalla.rpc.angel.dto.InsuranceDTO;

  import cn.fw.valhalla.rpc.erp.TodoRpcService;

  import cn.fw.valhalla.rpc.erp.UserService;

  import cn.fw.valhalla.rpc.erp.dto.BackLogItemDTO;

  import cn.fw.valhalla.rpc.erp.dto.PostUserDTO;

  import cn.fw.valhalla.rpc.erp.dto.UserInfoDTO;

  import cn.fw.valhalla.rpc.erp.dto.UserRoleDataRangeDTO;

  import cn.fw.valhalla.rpc.oop.OopService;

  import cn.fw.valhalla.rpc.oop.dto.ShopDTO;

  import cn.fw.valhalla.service.bus.cust.CustomerBizService;
  import cn.fw.valhalla.service.bus.cust.CustomerChangeBizService;

  import cn.fw.valhalla.service.bus.setting.SettingBizService;

  import cn.fw.valhalla.service.data.*;

  import cn.fw.valhalla.service.event.CancelApproveEvent;

  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.context.ApplicationEventPublisher;

  import org.springframework.transaction.annotation.Transactional;

  import org.springframework.util.CollectionUtils;

  import java.sql.Timestamp;

  import java.time.LocalDate;

  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 : AbstractFollowStrategy

   * @description : 策略抽象类 FIXME 跟进功能职责可以在拆分得更细

   * @date: 2020-08-17 10:42
   */
  @Slf4j
  public abstract class AbstractFollowStrategy implements FollowStrategy {
      @Autowired
      protected CustomerService customerService;
      @Autowired
      protected CustomerBaseInfoService customerBaseInfoService;
      @Autowired

      protected CustomerBizService customerBizService;
      @Autowired

      protected InsurerRpcService insurerRpcService;
      @Autowired
      protected FollowTaskService followTaskService;
      @Autowired
      protected FollowRecordService followRecordService;

      @Autowired
      protected UserService userService;
      @Autowired

      protected FollowRecordLogService followRecordLogService;

      @Autowired
      protected FollowNoticeRecordService followNoticeRecordService;
      @Autowired
      protected SettingBizService settingBizService;

      @Autowired
      protected OopService oopService;

      @Autowired
      protected ApplicationEventPublisher eventPublisher;

      @Autowired
      protected TodoRpcService todoRpcService;

      @Autowired
      protected CustomerLoanInfoService customerLoanInfoService;

      @Autowired
      protected CustomerCluePoolService customerCluePoolService;

      @Autowired
      protected CustomerChangeBizService customerChangeBizService;

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

      @Value("${follow.todo.FMCode}")

      @Getter

      private String FMCode;
  
      @Value("${follow.todo.RMCode}")
      @Getter
      private String RMCode;
  
      @Value("${follow.todo.IRCode}")
      @Getter
      private String IRCode;
  
      @Value("${follow.todo.ACCode}")
      @Getter
      private String ACCode;

      /**
       * 单位转换
       *
       * @param unit
       * @return
       */
      public static int getCalendarType(SettingUnitEnum unit) {
          switch (unit) {
              case HOUR:
                  return Calendar.HOUR;
              case MONTH:
                  return Calendar.MONTH;
              case MINUTE:
                  return Calendar.MINUTE;
              default:
                  return Calendar.DATE;
          }
      }
  

      @Override
      public List<FollowRecordVO> getRecordList(Long taskId) {

          List<FollowRecord> followRecordList = new ArrayList<>();
          FollowTask task = followTaskService.getById(taskId);
          if (Objects.nonNull(task)) {
              Long clueId = task.getClueId();
              List<FollowTask> taskList = followTaskService.list(Wrappers.<FollowTask>lambdaQuery()
                      .eq(FollowTask::getClueId, clueId)
                      .ne(FollowTask::getId, taskId)
              );
              if (!CollectionUtils.isEmpty(taskList)) {
                  for (FollowTask followTask : taskList) {
                      List<FollowRecord> recordList = followRecordService.getRecordList(followTask.getId());
                      if (!CollectionUtils.isEmpty(recordList)) {
                          followRecordList.addAll(recordList);
                      }
                  }
              }
          }
          List<FollowRecord> recordList = followRecordService.getRecordList(taskId);
          if (!CollectionUtils.isEmpty(recordList)) {
              followRecordList.addAll(recordList);
          }

          if (CollectionUtils.isEmpty(followRecordList)) {
              return new ArrayList<>();
          }

          List<FollowRecord> records = followRecordList.stream().sorted(Comparator.comparing(FollowRecord::getId)).collect(Collectors.toList());

          List<Long> recordIds = followRecordList.stream().map(FollowRecord::getId).collect(Collectors.toList());

          List<FollowRecordLog> attachments = followRecordLogService.getListByRecordIds(recordIds);

          if (CollectionUtils.isEmpty(attachments)) {
              return new ArrayList<>();
          }
          List<FollowRecordVO> list = new ArrayList<>();

          for (FollowRecordLog attachment : attachments) {

              FollowRecordVO vo = new FollowRecordVO();
              vo.setAttachments(attachment.getAttachments());
              vo.setId(attachment.getId());
              vo.setRecordId(attachment.getRecordId());

              vo.setTaskId(taskId);

              vo.setAttType(attachment.getAttType());

              vo.setFeedbackType(attachment.getFeedbackType());

              vo.setFollowType(followRecordList.get(0).getType());
              vo.setUploadTime(attachment.getUploadTime());

              vo.setDescribes(attachment.getDescribes());

              int i = queryIndexFromRecords(records, attachment.getRecordId());

              vo.setTimes(i + 1);
              list.add(vo);
          }
          return list;
      }
  
      @Override

      @Transactional(rollbackFor = Exception.class)

      public void completeRecord(Long id, LoginAuthBean currentUser) {

          final String lockKey = getLockKey(id);
          Pair<Boolean, RLock> pair = distributedLocker.tryLock(lockKey, TimeUnit.SECONDS, 0, 15);
          BV.isTrue(Boolean.TRUE.equals(pair.getKey()), () -> "请勿重复提交");
          try {
              BV.isTrue(Boolean.TRUE.equals(pair.getKey()), () -> "请勿重复提交");
              FollowRecord record = followRecordService.getById(id);
              if (Objects.isNull(record)) {
                  return;
              }
              Long customerId = record.getCustomerId();
              Customer customer = customerService.getById(customerId);

              FollowTask task = followTaskService.getById(record.getTaskId());

              BV.notNull(customer, () -> "档案信息异常");
              if (Boolean.FALSE.equals(customer.getYn())) {
                  customer = customerService.queryByFrameNo(customer.getFrameNo(), customer.getGroupId());
                  BV.notNull(customer, () -> "用户档案不存在");

              }
              BV.isTrue(record.getUserId().equals(currentUser.getUserId()), () -> "无法完成非本人待办任务");
              BV.isTrue(Boolean.FALSE.equals(record.getOutTime()), () -> "无法完成已逾期的待办任务");
              final Date followTime = DateUtil.localDateTime2Date(LocalDateTime.now());

              record.setFollowTime(followTime);

              List<FollowRecordLog> list = followRecordLogService.list(Wrappers.<FollowRecordLog>lambdaQuery()

                      .eq(FollowRecordLog::getRecordId, record.getId())
              );

              BV.isNotEmpty(list, () -> "请上传跟进记录");
              boolean match = list.stream().allMatch(log -> Objects.nonNull(log.getFeedbackType()));
              BV.isTrue(match, () -> "请检查跟进记录是否已完成客户反馈的录入");

              followRecordService.updateById(record);

              if (Objects.nonNull(task)) {
                  task.setCustomerId(customer.getId());
                  int times = task.getTimes() == null ? 0 : task.getTimes();
                  task.setTimes(times + 1);
              }
              followTaskService.updateById(task);

              record.setCustomerId(customer.getId());
              this.addTaskRecord(record, false);
              BackLogItemDTO dto = new BackLogItemDTO(record.getUserId(), getItemCode(record.getType()), String.valueOf(record.getId()), followTime, record.getShopId());
              todoRpcService.complete(dto);
          } catch (Exception e) {
              distributedLocker.unlock(lockKey);
              throw e;

          }

      }
  
      @Override
      @Transactional(rollbackFor = Exception.class)

      public void completeRecordAndEnd(FollowRecord record) {

          boolean equals = Boolean.FALSE.equals(record.getOutTime()) && Objects.isNull(record.getFollowTime());
          if (!equals) {
              return;
          }

          final Date followTime = DateUtil.localDateTime2Date(LocalDateTime.now());
          record.setFollowTime(followTime);
          followRecordService.updateById(record);

          this.addTaskRecord(record, false);

          BackLogItemDTO dto = new BackLogItemDTO(record.getUserId(), getItemCode(record.getType()), String.valueOf(record.getId()), followTime, record.getShopId());

          todoRpcService.complete(dto);

      }
  

      /**
       * 生成跟进记录
       *
       * @param task

       * @param addDay 二次分配的情况+1天

       */

      @Override

      @Transactional(rollbackFor = Exception.class)

      public void startTask(FollowTask task, boolean addDay) {

          if (!task.getDeadline().after(task.getBeginTime()) || !task.getDeadline().after(DateUtil.localDateTime2Date(LocalDateTime.now()))) {

              return;

          }

          final FollowRecord record = new FollowRecord();
          record.setTaskId(task.getId());
          record.setCustomerId(task.getCustomerId());
          record.setType(task.getType());

          record.setUserId(task.getFollowUser());

          record.setUserName(task.getFollowUserName());

          Date planTime = DateUtil.startDate(task.getBeginTime());
          if (addDay) {
              planTime = DateUtil.startDate(DateUtil.getExpired(DateUtil.startDate(task.getBeginTime()), 1, Calendar.DATE));
          }
          record.setPlanTime(planTime);

          settingBizService.querySettingByType(task.getType(), SettingTypeEnum.EFFECTIVE_TIME, task.getGroupId())
                  .ifPresent(setting -> {

                      Date timestamp = calDate(setting, record.getPlanTime(), false);

                      record.setDeadline(timestamp);
                  });
          record.setOutTime(Boolean.FALSE);
          record.setGroupId(task.getGroupId());

          record.setShopId(task.getFollowShop());

          record.setCreateTime(DateUtil.localDateTime2Date(LocalDateTime.now()));

          followRecordService.queryAndSave(record);

      }

      @Override
      @Transactional(rollbackFor = Exception.class)
      public void overdueProcessing(FollowRecord record) {

          boolean bool = this.addTaskRecord(record, true);
          if (bool) {
              followRecordService.overdue(record.getId());
          }

      }
  

      /**
       * 查询跟进记录
       *
       * @param startIndex
       * @param pageSize
       * @param userId
       * @return
       */

      protected List<FollowRecord> list(Integer startIndex, Integer pageSize, Long userId, FollowTypeEnum followType) {

          String sql = String.format("limit %s,%s", startIndex, pageSize);
          return followRecordService.list(Wrappers.<FollowRecord>lambdaQuery()
                  .eq(FollowRecord::getUserId, userId)

                  .eq(FollowRecord::getType, followType)

                  .eq(FollowRecord::getOutTime, Boolean.FALSE)
                  .le(FollowRecord::getPlanTime, new Date())
                  .ge(FollowRecord::getDeadline, new Date())
                  .isNull(FollowRecord::getFollowTime)
                  .last(sql)
          );
      }
  

      abstract public FollowDetailVO assemble(Long customerId);
  

      /**
       * 查询档案正在生效的保险信息
       *
       * @param customerId
       * @return
       */
      protected Optional<InsuranceDTO> queryInsuInfo(Long customerId) {
          if (Objects.isNull(customerId)) {
              return Optional.empty();
          }
          InsuranceDTO insuranceDTO = insurerRpcService.queryInsByCustId(customerId);
          return Optional.ofNullable(insuranceDTO);
      }
  

      /**
       * 查询下表
       *
       * @param list
       * @param recordId
       * @return
       */
      private int queryIndexFromRecords(List<FollowRecord> list, Long recordId) {
          for (int i = 0; i < list.size(); i++) {
              Long id = list.get(i).getId();
              if (Objects.equals(id, recordId)) {
                  return i;
              }
          }
          return 0;
      }

  
      /**
       * 取消生成的跟进待办
       *

       * @param customerId
       * @param type

       */

      @Transactional(rollbackFor = Exception.class)

      protected void cancelFollowTodo(Long customerId, FollowTypeEnum type) {

          List<FollowRecord> list = Optional.ofNullable(followRecordService.list(Wrappers.<FollowRecord>lambdaQuery()

                  .eq(FollowRecord::getCustomerId, customerId)
                  .eq(FollowRecord::getType, type)

                  .isNull(FollowRecord::getFollowTime)
                  .ge(FollowRecord::getDeadline, new Date())

          )).orElse(new ArrayList<>());

          if (CollectionUtils.isEmpty(list)) {
              return;
          }
          List<Long> idList = new ArrayList<>();
          for (FollowRecord record : list) {

              if (Boolean.TRUE.equals(record.getAddTodo())) {

                  BackLogItemDTO dto = new BackLogItemDTO(record.getUserId(), getItemCode(record.getType()), String.valueOf(record.getId()), record.getPlanTime(), record.getShopId());

                  todoRpcService.cancel(dto);
              }

              idList.add(record.getId());

          }

          followRecordService.removeByIds(idList);

      }
  

      @Transactional(rollbackFor = Exception.class)

      protected void completeClue(CustomerCluePool cluePool, OriginalData originalData) {

          if (Objects.isNull(cluePool)) {
              return;
          }
          if (ClueStatusEnum.COMPLETE.equals(cluePool.getClueStatus()) || ClueStatusEnum.FAILURE.equals(cluePool.getClueStatus())) {
              return;
          }

          if (ClueStatusEnum.WAITING.equals(cluePool.getClueStatus())) {
              customerCluePoolService.removeById(cluePool.getId());
              return;
          }

          LocalDateTime deadline = DateUtil.date2LocalDateTime(cluePool.getDeadline());
          if (deadline.isAfter(DateUtil.date2LocalDateTime(originalData.getGenerateTime()))) {
              cluePool.setFinishShopId(originalData.getShopId());
              cluePool.setFinishUserId(originalData.getUserId());
              UserInfoDTO user = userService.user(originalData.getUserId());
              if (Objects.nonNull(user)) {
                  cluePool.setFinishUserName(user.getUserName());
              }
              ShopDTO shop = oopService.shop(originalData.getShopId());

              if (Objects.nonNull(shop)) {

                  cluePool.setFinishShopName(shop.getShortName());

              }

              cluePool.setCloseTime(originalData.getGenerateTime());

              cluePool.setClueStatus(ClueStatusEnum.COMPLETE);
              customerCluePoolService.updateById(cluePool);
              completeTask(cluePool);
          }
      }
  
      /**
       * 完成跟进
       *
       * @param pool
       */
      @Transactional(rollbackFor = Exception.class)
      protected void completeTask(CustomerCluePool pool) {
          FollowTask followTask = followTaskService.queryOngoingTaskByClueId(pool.getId());
          if (Objects.isNull(followTask)) {
              return;
          }

          followTask.setFinishUser(pool.getFinishUserId());

          followTask.setFinishUserName(pool.getFinishUserName());

          followTask.setFinishShop(pool.getFinishShopId());

          followTask.setCloseTime(pool.getCloseTime());

          boolean equals = followTask.getFollowUser().equals(pool.getFinishUserId());
          followTask.setState(equals ? TaskStateEnum.COMPLETE : TaskStateEnum.DEFEAT);

          if (!equals) {

              followTask.setReason(TaskDefeatTypeEnum.F);

          }

          boolean succeed = followTaskService.updateById(followTask);
          if (succeed) {
              completeTodo(followTask.getId());
              followNoticeRecordService.removeByClueId(followTask.getId());
              CancelApproveEvent event = new CancelApproveEvent(followTask.getId(), ApproveTypeEnum.FOLLOW_DEFEAT);
              eventPublisher.publishEvent(event);
          }
      }
  

      /**

       * 完成生成的跟进待办
       *
       * @param taskId
       */

      @Transactional(rollbackFor = Exception.class)

      protected void completeTodo(Long taskId) {

          followRecordService.remove(Wrappers.<FollowRecord>lambdaQuery()
                  .eq(FollowRecord::getTaskId, taskId)
                  .eq(FollowRecord::getOutTime, Boolean.FALSE)
                  .eq(FollowRecord::getAddTodo, Boolean.FALSE)
                  .isNull(FollowRecord::getFollowTime)
                  .ge(FollowRecord::getDeadline, new Date())
          );

          List<FollowRecord> list = Optional.ofNullable(followRecordService.list(Wrappers.<FollowRecord>lambdaQuery()
                  .eq(FollowRecord::getTaskId, taskId)
                  .eq(FollowRecord::getOutTime, Boolean.FALSE)

                  .eq(FollowRecord::getAddTodo, Boolean.TRUE)

                  .isNull(FollowRecord::getFollowTime)
                  .ge(FollowRecord::getDeadline, new Date())
          )).orElse(new ArrayList<>());
          if (CollectionUtils.isEmpty(list)) {
              return;
          }
          for (FollowRecord record : list) {

              BackLogItemDTO dto = new BackLogItemDTO(record.getUserId(), getItemCode(record.getType()), String.valueOf(record.getId()), record.getPlanTime(), record.getShopId());

              todoRpcService.complete(dto);

              record.setFollowTime(new Date());
              record.setOutTime(Boolean.FALSE);
          }
          followRecordService.updateBatchById(list);
      }
  

  
      /**
       * 更新任务
       *
       * @param list
       * @param setting
       */
      @Transactional(rollbackFor = Exception.class)

      protected void updateClue(List<CustomerCluePool> list, List<SettingVO> setting) {

          for (SettingVO vo : setting) {
              final Integer unit = vo.getUnit();
              final int value = Optional.ofNullable(vo.getDetailValue()).orElse(0);
              SettingUnitEnum unitEnum = SettingUnitEnum.ofValue(unit);
  
              if (SettingTypeEnum.FIRST_TRIGGER_TIME.getValue().equals(vo.getType())) {
                  if (Objects.nonNull(unitEnum) && value > 0) {
                      final int calendarType = getCalendarType(unitEnum);

                      list.forEach(clue -> {
                          Date originTime = clue.getAddTime();

                          Timestamp timestamp = DateUtil.getExpired(originTime, value, calendarType);

                          clue.setStartTime(timestamp);

                      });
                  }
              }
              if (SettingTypeEnum.FAIL_TIME.getValue().equals(vo.getType())) {
                  if (Objects.nonNull(unitEnum) && value > 0) {
                      final int calendarType = getCalendarType(unitEnum);

                      list.forEach(clue -> {
                          Date originTime = clue.getAddTime();

                          Timestamp timestamp = DateUtil.getExpired(originTime, value, calendarType);

                          clue.setDeadline(timestamp);

                      });
                  }
              }
          }

          customerCluePoolService.updateBatchById(list);

      }
  
      /**
       * 更新服务号消息记录
       *
       * @param list
       * @param vo
       */
      @Transactional(rollbackFor = Exception.class)

      protected void updateNoticeRecord(List<CustomerCluePool> list, SettingVO vo) {
          List<Long> idList = list.stream().map(CustomerCluePool::getId).collect(Collectors.toList());

          List<FollowNoticeRecord> noticeList = followNoticeRecordService.list(Wrappers.<FollowNoticeRecord>lambdaQuery()
                  .eq(FollowNoticeRecord::getStatus, SendStatusEnum.NOT_SENT)

                  .in(FollowNoticeRecord::getClueId, idList)

          );
          Integer unit = vo.getUnit();
          int value = Optional.ofNullable(vo.getDetailValue()).orElse(0);
          SettingUnitEnum unitEnum = SettingUnitEnum.ofValue(unit);
          if (Objects.isNull(unitEnum) || value <= 0) {
              return;
          }
          final int calendarType = getCalendarType(unitEnum);

          for (CustomerCluePool clue : list) {

              for (FollowNoticeRecord noticeRecord : noticeList) {

                  if (clue.getId().equals(noticeRecord.getClueId())) {
                      Date originTime = clue.getAddTime();

                      Timestamp timestamp = DateUtil.getExpired(originTime, value, calendarType);
                      noticeRecord.setSendTime(timestamp);
                  }
              }
          }
          followNoticeRecordService.updateBatchById(noticeList);
      }
  

      @Override
      @Transactional(rollbackFor = Exception.class)
      public void uploadAtt(FollowAttachmentDTO dto, Long userId) {
          FollowRecord record = followRecordService.getById(dto.getRecordId());
          if (Objects.isNull(record)) {
              return;

          }

          BV.isTrue(record.getUserId().equals(userId), () -> "无法跟进非本人待办任务");
          BV.isTrue(Boolean.FALSE.equals(record.getOutTime()), () -> "无法跟进已逾期的待办任务");

          FollowRecordLog recordLog = new FollowRecordLog();

          recordLog.setId(dto.getId());

          recordLog.setTaskId(record.getTaskId());

          recordLog.setAttachments(dto.getAttachments());
          recordLog.setFeedbackType(dto.getFeedbackTypeEnum());
          recordLog.setAttType(dto.getAttTypeEnum());
          recordLog.setDescribes(dto.getDescribes());
          recordLog.setRecordId(dto.getRecordId());

          if (Objects.isNull(dto.getId())) {
              recordLog.setUploadTime(new Date());
          }

          followRecordLogService.saveOrUpdate(recordLog);

          feedbackTask(record.getTaskId(), dto.getFeedbackTypeEnum());

      }

  
      /**
       * 生成任务实体
       *
       * @param originalData
       * @return
       */

      protected CustomerCluePool createClueInfo(final OriginalData originalData, FollowTypeEnum followType, Customer customer) throws Exception {

          final CustomerCluePool pool = new CustomerCluePool();

          pool.setOriginalUserId(customer.getAdviserId());
          pool.setOriginalShopId(customer.getShopId());
          UserInfoDTO user = userService.user(customer.getAdviserId());
          if (Objects.nonNull(user)) {
              pool.setOriginalUserName(user.getUserName());
          }
          ShopDTO shop = oopService.shop(originalData.getShopId());
          if (Objects.nonNull(shop)) {

              pool.setOriginalShopName(shop.getShortName());

          }

          pool.setClueType(followType);
          pool.setAddTime(originalData.getGenerateTime());
          pool.setClueStatus(ClueStatusEnum.WAITING);
          pool.setRedistribution(Boolean.FALSE);
          pool.setGroupId(originalData.getGroupId());
          pool.setCreateTime(new Date());

          settingBizService.querySettingByType(followType, SettingTypeEnum.FIRST_TRIGGER_TIME, originalData.getGroupId())

                  .ifPresent(r -> pool.setStartTime(calDate(r, originalData.getGenerateTime(), false)));

  
          settingBizService.querySettingByType(followType, SettingTypeEnum.FAIL_TIME, originalData.getGroupId())

                  .ifPresent(r -> pool.setDeadline(calDate(r, originalData.getGenerateTime(), false)));
          pool.setRefererId(customer.getId());
          pool.setFrameNo(customer.getFrameNo());
          pool.setPlateNo(customer.getPlateNo());

          return pool;
      }
  
      @Override
      @Transactional(rollbackFor = Exception.class)
      public void startClue(CustomerCluePool cluePool) {
          if (!ClueStatusEnum.WAITING.equals(cluePool.getClueStatus())) {
              return;
          }
          FollowTask task = createTask(cluePool, false);
          task.setFollowUser(cluePool.getOriginalUserId());

          task.setFollowUserName(cluePool.getOriginalUserName());

          task.setFollowShop(cluePool.getOriginalShopId());
          followTaskService.save(task);

          startTask(task, false);

          cluePool.setClueStatus(ClueStatusEnum.ONGOING);
      }
  
  
      @Override
      @Transactional(rollbackFor = Exception.class)

      public void closeTask(FollowTask task) throws BusinessException {

          final Long clueId = task.getClueId();
          final CustomerCluePool cluePool = customerCluePoolService.getById(clueId);

          task.setState(TaskStateEnum.DEFEAT);

          task.setCloseTime(new Date());
          if (Boolean.TRUE.equals(task.getRedistribution())) {
              task.setReason(TaskDefeatTypeEnum.C);

              followTaskService.updateById(task);

              customerBizService.abandon(task, false);

          } else if (Objects.nonNull(cluePool)) {

              if (LocalDateTime.now().isAfter((DateUtil.date2LocalDateTime(cluePool.getDeadline())))) {
                  cluePool.setCloseTime(new Date());
                  cluePool.setClueStatus(ClueStatusEnum.FAILURE);

                  customerCluePoolService.updateById(cluePool);

                  followTaskService.updateById(task);

              } else {
                  task.setReason(TaskDefeatTypeEnum.B);
                  if (Boolean.FALSE.equals(cluePool.getRedistribution())) {
                      StammkundePool stammkundePool = customerChangeBizService.changeFollowUser(task);
                      if (Objects.isNull(stammkundePool)) {
                          task.setReason(null);
                          task.setState(TaskStateEnum.ONGOING);
                          task.setCloseTime(null);
                          task.setDeadline(cluePool.getDeadline());
                          followTaskService.updateById(task);
                          return;
                      }
                      FollowTask followTask = createTask(cluePool, true);
                      followTask.setFollowUser(stammkundePool.getAdviserId());
                      followTask.setFollowUserName(stammkundePool.getAdviserName());
                      followTask.setFollowShop(stammkundePool.getShopId());
                      cluePool.setRedistribution(Boolean.TRUE);

                      followTaskService.updateById(task);

                      customerCluePoolService.updateById(cluePool);
                      followTaskService.save(followTask);
                      startTask(followTask, true);
                  }

              }

          }

          CancelApproveEvent event = new CancelApproveEvent(task.getId(), ApproveTypeEnum.FOLLOW_DEFEAT);
          eventPublisher.publishEvent(event);
      }
  

  
      @Override
      @Transactional(rollbackFor = Exception.class)
      public void forceStopClue(CustomerCluePool clue) {

          onStopClue(clue, TaskDefeatTypeEnum.A);

          customerCluePoolService.updateById(clue);