valhalla / fw-valhalla

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

  import cn.fw.common.util.ValidationUtils;

  import cn.fw.common.web.annotation.DisLock;

  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.customer.AccidentPool;

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

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

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

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

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

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

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

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

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

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

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

  import cn.fw.valhalla.rpc.oop.dto.ShopDTO;
  import cn.fw.valhalla.service.bus.setting.SettingBizService;

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

  import com.baomidou.mybatisplus.core.toolkit.Wrappers;

  import lombok.Getter;

  import lombok.RequiredArgsConstructor;

  import lombok.extern.slf4j.Slf4j;

  import org.springframework.beans.BeanUtils;

  import org.springframework.beans.factory.annotation.Value;

  import org.springframework.stereotype.Service;
  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 static cn.fw.common.businessvalidator.Validator.BV;

  import static cn.fw.valhalla.service.bus.follow.strategy.AbstractFollowStrategy.getCalendarType;

  
  /**
   * @author : kurisu
   * @className : AccidentPoolBizService
   * @description : 事故池
   * @date: 2020-08-15 15:20
   */
  @Service
  @Slf4j

  @RequiredArgsConstructor

  public class AccidentPoolBizService {

      private final AccidentPoolService accidentPoolService;

      private final FollowTaskService followTaskService;

      private final FollowRecordService followRecordService;

      private final UserService userService;
      private final OopService oopService;

      private final SettingBizService settingBizService;

      private final TodoRpcService todoRpcService;

      private final CustomerCluePoolService customerCluePoolService;

      private final CustomerService customerService;

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

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

  
      @Transactional(rollbackFor = Exception.class)

      @DisLock(prefix = "#this.getKeyPrefix()", key = "#currentUser.groupId + ':' + #poolDTO.plateNo", message = "请勿重复提交")

      public Long add2Pool(LoginAuthBean currentUser, AccidentPoolDTO poolDTO) {
          boolean isPlateNo = ValidationUtils.checkCarPlate(poolDTO.getPlateNo());
          BV.isTrue(isPlateNo, () -> "车牌号不正确，请检查是否包含I、O或特殊字符");
          if (!Boolean.TRUE.equals(poolDTO.getForce())) {
              AccidentPool repetition = isRepetition(currentUser.getGroupId(), poolDTO.getPlateNo());
              if (Objects.nonNull(repetition)) {
                  return repetition.getCreateTime().getTime();
              }
          }
  

          if (StringUtils.isEmpty(poolDTO.getMobile())) {
              poolDTO.setMobile(poolDTO.getReportMobile());

          }

          AccidentPool pool = conversion2db(poolDTO, currentUser);
          pool.setShopId(poolDTO.getShopId());
          pool.setShopName(poolDTO.getShopName());
          BV.notNull(pool.getShopId(), () -> "服务站信息不正确，请确认");
          accidentPoolService.save(pool);
          afterAddPool(pool);

          return 0L;

      }
  

      private void afterAddPool(final AccidentPool pool) {
          final String plateNo = pool.getPlateNo();
          CustomerCluePool cluePool = customerCluePoolService.queryByPlateNo(plateNo, pool.getGroupId(), FollowTypeEnum.AC);
          if (Objects.nonNull(cluePool) && ClueStatusEnum.ONGOING.equals(cluePool.getClueStatus())) {
              cluePool.setClueStatus(ClueStatusEnum.FAILURE);

              cluePool.setCloseTime(new Date());

              customerCluePoolService.updateById(cluePool);
              clearTask(cluePool.getId(), cluePool.getGroupId());

          }

          CustomerCluePool clue = createClue(pool);
          FollowTask task = createTask(clue);
          createTaskRecord(task);

      }
  

      private AccidentPool conversion2db(AccidentPoolDTO dto, LoginAuthBean currentUser) {
          AccidentPool pool = new AccidentPool();
          BeanUtils.copyProperties(dto, pool);

          pool.setAddress(dto.getReportAddress());

          pool.setCreateTime(new Date());
          pool.setUpdateTime(new Date());
          pool.setGroupId(currentUser.getGroupId());
          return pool;
      }

      private AccidentPool isRepetition(Long groupId, String plateNo) {
          AccidentPool lastOne = accidentPoolService.getOne(Wrappers.<AccidentPool>lambdaQuery()

                  .eq(AccidentPool::getPlateNo, plateNo)
                  .eq(AccidentPool::getGroupId, groupId)

                  .orderByDesc(AccidentPool::getCreateTime)
                  .last(" limit 1 ")

          );

  
          if (Objects.isNull(lastOne)) {
              return null;
          }
  
          if (LocalDate.now().minusDays(7L).isBefore(DateUtil.date2LocalDate(lastOne.getCreateTime()))) {
              FollowTask lastOngoingTask = followTaskService.getOne(Wrappers.<FollowTask>lambdaQuery()
                      .eq(FollowTask::getCustomerId, lastOne.getId())
                      .eq(FollowTask::getType, FollowTypeEnum.AC)
                      .eq(FollowTask::getState, TaskStateEnum.ONGOING)
                      .last(" limit 1 ")
              );
  
              if (Objects.nonNull(lastOngoingTask)) {
                  return lastOne;
              }
          }
  
          return null;

      }

      /**

       * 清理跟进任务

       *

       * @param clueId

       * @param groupId

       */

      private void clearTask(Long clueId, Long groupId) {

          List<FollowTask> taskList = followTaskService.list(Wrappers.<FollowTask>lambdaQuery()
                  .eq(FollowTask::getGroupId, groupId)

                  .eq(FollowTask::getState, TaskStateEnum.ONGOING)

                  .eq(FollowTask::getClueId, clueId)

                  .eq(FollowTask::getType, FollowTypeEnum.AC)
          );

          if (!CollectionUtils.isEmpty(taskList)) {
              for (FollowTask task : taskList) {
                  clearRecord(task.getId());

                  task.setCloseTime(new Date());
                  task.setReason(TaskDefeatTypeEnum.E);

                  task.setState(TaskStateEnum.DEFEAT);

              }
              followTaskService.updateBatchById(taskList);

          }

      }
  
      /**
       * 清理对应任务的记录
       *
       * @param taskId
       */
      private void clearRecord(Long taskId) {
          followRecordService.remove(Wrappers.<FollowRecord>lambdaQuery()
                  .eq(FollowRecord::getTaskId, taskId)
                  .eq(FollowRecord::getAddTodo, Boolean.FALSE)
          );
          List<FollowRecord> list = followRecordService.list(Wrappers.<FollowRecord>lambdaQuery()
                  .eq(FollowRecord::getTaskId, taskId)
                  .eq(FollowRecord::getAddTodo, Boolean.TRUE)
                  .eq(FollowRecord::getOutTime, Boolean.FALSE)
                  .isNull(FollowRecord::getFollowTime)
          );
          if (CollectionUtils.isEmpty(list)) {
              return;
          }
          for (FollowRecord record : list) {

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

              BackLogItemDTO dto = new BackLogItemDTO(record.getUserId(), getACCode(), String.valueOf(record.getId()), DateUtil.localDateTime2Date(LocalDateTime.now()), record.getShopId());

              todoRpcService.cancel(dto);

          }
          followRecordService.updateBatchById(list);
      }

  
      /**
       * 新增线索
       *
       * @param pool
       * @return
       */
      private CustomerCluePool createClue(final AccidentPool pool) {

          final Customer customer = customerService.queryByPlateNo(pool.getPlateNo(), pool.getGroupId());

          final Date datetime = new Date();
          final CustomerCluePool cluePool = new CustomerCluePool();
          cluePool.setRefererId(pool.getId());
          cluePool.setPlateNo(pool.getPlateNo());
          cluePool.setClueType(FollowTypeEnum.AC);
          cluePool.setAddTime(datetime);
          cluePool.setStartTime(datetime);
          settingBizService.querySettingByType(FollowTypeEnum.AC, SettingTypeEnum.FAIL_TIME, pool.getGroupId())
                  .ifPresent(r -> {
                      Timestamp expired = DateUtil.getExpired(datetime, r.getDetailValue(), getCalendarType(Objects.requireNonNull(SettingUnitEnum.ofValue(r.getUnit()))));
                      cluePool.setDeadline(expired);
                  });
          cluePool.setClueStatus(ClueStatusEnum.ONGOING);
          cluePool.setRedistribution(Boolean.FALSE);
          ShopDTO shop = oopService.shop(pool.getShopId());
          BV.notNull(shop, () -> "门店信息有误");
          List<PostUserDTO> userByRole = userService.getUserByRole(pool.getShopId(), RoleCode.SGCGJ);
          BV.isFalse(CollectionUtils.isEmpty(userByRole), () -> "该门店没有事故车跟进人员");

          int randomIndex = new Random().nextInt(userByRole.size());
          PostUserDTO userDTO = userByRole.get(randomIndex);

          cluePool.setOriginalUserId(userDTO.getUserId());
          cluePool.setOriginalUserName(userDTO.getUserName());

          if (Objects.nonNull(customer)) {
              if (shop.getId().equals(customer.getShopId())) {
                  Optional<PostUserDTO> dto = userByRole.stream().filter(u -> u.getUserId().equals(customer.getAdviserId())).findFirst();
                  dto.ifPresent(d -> {
                      cluePool.setOriginalUserId(d.getUserId());
                      cluePool.setOriginalUserName(d.getUserName());
                  });
              }
          }

          cluePool.setOriginalShopId(shop.getId());

          cluePool.setOriginalShopName(shop.getShortName());

          cluePool.setGroupId(pool.getGroupId());
          cluePool.setCreateTime(new Date());
          customerCluePoolService.save(cluePool);
          return cluePool;
      }
  
      /**
       * 新增跟进任务
       *
       * @param pool
       * @return
       */
      private FollowTask createTask(final CustomerCluePool pool) {
          final FollowTask task = new FollowTask();
          task.setClueId(pool.getId());
          task.setCustomerId(pool.getRefererId());
          task.setType(FollowTypeEnum.AC);

          task.setState(TaskStateEnum.ONGOING);

          task.setBeginTime(pool.getStartTime());
          task.setRedistribution(Boolean.FALSE);
          task.setDeadline(pool.getDeadline());
          task.setFollowUser(pool.getOriginalUserId());

          task.setFollowUserName(pool.getOriginalUserName());

          task.setFollowShop(pool.getOriginalShopId());
          task.setGroupId(pool.getGroupId());
          task.setCreateTime(new Date());
          followTaskService.save(task);
          return task;
      }
  
      /**
       * 新增跟进代办任务
       *
       * @param task
       */
      private void createTaskRecord(final FollowTask task) {
          final FollowRecord record = new FollowRecord();
          record.setTaskId(task.getId());
          record.setType(FollowTypeEnum.AC);
          record.setCustomerId(task.getCustomerId());

          record.setUserId(task.getFollowUser());
          record.setUserName(task.getFollowUserName());

          record.setPlanTime(task.getBeginTime());
          settingBizService.querySettingByType(FollowTypeEnum.AC, SettingTypeEnum.EFFECTIVE_TIME, task.getGroupId())
                  .ifPresent(r -> {
                      Timestamp expired = DateUtil.getExpired(task.getBeginTime(), r.getDetailValue(), getCalendarType(Objects.requireNonNull(SettingUnitEnum.ofValue(r.getUnit()))));
                      record.setDeadline(expired);
                  });
          record.setOutTime(Boolean.FALSE);
          record.setAddTodo(Boolean.FALSE);
          record.setGroupId(task.getGroupId());
          record.setShopId(task.getFollowShop());

          record.setLimitTime(record.getDeadline());

          followRecordService.queryAndSave(record);

      }

  }