律师注销修改

alien-job/src/main/java/shop/alien/job/store/StoreMembershipCardJob.java

@@ -1,6 +1,7 @@
 package shop.alien.job.store;
 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.xxl.job.core.handler.annotation.XxlJob;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -9,6 +10,7 @@ import shop.alien.config.redis.BaseRedisService;
 import shop.alien.entity.store.*;
 import shop.alien.job.feign.AlienStoreFeign;
 import shop.alien.mapper.*;
+import shop.alien.util.type.LifeNoticeUtil;
 
 import java.util.Calendar;
 import java.util.Date;
@@ -57,6 +59,12 @@ public class StoreMembershipCardJob {
 
     private final LifeFansMapper lifeFansMapper;
 
+    private final LawyerUserMapper lawyerUserMapper;
+
+    private final LifeNoticeMapper lifeNoticeMapper;
+
+    private final LifeNoticeUtil lifeNoticeUtil;
+
     private final AlienStoreFeign alienStoreFeign;
 
     /**
@@ -118,11 +126,11 @@ public class StoreMembershipCardJob {
     }
 
     /**
-     * 定时清理已申请注销超过7天的商家与用户
+     * 定时清理已申请注销超过7天的商家、用户与律师
      */
     @XxlJob("cancellationOfBusinessJob")
     public void cancellationOfBusinessJob() {
-        log.info("处理已申请注销超过7天的商家与用户: " + new Date());
+        log.info("处理已申请注销超过7天的商家、用户与律师: " + new Date());
         int successCount = 0;
         int failCount = 0;
 
@@ -255,16 +263,6 @@ public class StoreMembershipCardJob {
                     if (date.compareTo(sevenDay) >= 0) {
                         // 删除已过注销时间的用户
                         lifeUserMapper.deleteById(lifeUser.getId());
-                        // 清理粉丝
-                        LambdaQueryWrapper<LifeFans> queryWrapper = new LambdaQueryWrapper<LifeFans>()
-                                .eq(LifeFans::getDeleteFlag, 0)
-                                .and(w -> w
-                                        .nested(n -> n.eq(LifeFans::getFollowedUserType, 1)
-                                                .eq(LifeFans::getFollowedRefId, lifeUser.getId()))
-                                        .or()
-                                        .nested(n -> n.eq(LifeFans::getFansUserType, 1)
-                                                .eq(LifeFans::getFansRefId, lifeUser.getId())));
-                        lifeFansMapper.delete(queryWrapper);
                         successCount++;
                     }
                 }
@@ -274,6 +272,52 @@ public class StoreMembershipCardJob {
                         lifeUser.getId(), lifeUser.getUserPhone(), e.getMessage(), e);
             }
         }
+
+        // 获取处于注销冷静期的律师用户
+        List<LawyerUser> lawyerUsers = lawyerUserMapper.selectList(new LambdaQueryWrapper<LawyerUser>()
+                .eq(LawyerUser::getLogoutFlag, LOGOUT_FLAG_COOLING)
+                .eq(LawyerUser::getDeleteFlag, 0));
+        for (LawyerUser lawyerUser : lawyerUsers) {
+            try {
+                if (lawyerUser.getLogoutTime() != null) {
+                    Date logoutTime = lawyerUser.getLogoutTime();
+                    Calendar calendar = Calendar.getInstance();
+                    calendar.setTime(logoutTime);
+                    calendar.add(Calendar.DAY_OF_YEAR, 7);
+                    Date sevenDay = calendar.getTime();
+                    Date date = new Date();
+                    if (date.compareTo(sevenDay) >= 0) {
+                        log.info("律师账号冷静期结束，执行注销: lawyerId={}, phone={}, logoutTime={}",
+                                lawyerUser.getId(), lawyerUser.getPhone(), logoutTime);
+
+                        String receiverKey = "lawyer_" + lawyerUser.getPhone();
+                        baseRedisService.delete(receiverKey);
+
+                        LawyerUser update = new LawyerUser();
+                        update.setId(lawyerUser.getId());
+                        update.setLogoutFlag(LOGOUT_FLAG_DONE);
+                        update.setStatus(0);
+                        update.setOrderReceivingStatus(0);
+                        update.setIsOnline(0);
+                        update.setIsRecommended(0);
+                        update.setDeleteFlag(1);
+                        update.setLastOnlineTime(date);
+                        lawyerUserMapper.updateById(update);
+
+//                        LambdaUpdateWrapper<LifeNotice> noticeUpdateWrapper = new LambdaUpdateWrapper<>();
+//                        lifeNoticeUtil.applyReceiverUpdate(noticeUpdateWrapper, receiverKey);
+//                        noticeUpdateWrapper.set(LifeNotice::getDeleteFlag, 1);
+//                        lifeNoticeMapper.update(null, noticeUpdateWrapper);
+
+                        successCount++;
+                    }
+                }
+            } catch (Exception e) {
+                failCount++;
+                log.error("律师账号注销失败: lawyerId={}, phone={}, error={}",
+                        lawyerUser.getId(), lawyerUser.getPhone(), e.getMessage(), e);
+            }
+        }
         
         log.info("定时任务执行完成: 成功={}, 失败={}", successCount, failCount);
     }

alien-lawyer/src/main/java/shop/alien/lawyer/controller/LawyerUserController.java

@@ -223,9 +223,25 @@ public class LawyerUserController {
         return lawyerUserService.logOutLawyerUser(request);
     }
 
+    @ApiOperation("撤销律师注销申请")
+    @ApiOperationSupport(order = 14)
+    @PostMapping("/cancelLogoutLawyerUser")
+    public R<Boolean> cancelLogoutLawyerUser(@RequestBody LawyerUser lawyerUser) {
+        log.info("LawyerUserController.cancelLogoutLawyerUser?lawyerUser={}", lawyerUser);
+        if (lawyerUser == null || lawyerUser.getId() == null) {
+            return R.fail("律师ID不能为空");
+        }
+        try {
+            lawyerUserService.cancelLogoutLawyerUser(lawyerUser.getId());
+        } catch (IllegalArgumentException e) {
+            return R.fail(e.getMessage());
+        }
+        return R.success("撤回注销成功");
+    }
+
 
     @ApiOperation("律师信息详情")
-    @ApiOperationSupport(order = 14)
+    @ApiOperationSupport(order = 15)
     @ApiImplicitParams({
             @ApiImplicitParam(name = "lawyerId", value = "律师ID", dataType = "Integer", paramType = "query", required = true)
     })

alien-lawyer/src/main/java/shop/alien/lawyer/service/LawyerUserService.java

@@ -130,6 +130,13 @@ public interface LawyerUserService extends IService<LawyerUser> {
     R<Map<String, Object>> logOutLawyerUser(LawyerLogoutRequestDto request);
 
     /**
+     * 撤销律师注销申请（冷静期内）
+     *
+     * @param id 律师ID
+     */
+    void cancelLogoutLawyerUser(Integer id);
+
+    /**
      * 获取律师信息
      *
      * @param lawyerId 律师ID

alien-lawyer/src/main/java/shop/alien/lawyer/service/impl/LawyerUserServiceImpl.java

@@ -50,6 +50,9 @@ public class LawyerUserServiceImpl extends ServiceImpl<LawyerUserMapper, LawyerU
 
     private static final String LOGOUT_REASON_OTHER = "其他";
     private static final int LOGOUT_CONTENT_MAX_LENGTH = 300;
+    private static final int LOGOUT_FLAG_COOLING = 2;
+    private static final int LOGOUT_COOLING_DAYS = 7;
+    private static final String CANCEL_REVOKE_NOT_IN_COOLING_MSG = "当前账号不在注销冷静期内，无法撤销";
 
     private final LawyerUserMapper lawyerUserMapper;
     private final LawyerServiceAreaService lawyerServiceAreaService;
@@ -536,18 +539,17 @@ public class LawyerUserServiceImpl extends ServiceImpl<LawyerUserMapper, LawyerU
             return R.fail("律师不存在");
         }
 
-        String key = "lawyer_" + lawyerUser.getPhone();
-        String redisVerificationCode = baseRedisService.getString(key);
-        //对redisVerificationCode进行校验，如果不是空的话清除redis中的记录
-//        if (redisVerificationCode != null) {
-//            baseRedisService.delete(key);
-//        }
         // 检查是否已经注销
-        if (lawyerUser.getLogoutFlag() != null && lawyerUser.getLogoutFlag() == 1 && lawyerUser.getDeleteFlag() == 1) {
+        if (lawyerUser.getLogoutFlag() != null && lawyerUser.getLogoutFlag() == 1 && lawyerUser.getDeleteFlag() != null && lawyerUser.getDeleteFlag() == 1) {
             log.warn("注销律师用户失败：律师已注销，律师ID={}, 律师姓名={}", id, lawyerUser.getName());
             return R.fail("该律师账号已注销，无需重复注销");
         }
 
+        if (lawyerUser.getLogoutFlag() != null && lawyerUser.getLogoutFlag() == LOGOUT_FLAG_COOLING) {
+            log.warn("注销律师用户失败：律师已在注销冷静期中，律师ID={}", id);
+            return R.fail("账号已在注销冷静期中");
+        }
+
         // 检查是否已删除
         if (lawyerUser.getDeleteFlag() != null && lawyerUser.getDeleteFlag() == 1) {
             log.warn("注销律师用户失败：律师已删除，律师ID={}, 律师姓名={}", id, lawyerUser.getName());
@@ -570,48 +572,29 @@ public class LawyerUserServiceImpl extends ServiceImpl<LawyerUserMapper, LawyerU
         if (lawyerUser.getOrderReceivingStatus() != null) {
 
             if (CollectionUtils.isEmpty(list) && lawyerUser.getOrderReceivingStatus() == 0) {
-                // 设置注销相关字段
-                lawyerUser.setLogoutFlag(2); // 注销标记：1-已注销
-                lawyerUser.setLogoutTime(new Date()); // 注销时间
-                lawyerUser.setLogoutReason(logoutContent);
-                lawyerUser.setLogoutCode(logoutReason);
-                lawyerUser.setStatus(0); // 状态设置为禁用
-                lawyerUser.setOrderReceivingStatus(0); // 接单状态设置为不接单
-                lawyerUser.setIsOnline(0); // 在线状态设置为离线
-                lawyerUser.setIsRecommended(0); // 推荐状态设置为不推荐
+                // 进入注销冷静期（7天内可撤销）
+                lawyerUser.setLogoutFlag(LOGOUT_FLAG_COOLING);
+                lawyerUser.setLogoutTime(new Date());
+                lawyerUser.setLogoutReason(logoutReason);
+                lawyerUser.setLogoutCode(LOGOUT_REASON_OTHER.equals(logoutReason) ? logoutContent : null);
+                lawyerUser.setOrderReceivingStatus(0);
                 lawyerUser.setIsOnline(0);
-                lawyerUser.setDeleteFlag(1);
-                lawyerUser.setLastOnlineTime(new Date());
 
-                // 执行更新操作
                 int result = lawyerUserMapper.updateLawyerUser(lawyerUser);
-                if (result==0) {
+                if (result == 0) {
                     log.error("注销律师用户失败：更新数据库失败，律师ID={}", id);
                     return R.fail("注销失败，请稍后重试");
                 }
 
-                //对redisVerificationCode进行校验，如果不是空的话清除redis中的记录
-                if (redisVerificationCode != null) {
-                    baseRedisService.delete(key);
-                }
-
-                log.info("注销律师用户成功，律师ID={}, 律师姓名={}, 注销时间={}",
+                log.info("律师注销申请已提交，律师ID={}, 律师姓名={}, 注销时间={}",
                         id, lawyerUser.getName(), lawyerUser.getLogoutTime());
 
-
-                LambdaUpdateWrapper<LifeNotice> noticeUpdateWrapper = new LambdaUpdateWrapper<>();
-                lifeNoticeUtil.applyReceiverUpdate(noticeUpdateWrapper, key);
-                noticeUpdateWrapper.set(LifeNotice::getDeleteFlag, 1);
-                lifeNoticeMapper.update(null, noticeUpdateWrapper);
-
-                // 构建返回结果
                 resultMap.put("id", lawyerUser.getId());
                 resultMap.put("name", lawyerUser.getName());
                 resultMap.put("phone", lawyerUser.getPhone());
                 resultMap.put("logoutFlag", lawyerUser.getLogoutFlag());
                 resultMap.put("logoutTime", lawyerUser.getLogoutTime());
-                resultMap.put("status", lawyerUser.getStatus());
-                resultMap.put("message", "律师账号注销成功");
+                resultMap.put("message", "律师账号注销申请已提交");
             }
         }
 
@@ -619,6 +602,45 @@ public class LawyerUserServiceImpl extends ServiceImpl<LawyerUserMapper, LawyerU
     }
 
     @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void cancelLogoutLawyerUser(Integer id) {
+        if (id == null) {
+            throw new IllegalArgumentException("律师ID不能为空");
+        }
+        LawyerUser lawyerUser = this.getById(id);
+        if (lawyerUser == null) {
+            throw new IllegalArgumentException("律师不存在");
+        }
+        boolean logoutFlagCooling = lawyerUser.getLogoutFlag() != null
+                && lawyerUser.getLogoutFlag() == LOGOUT_FLAG_COOLING;
+        if (!logoutFlagCooling && !isLawyerInLogoutCoolingPeriod(lawyerUser)) {
+            throw new IllegalArgumentException(CANCEL_REVOKE_NOT_IN_COOLING_MSG);
+        }
+
+        LambdaUpdateWrapper<LawyerUser> updateWrapper = new LambdaUpdateWrapper<>();
+        updateWrapper.eq(LawyerUser::getId, id)
+                .set(LawyerUser::getLogoutFlag, 0)
+                .set(LawyerUser::getLogoutTime, null)
+                .set(LawyerUser::getLogoutReason, null)
+                .set(LawyerUser::getLogoutCode, null);
+        int updated = lawyerUserMapper.update(null, updateWrapper);
+        if (updated == 0) {
+            throw new IllegalArgumentException("撤销注销失败，请稍后重试");
+        }
+        log.info("律师撤销注销成功，律师ID={}", id);
+    }
+
+    private static boolean isLawyerInLogoutCoolingPeriod(LawyerUser lawyerUser) {
+        if (lawyerUser == null || lawyerUser.getLogoutTime() == null) {
+            return false;
+        }
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(lawyerUser.getLogoutTime());
+        calendar.add(Calendar.DAY_OF_YEAR, LOGOUT_COOLING_DAYS);
+        return !new Date().after(calendar.getTime());
+    }
+
+    @Override
     public R<LawyerUserVo> getLawyerInfo(Integer lawyerId) {
         log.info("LawyerUserServiceImpl.getLawyerInfo?lawyerId={}", lawyerId);