feature(*): 公共池线索终止逻辑

- 角色调整总之公共池线索跟进 - 公共池跟进到期终止线索 - 线索终止后档案以及专属性的逻辑关系处理

feature(*): 公共池线索终止逻辑
- 角色调整总之公共池线索跟进 - 公共池跟进到期终止线索 - 线索终止后档案以及专属性的逻辑关系处理
张志伟
1 parent 1331548a
Showing 15 changed files with 405 additions and 33 deletions
doc/v2.0/update.sql
fw-valhalla-domain/src/main/java/cn/fw/valhalla/domain/db/customer/Customer.java
fw-valhalla-domain/src/main/java/cn/fw/valhalla/domain/db/pub/PubCluePool.java
fw-valhalla-domain/src/main/java/cn/fw/valhalla/domain/dto/CustomerDetailDto.java
fw-valhalla-domain/src/main/java/cn/fw/valhalla/domain/enums/DefeatReasonEnum.java
fw-valhalla-domain/src/main/java/cn/fw/valhalla/domain/enums/PublicPoolTypeEnum.java
fw-valhalla-server/src/main/java/cn/fw/valhalla/controller/task/PubFollowTask.java
fw-valhalla-service/src/main/java/cn/fw/valhalla/service/bus/LeaveNeedDoBizService.java
fw-valhalla-service/src/main/java/cn/fw/valhalla/service/bus/ReachLogBizService.java
fw-valhalla-service/src/main/java/cn/fw/valhalla/service/bus/cust/AbstractCustomerService.java
fw-valhalla-service/src/main/java/cn/fw/valhalla/service/bus/cust/CustomerBizService.java
fw-valhalla-service/src/main/java/cn/fw/valhalla/service/bus/follow/strategy/AbstractFollowStrategy.java
fw-valhalla-service/src/main/java/cn/fw/valhalla/service/bus/follow/strategy/impl/IRFollowStrategy.java
fw-valhalla-service/src/main/java/cn/fw/valhalla/service/bus/follow/strategy/impl/PubFollowStrategy.java
fw-valhalla-service/src/main/java/cn/fw/valhalla/service/bus/pub/PubFollowBizService.java
@@ -2,6 +2,9 @@ drop table if exists customer_clue_pool;
  
 drop table if exists follow_task;
  
+alter table customer
+    add last_arrival_shop bigint null comment '上次进站门店' after arrival_time;
+
 # 续保跟进模式
 INSERT INTO fw_valhalla.follow_setting_detail (setting_id, brand_id, type, detail_value, unit, group_id, yn,
                                                create_time, update_time)
@@ -61,6 +64,7 @@ CREATE TABLE IF NOT EXISTS fw_valhalla.pub_stand_staff_info
     shop_id             bigint       not null comment '门店id',
     shop_name           varchar(255) null comment '门店名称',
     group_id            bigint       not null comment '集团id',
+    defeat_reason       int(3)       null comment '关单原因 1:主动放弃 2:进另一门店 3:角色变动战败 4:到期战败',
     create_time         datetime     not null,
     update_time         datetime     null,
     constraint pub_stand_staff_info_staff_id_group_id_uindex
@@ -106,6 +106,10 @@ public class Customer extends BaseAuditableTimeEntity&lt;Customer, Long&gt; {
      */
     private Date arrivalTime;
     /**
+     * 上次进站门店
+     */
+    private Long lastArrivalShop;
+    /**
      * 进站次数
      */
     private Integer arrivalCount;
@@ -118,6 +122,10 @@ public class Customer extends BaseAuditableTimeEntity&lt;Customer, Long&gt; {
      */
     private Date insuranceExpires;
     /**
+     * 临时的专属顾问关系
+     */
+    private Boolean temporary;
+    /**
      * 所属服务站
      */
     private Long shopId;
@@ -3,6 +3,7 @@ package cn.fw.valhalla.domain.db.pub;
 import cn.fw.common.data.entity.BaseAuditableTimeEntity;
 import cn.fw.valhalla.domain.enums.PubStandType;
 import cn.fw.valhalla.domain.enums.PublicClueStateEnum;
+import cn.fw.valhalla.domain.enums.TaskDefeatTypeEnum;
 import lombok.Data;
  
 import java.time.LocalDate;
@@ -67,4 +68,8 @@ public class PubCluePool extends BaseAuditableTimeEntity&lt;PubCluePool, Long&gt; {
      * 集团id
      */
     private Long groupId;
+    /**
+     * 战败原因
+     */
+    private TaskDefeatTypeEnum defeatReason;
 }
@@ -184,6 +184,10 @@ public class CustomerDetailDto {
      */
     private Long shopId;
     /**
+     * 上次进站门店
+     */
+    private Long lastArrivalShop;
+    /**
      * 车价 （分）
      */
     private Long buyPrice;
@@ -14,11 +14,13 @@ import lombok.Getter;
 public enum DefeatReasonEnum implements IEnum<Integer> {
     /**
      * 保养卡流失
+     *
      * @deprecated
      */
     MC(1, "保养卡流失"),
     /**
      * 质保卡流失
+     *
      * @deprecated
      */
     WC(2, "质保卡流失"),
@@ -44,6 +46,7 @@ public enum DefeatReasonEnum implements IEnum&lt;Integer&gt; {
     RM(7, "流失预警划走"),
     /**
      * 客户变更
+     *
      * @deprecated
      */
     CC(8, "客户主动变更"),
@@ -56,10 +59,17 @@ public enum DefeatReasonEnum implements IEnum&lt;Integer&gt; {
      */
     LC(10, "客户分配"),
     /**
+     * 角色变动
+     */
+    RC(11, "角色变动"),
+    /**
+     * 线索逾期
+     */
+    CD(12, "线索逾期"),
+    /**
      * 其他原因
      */
-    OT(99, "其他原因")
-    ;
+    OT(99, "其他原因");
  
     /**
      * 值
@@ -28,6 +28,7 @@ public enum PublicPoolTypeEnum implements IEnum&lt;Integer&gt; {
      * 公共线索池过期
      */
     PD(4, "公共线索池过期"),
+    RC(5, "角色变动战败"),
     ;
  
     /**
+package cn.fw.valhalla.controller.task;
+
+import cn.fw.valhalla.common.utils.StringUtils;
+import cn.fw.valhalla.service.bus.pub.PubFollowBizService;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.data.redis.core.BoundSetOperations;
+import org.springframework.data.redis.core.StringRedisTemplate;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import org.springframework.util.CollectionUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 公共池线索任务
+ *
+ * @author : kurisu
+ * @version : 1.0
+ * @className : PubFollowTask
+ * @description : 公共池线索任务
+ * @date : 2023-03-21 16:11
+ */
+@Component
+@ConditionalOnProperty(prefix = "task", name = "switch", havingValue = "on")
+@Slf4j
+public class PubFollowTask {
+    private final StringRedisTemplate stringRedisTemplate;
+    private final PubFollowBizService pubFollowBizService;
+    @Value("${spring.cache.custom.global-prefix}:role-change-need-close:clue")
+    @Getter(AccessLevel.PRIVATE)
+    private String roleChangeNeedCloseClueKey;
+
+    public PubFollowTask(final StringRedisTemplate stringRedisTemplate,
+                         final PubFollowBizService pubFollowBizService) {
+        this.stringRedisTemplate = stringRedisTemplate;
+        this.pubFollowBizService = pubFollowBizService;
+    }
+
+    /**
+     * 处理角色变动战败公共池跟进线索
+     */
+    @Scheduled(cron = "0/20 * * * * *")
+    public void roleChangeDefeatClue() {
+        BoundSetOperations<String, String> setOps = stringRedisTemplate.boundSetOps(getRoleChangeNeedCloseClueKey());
+        List<String> failList = new ArrayList<>();
+        String idStr;
+        while ((idStr = setOps.pop()) != null) {
+            if (!StringUtils.isNumber(idStr)) {
+                continue;
+            }
+            try {
+                pubFollowBizService.roleChangeDefeatClue(idStr);
+            } catch (Exception e) {
+                if (StringUtils.isValid(idStr)) {
+                    failList.add(idStr);
+                }
+                log.error("处理角色变动结束公共池线索失败", e);
+            }
+        }
+        if (!CollectionUtils.isEmpty(failList)) {
+            String[] idArr = failList.toArray(new String[0]);
+            setOps.add(idArr);
+        }
+    }
+}
@@ -120,6 +120,7 @@ public class LeaveNeedDoBizService {
                 .eq(Customer::getAdviserId, userId)
                 .eq(Customer::getShopId, shopId)
                 .eq(Customer::getYn, Boolean.TRUE)
+                .and(w1 -> w1.eq(Customer::getTemporary, Boolean.FALSE).or().isNull(Customer::getTemporary))
         );
         if (count <= 0) {
             return;
@@ -152,6 +153,7 @@ public class LeaveNeedDoBizService {
             int i = customerService.count(Wrappers.<Customer>lambdaQuery()
                     .eq(Customer::getAdviserId, needDo.getUserId())
                     .eq(Customer::getYn, Boolean.TRUE)
+                    .and(w1 -> w1.eq(Customer::getTemporary, Boolean.FALSE).or().isNull(Customer::getTemporary))
             );
             list.add(LeaveNeedDoVO.with(needDo, i));
         }
@@ -184,6 +186,7 @@ public class LeaveNeedDoBizService {
         int i = customerService.count(Wrappers.<Customer>lambdaQuery()
                 .eq(Customer::getAdviserId, needDo.getUserId())
                 .eq(Customer::getYn, Boolean.TRUE)
+                .and(w1 -> w1.eq(Customer::getTemporary, Boolean.FALSE).or().isNull(Customer::getTemporary))
         );
         if (i > 0) {
             return;
@@ -312,7 +315,8 @@ public class LeaveNeedDoBizService {
      * @return 处理完的档案
      */
     private void doAllocation(LeaveAllocationDTO dto, String key) {
-        List<Customer> customerList = customerService.queryByAdviserId(dto.getAdviserId());
+        List<Customer> customerAllList = Optional.ofNullable(customerService.queryByAdviserId(dto.getAdviserId())).orElse(new ArrayList<>());
+        List<Customer> customerList = customerAllList.stream().filter(r -> !Boolean.TRUE.equals(r.getTemporary())).collect(Collectors.toList());
         if (CollectionUtils.isEmpty(customerList)) {
             return;
         }
@@ -456,6 +460,7 @@ public class LeaveNeedDoBizService {
                 .eq(Customer::getAdviserId, userId)
                 .eq(Customer::getShopId, shopId)
                 .eq(Customer::getYn, Boolean.TRUE)
+                .and(w1 -> w1.eq(Customer::getTemporary, Boolean.FALSE).or().isNull(Customer::getTemporary))
         ) > 0;
         BV.isTrue(bool, () -> "该顾问没有可用档案无需分配保有客");
         LeaveNeedDo db = new LeaveNeedDo();
@@ -56,6 +56,7 @@ public class ReachLogBizService {
         int count = Objects.nonNull(customer.getArrivalCount()) ? customer.getArrivalCount() : 0;
         customer.setArrivalTime(arrivalTime);
         customer.setArrivalCount(count + 1);
+        customer.setLastArrivalShop(reachLogReq.getShopId());
         customer.setCurrentMileage(reachLogReq.getArrivalMileage());
         customerService.updateById(customer);
     }
@@ -146,10 +146,10 @@ public abstract class AbstractCustomerService {
         dto.setGroupId(customer.getGroupId());
         dto.setVehicleLicense(customer.getVehicleLicense());
         dto.setShopId(customer.getShopId());
+        dto.setLastArrivalShop(customer.getLastArrivalShop());
         dto.setBuyPrice(customer.getBuyPrice());
         dto.setSource(Objects.isNull(customer.getSource()) ? null : customer.getSource().getValue());
         dto.setYn(customer.getYn());
-        dto.setShopId(customer.getShopId());
         return dto;
     }
  
@@ -17,6 +17,7 @@ import cn.fw.valhalla.domain.db.follow.FollowRecord;
 import cn.fw.valhalla.domain.db.pool.PublicCluePool;
 import cn.fw.valhalla.domain.db.pool.PublicPool;
 import cn.fw.valhalla.domain.db.pool.StammkundePool;
+import cn.fw.valhalla.domain.db.pub.PubCluePool;
 import cn.fw.valhalla.domain.dto.CustomerDetailDto;
 import cn.fw.valhalla.domain.enums.*;
 import cn.fw.valhalla.domain.query.CustomCustomerQuery;
@@ -579,10 +580,42 @@ public class CustomerBizService extends AbstractCustomerService {
     }
  
     /**
+     * 公共池跟进任务结束战败客户到公共池
+     *
+     * @param pubCluePool
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public void pubTaskEndAbandon(PubCluePool pubCluePool) {
+        Long groupId = pubCluePool.getGroupId();
+        CustomerDetailDto detailDto = queryByFrameNo(pubCluePool.getVin(), groupId);
+        if (Objects.isNull(detailDto)) {
+            return;
+        }
+        boolean updated = customerService.update(Wrappers.<Customer>lambdaUpdate()
+                .set(Customer::getAdviserId, null)
+                .set(Customer::getShopId, null)
+                .eq(Customer::getId, detailDto.getId()));
+        if (!updated) {
+            return;
+        }
+        stammkundePoolService.reject(detailDto.getId(), groupId, DefeatReasonEnum.CD);
+        publicCluePoolService.removeClue(detailDto.getId(), detailDto.getAdviserId());
+        AffiliationRecord entity = createEntity(detailDto);
+        entity.setReason("跟进超期");
+        affiliationRecordService.save(entity);
+        if (publicPoolService.queryByPlate(detailDto.getPlateNo(), detailDto.getGroupId()).isPresent()) {
+            return;
+        }
+        PublicPool publicPool = createPublicPool(detailDto, PublicPoolTypeEnum.PD, PublicPoolTypeEnum.PD.getName());
+        publicPoolService.save(publicPool);
+    }
+
+    /**
      * 继续跟进
-     * @deprecated
+     *
      * @param currentUser
      * @param customerId
+     * @deprecated
      */
     @DisLock(prefix = "#this.getKeyPrefix()", key = "'continueFollow:' + #customerId", message = "请勿重复提交")
     public void continueFollow(LoginAuthBean currentUser, final Long customerId) {
@@ -869,11 +902,11 @@ public class CustomerBizService extends AbstractCustomerService {
     }
  
     /**
-     * @deprecated  已弃用 sclie 2.0
      * @param customer
      * @param currentUser
      * @param rangeDTO
      * @param deadline
+     * @deprecated 已弃用 sclie 2.0
      */
     @Transactional(rollbackFor = Exception.class)
     public void createPublicPoolClue(Customer customer, LoginAuthBean currentUser, UserRoleDataRangeDTO rangeDTO, Date deadline) {
@@ -891,11 +924,12 @@ public class CustomerBizService extends AbstractCustomerService {
  
     /**
      * 创建公共池线索跟进
-     * @deprecated  已弃用 sclie 2.0
+     *
      * @param customerId
      * @param deadline
      * @param currentUser
      * @param rangeDTO
+     * @deprecated 已弃用 sclie 2.0
      */
     private void createPublicCluePool(Long customerId, Date deadline, LoginAuthBean currentUser, UserRoleDataRangeDTO rangeDTO) {
         final PublicCluePool publicCluePool = new PublicCluePool();
@@ -954,8 +988,9 @@ public class CustomerBizService extends AbstractCustomerService {
         pool.setCompany(dto.getCompanyName());
         pool.setType(type);
         pool.setReason(reason);
-        pool.setShopId(dto.getShopId());
-        ShopDTO shop = oopService.shop(dto.getShopId());
+        Long shopId = Optional.ofNullable(dto.getLastArrivalShop()).orElse(dto.getShopId());
+        pool.setShopId(shopId);
+        ShopDTO shop = oopService.shop(shopId);
         if (Objects.nonNull(shop)) {
             pool.setShopName(shop.getShortName());
         }
@@ -201,7 +201,9 @@ public abstract class AbstractFollowStrategy implements FollowStrategy {
             task.setReason(TaskDefeatTypeEnum.B);
         }
         boolean rpcSucess = rpcStopTask(task);
-        BV.isTrue(rpcSucess, () -> "跟进系统终止任务失败");
+        if (!rpcSucess) {
+            log.info("跟进系统终止任务失败");
+        }
         task.setRpcSuccess(rpcSucess);
         clueTaskService.updateById(task);
         if (Objects.nonNull(clue)) {
@@ -233,7 +235,9 @@ public abstract class AbstractFollowStrategy implements FollowStrategy {
         task.setReason(TaskDefeatTypeEnum.D);
         if (Objects.isNull(clue)) {
             boolean rpcSucess = rpcStopTask(task);
-            BV.isTrue(rpcSucess, () -> "跟进系统终止任务失败");
+            if (!rpcSucess) {
+                log.info("跟进系统终止任务失败");
+            }
             task.setRpcSuccess(rpcSucess);
             clueTaskService.updateById(task);
         } else {
@@ -248,7 +252,9 @@ public abstract class AbstractFollowStrategy implements FollowStrategy {
             }
  
             boolean rpcSucess = rpcStopTask(task);
-            BV.isTrue(rpcSucess, () -> "跟进系统终止任务失败");
+            if (!rpcSucess) {
+                log.info("跟进系统终止任务失败");
+            }
             task.setRpcSuccess(rpcSucess);
             clueTaskService.updateById(task);
  
@@ -124,7 +124,9 @@ public class IRFollowStrategy extends AbstractFollowStrategy {
             task.setReason(TaskDefeatTypeEnum.B);
         }
         boolean rpcSucess = rpcStopTask(task);
-        BV.isTrue(rpcSucess, () -> "跟进系统终止任务失败");
+        if (!rpcSucess) {
+            log.info("跟进系统终止任务失败");
+        }
         task.setRpcSuccess(rpcSucess);
         if (Objects.nonNull(clue) && redistribution) {
             clue.setClueState(ClueStatusEnum.FAILURE);
@@ -155,7 +157,9 @@ public class IRFollowStrategy extends AbstractFollowStrategy {
         task.setCloseTime(LocalDateTime.now());
         task.setReason(TaskDefeatTypeEnum.D);
         boolean rpcSucess = rpcStopTask(task);
-        BV.isTrue(rpcSucess, () -> "跟进系统终止任务失败");
+        if (!rpcSucess) {
+            log.info("跟进系统终止任务失败");
+        }
         task.setRpcSuccess(rpcSucess);
         if (Objects.nonNull(clue) && redistribution) {
             clue.setClueState(ClueStatusEnum.FAILURE);
+package cn.fw.valhalla.service.bus.follow.strategy.impl;
+
+import cn.fw.valhalla.domain.db.OriginalData;
+import cn.fw.valhalla.domain.db.follow.ClueTask;
+import cn.fw.valhalla.domain.db.follow.FollowClue;
+import cn.fw.valhalla.domain.db.pub.PubCluePool;
+import cn.fw.valhalla.domain.enums.FollowTypeEnum;
+import cn.fw.valhalla.domain.enums.PublicClueStateEnum;
+import cn.fw.valhalla.domain.enums.TaskDefeatTypeEnum;
+import cn.fw.valhalla.domain.enums.TaskStateEnum;
+import cn.fw.valhalla.service.bus.follow.strategy.AbstractFollowStrategy;
+import cn.fw.valhalla.service.data.PubCluePoolService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+
+import static cn.fw.common.businessvalidator.Validator.BV;
+
+/**
+ * 公共池线索跟进
+ *
+ * @author : kurisu
+ * @version : 1.0
+ * @className : PubFollowStrategy
+ * @description : 公共池线索跟进
+ * @date : 2023-03-21 16:52
+ */
+@Slf4j
+@Component
+public class PubFollowStrategy extends AbstractFollowStrategy {
+    private final PubCluePoolService pubCluePoolService;
+
+    @Autowired
+    public PubFollowStrategy(final PubCluePoolService pubCluePoolService) {
+        this.pubCluePoolService = pubCluePoolService;
+    }
+
+    @Override
+    public FollowTypeEnum getFollowType() {
+        return FollowTypeEnum.PL;
+    }
+
+    /**
+     * 公共池线索跟进此方法无效
+     *
+     * @param originalData
+     * @return
+     */
+    @Override
+    public boolean origin2task(final OriginalData originalData) {
+        return false;
+    }
+
+    @Override
+    public void startClue(final FollowClue followClue) {
+
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void onRoleChangeCloseTask(final ClueTask task) {
+        task.setState(TaskStateEnum.DEFEAT);
+        task.setCloseTime(LocalDateTime.now());
+        task.setReason(TaskDefeatTypeEnum.D);
+
+        boolean rpcSucess = rpcStopTask(task);
+        if (!rpcSucess) {
+            log.info("跟进系统终止任务失败");
+        }
+        task.setRpcSuccess(rpcSucess);
+        clueTaskService.updateById(task);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void closeTask(final ClueTask task) {
+        final Long clueId = task.getClueId();
+        PubCluePool pubCluePool = pubCluePoolService.getById(clueId);
+        BV.notNull(pubCluePool, () -> "公共池跟进线索不存在: " + clueId);
+        task.setState(TaskStateEnum.DEFEAT);
+        task.setCloseTime(task.getDeadline().minusSeconds(1L));
+        task.setReason(TaskDefeatTypeEnum.C);
+        boolean rpcSucess = rpcStopTask(task);
+        if (!rpcSucess) {
+            log.info("跟进系统终止任务失败");
+        }
+        task.setRpcSuccess(rpcSucess);
+        clueTaskService.updateById(task);
+        pubCluePool.setCloseTime(task.getCloseTime());
+        pubCluePool.setState(PublicClueStateEnum.DEFEAT);
+        pubCluePool.setDefeatReason(task.getReason());
+        pubCluePoolService.updateById(pubCluePool);
+        redisTemplate.opsForSet().add(generateStopKey(), String.valueOf(clueId));
+        customerBizService.pubTaskEndAbandon(pubCluePool);
+    }
+}
 package cn.fw.valhalla.service.bus.pub;
  
+import cn.fw.valhalla.domain.db.customer.Customer;
+import cn.fw.valhalla.domain.db.customer.CustomerBaseInfo;
+import cn.fw.valhalla.domain.db.follow.ClueTask;
+import cn.fw.valhalla.domain.db.pool.PublicPool;
 import cn.fw.valhalla.domain.db.pub.PubCluePool;
-import cn.fw.valhalla.domain.enums.PublicClueStateEnum;
+import cn.fw.valhalla.domain.enums.*;
+import cn.fw.valhalla.rpc.oop.OopService;
+import cn.fw.valhalla.rpc.oop.dto.ShopDTO;
+import cn.fw.valhalla.service.bus.follow.strategy.impl.PubFollowStrategy;
 import cn.fw.valhalla.service.bus.setting.SettingBizService;
-import cn.fw.valhalla.service.data.CustomerService;
-import cn.fw.valhalla.service.data.PubCluePoolService;
-import cn.fw.valhalla.service.data.StammkundePoolService;
+import cn.fw.valhalla.service.data.*;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import lombok.AccessLevel;
 import lombok.Getter;
-import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.redis.core.BoundSetOperations;
+import org.springframework.data.redis.core.StringRedisTemplate;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
  
+import java.time.LocalDateTime;
 import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+import static cn.fw.common.businessvalidator.Validator.BV;
  
 /**
  * 公共池跟进处理
@@ -29,41 +41,149 @@ import java.util.List;
  */
 @Slf4j
 @Service
-@RequiredArgsConstructor
 public class PubFollowBizService {
     private final PubCluePoolService pubCluePoolService;
+    private final PublicPoolService publicPoolService;
     private final StammkundePoolService stammkundePoolService;
     private final CustomerService customerService;
+    private final CustomerBaseInfoService customerBaseInfoService;
     private final SettingBizService settingBizService;
+    private final ClueTaskService clueTaskService;
+    private final StringRedisTemplate stringRedisTemplate;
+    private final OopService oopService;
+    private final PubFollowStrategy pubFollowStrategy;
     @Value("${follow.todo.PubFollowCode}")
     @Getter(AccessLevel.PRIVATE)
     private String pubFollowCode;
  
+    @Value("${spring.cache.custom.global-prefix}:role-change-need-close:clue")
+    @Getter(AccessLevel.PRIVATE)
+    private String roleChangeNeedCloseClueKey;
  
-    @Transactional(rollbackFor = Exception.class)
-    public void onRoleChange(Long userId, Long shopId) {
-        try {
-            List<PubCluePool> list = pubCluePoolService.list(Wrappers.<PubCluePool>lambdaQuery()
-                    .eq(PubCluePool::getAdviserId, userId)
-                    .eq(PubCluePool::getState, PublicClueStateEnum.ONGOING)
-            );
-
-            if (CollectionUtils.isEmpty(list)) {
-                return;
-            }
-
+    @Autowired
+    public PubFollowBizService(final PubCluePoolService pubCluePoolService,
+                               final PublicPoolService publicPoolService,
+                               final StammkundePoolService stammkundePoolService,
+                               final CustomerService customerService,
+                               final CustomerBaseInfoService customerBaseInfoService,
+                               final SettingBizService settingBizService,
+                               final ClueTaskService clueTaskService,
+                               final StringRedisTemplate stringRedisTemplate,
+                               final OopService oopService,
+                               final PubFollowStrategy pubFollowStrategy) {
+        this.pubCluePoolService = pubCluePoolService;
+        this.publicPoolService = publicPoolService;
+        this.stammkundePoolService = stammkundePoolService;
+        this.customerService = customerService;
+        this.customerBaseInfoService = customerBaseInfoService;
+        this.settingBizService = settingBizService;
+        this.clueTaskService = clueTaskService;
+        this.stringRedisTemplate = stringRedisTemplate;
+        this.oopService = oopService;
+        this.pubFollowStrategy = pubFollowStrategy;
+    }
  
-        } catch (Exception e) {
+    /**
+     * 人员角色变动或缓存需要战败的vin
+     *
+     * @param userId
+     * @param shopId
+     */
+    public void onRoleChange(Long userId, Long shopId) {
+        List<PubCluePool> list = pubCluePoolService.list(Wrappers.<PubCluePool>lambdaQuery()
+                .eq(PubCluePool::getAdviserId, userId)
+                .eq(PubCluePool::getState, PublicClueStateEnum.ONGOING)
+        );
+        if (CollectionUtils.isEmpty(list)) {
+            return;
+        }
+        BoundSetOperations<String, String> setOps = stringRedisTemplate.boundSetOps(getRoleChangeNeedCloseClueKey());
+        for (PubCluePool pool : list) {
+            setOps.add(String.valueOf(pool.getId()));
+        }
+    }
  
+    /**
+     * 角色变动结束线索
+     *
+     * @param id
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public void roleChangeDefeatClue(String id) {
+        PubCluePool pool = pubCluePoolService.getById(Long.valueOf(id));
+        if (Objects.isNull(pool)) {
+            return;
+        }
+        Customer customer = customerService.queryByFrameNo(pool.getVin(), pool.getGroupId());
+        endClue(pool);
+        if (Objects.nonNull(customer)) {
+            customerRemoval(customer);
         }
     }
  
     /**
      * 结束线索
+     *
      * @param pool
      */
     public void endClue(PubCluePool pool) {
+        ClueTask task = clueTaskService.getOne(Wrappers.<ClueTask>lambdaQuery()
+                        .eq(ClueTask::getClueId, pool.getId())
+                        .eq(ClueTask::getType, FollowTypeEnum.PL)
+                        .eq(ClueTask::getState, TaskStateEnum.ONGOING)
+                , Boolean.FALSE);
+
+        if (Objects.nonNull(task)) {
+            pubFollowStrategy.onRoleChangeCloseTask(task);
+        }
+        pool.setState(PublicClueStateEnum.DEFEAT);
+        pool.setCloseTime(LocalDateTime.now());
+        pool.setDefeatReason(TaskDefeatTypeEnum.D);
+        pubCluePoolService.updateById(pool);
+    }
+
+    /**
+     * 移除档案到公共池
+     *
+     * @param customer
+     */
+    private void customerRemoval(Customer customer) {
+        PublicPool publicPool = createPublicPool(customer);
+        publicPoolService.save(publicPool);
+        stammkundePoolService.reject(customer.getId(), customer.getGroupId(), DefeatReasonEnum.RC);
+        customer.setAdviserId(null);
+        customer.setShopId(null);
+        customerService.updateById(customer);
+    }
  
+    private PublicPool createPublicPool(Customer customer) {
+        final Long shopId = Optional.ofNullable(customer.getLastArrivalShop()).orElse(customer.getShopId());
+        ShopDTO shop = oopService.shop(shopId);
+        BV.notNull(shop, () -> String.format("门店[%s]信息获取失败", shopId));
+        String shopName = shop.getShortName();
+        final Long baseId = customer.getBaseId();
+        CustomerBaseInfo baseInfo = customerBaseInfoService.getById(baseId);
+        BV.notNull(baseInfo, () -> String.format("档案车主信息获取失败[%s]", baseId));
+        PublicPool pool = new PublicPool();
+        pool.setCustomerId(customer.getId());
+        pool.setCustomerName(baseInfo.getName());
+        pool.setPlateNo(customer.getPlateNo());
+        pool.setFrameNo(customer.getFrameNo());
+        pool.setBrandId(customer.getBrandId());
+        pool.setBrandName(customer.getBrandName());
+        pool.setSeriesId(customer.getSeriesId());
+        pool.setSeriesName(customer.getSeriesName());
+        pool.setSpecId(customer.getSpecId());
+        pool.setSpecName(customer.getSpecName());
+        pool.setAddress(baseInfo.getAddress());
+        pool.setCompany(baseInfo.getCompanyName());
+        pool.setType(PublicPoolTypeEnum.RC);
+        pool.setShopId(shopId);
+        pool.setShopName(shopName);
+        pool.setTimes(customer.getArrivalCount());
+        pool.setReason(PublicPoolTypeEnum.RC.getName());
+        pool.setGroupId(customer.getGroupId());
+        return pool;
     }
  
 }