修改用户同步子系统

jeeplus-module/jeeplus-test/src/main/java/com/jeeplus/test/roster/service/RosterBaseService.java

@@ -1042,24 +1042,29 @@ public class RosterBaseService extends ServiceImpl<RosterBaseMapper, RosterBase>
      */
     public Map<String,Object> checkIsSyncFailed(String rosterId) {
         User user = userService.getOne(new LambdaQueryWrapper<User>().eq(User::getRosterId, rosterId));
-        // 查询当前用户推送子系统是否成功， isPush != 1说明未推送成功
-        List<SysUserFailedLog> sysUserFailedLogList = sysUserFailedLogService.list(new LambdaQueryWrapper<SysUserFailedLog>()
-                .eq(SysUserFailedLog::getUserId, user.getId())
-                .ne(SysUserFailedLog::getIsPush, "1")
-        );
         Map<String,Object> res = new HashMap<>();
-        if (sysUserFailedLogList.size() > 0) {
-            res.put("success", false);
-            List<String> msg = changeFailedLogToMsg(sysUserFailedLogList);
-            if (msg.size() > 0) {
-                String message = msg.stream().collect(Collectors.joining(","));
-                message = message + "，请重新推送后再进行尝试";
-                res.put("message", message);
+        if (ObjectUtil.isNotEmpty(user)) {
+            // 查询当前用户推送子系统是否成功， isPush != 1说明未推送成功
+            List<SysUserFailedLog> sysUserFailedLogList = sysUserFailedLogService.list(new LambdaQueryWrapper<SysUserFailedLog>()
+                    .eq(SysUserFailedLog::getUserId, user.getId())
+                    .ne(SysUserFailedLog::getIsPush, "1")
+            );
+            if (sysUserFailedLogList.size() > 0) {
+                res.put("success", false);
+                List<String> msg = changeFailedLogToMsg(sysUserFailedLogList);
+                if (msg.size() > 0) {
+                    String message = msg.stream().collect(Collectors.joining(","));
+                    message = message + "，请重新推送后再进行尝试";
+                    res.put("message", message);
+                } else {
+                    res.put("message", "有推送失败的数据，请重新推送后再进行尝试");
+                }
             } else {
-                res.put("message", "有推送失败的数据，请重新推送后再进行尝试");
+                res.put("success", true);
             }
         } else {
-            res.put("success", true);
+            res.put("success", false);
+            res.put("message", "没有获取到当前用户数据");
         }
         return res;
     }

jeeplus-platform/jeeplus-admin/src/main/java/com/jeeplus/sys/controller/UserController.java

@@ -29,6 +29,7 @@ import com.jeeplus.sys.domain.Office;
 import com.jeeplus.sys.domain.User;
 import com.jeeplus.sys.service.OfficeService;
 import com.jeeplus.sys.service.RoleService;
+import com.jeeplus.sys.service.RosterBaseCService;
 import com.jeeplus.sys.service.UserService;
 import com.jeeplus.sys.service.dto.OfficeDTO;
 import com.jeeplus.sys.service.dto.RoleDTO;
@@ -88,6 +89,9 @@ public class UserController {
     @Autowired
     private OfficeWrapper officeWrapper;
 
+    @Autowired
+    private RosterBaseCService rosterBaseCService;
+
     /**
      * 根据id查询用户
      *
@@ -303,25 +307,31 @@ public class UserController {
     public ResponseEntity delete(String ids) {
         String idArray[] = ids.split ( "," );
         StringBuffer msg = new StringBuffer ( );
+        Map<String,Object> resMap = new HashMap<>();
         boolean success = true;
         for (String id : idArray) {
             UserDTO userDTO = userService.get ( id );
             if ( UserUtils.getCurrentUserDTO ( ).getId ( ).equals ( userDTO.getId ( ) ) ) {
                 success = false;
-                msg.append ( "[" + userDTO.getLoginName ( ) + "]删除失败，不允许删除当前用户!<br/>" );
+                msg.append ( "[" + userDTO.getLoginName ( ) + "]删除失败，不允许删除当前用户<br/>" );
             } else if ( userDTO.isAdmin () ) {
                 success = false;
-                msg.append ( "[" + userDTO.getLoginName ( ) + "]删除失败，不允许删除超级管理员!<br/>" );//删除用户失败, 不允许删除超级管理员用户
+                msg.append ( "[" + userDTO.getLoginName ( ) + "]删除失败，不允许删除超级管理员<br/>" );//删除用户失败, 不允许删除超级管理员用户
             } else {
-                msg.append ( "[" + userDTO.getLoginName ( ) + "]删除成功!<br/>" );
-                userService.deleteUser ( userDTO );//删除用户成功
+                Map<String, Object> map = userService.deleteUser(userDTO);//删除用户
+                msg.append ( "[" + userDTO.getLoginName ( ) + "]"+ map.get("message") +"<br/>" );
+                if (!(Boolean) map.get("success")) {
+                    success = false;
+                }
             }
         }
+        resMap.put("message",msg.toString());
         if ( success ) {
-            return ResponseEntity.ok ( msg.toString ( ) );
+            resMap.put("success",true);
         } else {
-            return ResponseEntity.badRequest ( ).body ( msg.toString ( ) );
+            resMap.put("success",false);
         }
+        return ResponseEntity.ok ( resMap );
     }
 
     /**
@@ -779,4 +789,26 @@ public class UserController {
         Boolean updatePassword = userService.isUpdatePassword(userDTO.getId());
         return ResponseEntity.ok(updatePassword);
     }
+
+    /**
+     * 查询当前数据推送子系统是否成功
+     * @param userId
+     * @return
+     */
+    @GetMapping("checkIsSyncFailed")
+    public ResponseEntity checkIsSyncFailed(String userId) {
+        Map<String, Object> res = rosterBaseCService.checkIsSyncFailed(userId);
+        return ResponseEntity.ok (res);
+    }
+
+    /**
+     * 手动向子系统推送之前同步失败的数据
+     * @param userDTO
+     * @return
+     */
+    @PostMapping("pushUserSync")
+    public ResponseEntity pushUserSync(@RequestBody UserDTO userDTO) {
+        boolean s = userService.pushUserSync(userDTO.getId());
+        return ResponseEntity.ok (s);
+    }
 }

jeeplus-platform/jeeplus-admin/src/main/java/com/jeeplus/sys/domain/RosterBaseC.java

@@ -1,5 +1,6 @@
 package com.jeeplus.sys.domain;
 
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableName;
 import com.jeeplus.core.domain.BaseEntity;
 import com.jeeplus.core.query.Query;
@@ -226,5 +227,35 @@ public class RosterBaseC extends BaseEntity {
      */
     private String personType;
 
+    /**
+     * 密码
+     */
+    @TableField(exist = false)
+    private String newPassword;
+
+    /**
+     * 确认密码
+     */
+    @TableField(exist = false)
+    private String confirmNewPassword;
+
+    /**
+     * 是否允许登录
+     */
+    @TableField(exist = false)
+    private String loginFlag;
+
+    /**
+     * 访问其他系统权限
+     */
+    @TableField(exist = false)
+    private String otherServiceFlag;
+
+    /**
+     * 用户id
+     */
+    @TableField(exist = false)
+    private String userId;
+
     private static final long serialVersionUID = 1L;
 }

jeeplus-platform/jeeplus-admin/src/main/java/com/jeeplus/sys/service/RosterBaseCService.java

@@ -1,14 +1,243 @@
 package com.jeeplus.sys.service;
 
+import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.util.ObjectUtil;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.jeeplus.center.enums.ServiceAliasEnum;
+import com.jeeplus.centerservice.utils.RestTemplateService;
+import com.jeeplus.sys.domain.Office;
 import com.jeeplus.sys.domain.RosterBaseC;
+import com.jeeplus.sys.domain.SysUserFailedLog;
+import com.jeeplus.sys.domain.User;
 import com.jeeplus.sys.mapper.RosterBaseCMapper;
+import com.jeeplus.sys.service.dto.UserDTO;
+import com.jeeplus.sys.utils.StringUtils;
+import org.checkerframework.checker.units.qual.A;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
+
 @Service
 @Transactional(rollbackFor = Exception.class)
 public class RosterBaseCService extends ServiceImpl<RosterBaseCMapper, RosterBaseC> {
 
+    @Autowired
+    private OfficeService officeService;
+
+    @Autowired
+    private RestTemplateService restTemplateService;
+
+    @Autowired
+    private SysUserFailedLogService sysUserFailedLogService;
+
+    @Autowired
+    private UserService userService;
+
+    /**
+     * 推送其他系统同步保存用户信息
+     * @param rosterBase
+     */
+    public void syncPushSubsystem(RosterBaseC rosterBase, String oldOfficeId) {
+        // 接口所需参数
+        Map<String,Object> bodyMap = JSONObject.parseObject(JSON.toJSONString(rosterBase), Map.class);
+        // 判断是否有修改用户的所属部门(oldOfficeId为空，则直接进行保存推送)。
+        // 没有修改的话，则直接进行保存推送。有修改的话，要判断是否所属同一个子系统。
+        // 有修改的话。所属是同一个子系统 则直接进行保存推送，不是 则要清空旧所属系统的用户，再保存到新所属系统中
+        String pushType = "";
+        if (StringUtils.isNotBlank(oldOfficeId) && !oldOfficeId.equals(rosterBase.getOfficeId())) {
+            String officeCode1 = getServiceByOffice(oldOfficeId);
+            String officeCode2 = getServiceByOffice(rosterBase.getOfficeId());
+            if (StringUtils.isNotBlank(officeCode1) && StringUtils.isNotBlank(officeCode2) && !officeCode1.equals(officeCode2) && !ServiceAliasEnum.CPA_PUBLIC.getValue().equals(officeCode2)) {
+                // 有修改用户的所属部门，并且所属不是同一个子系统，修改后的所属部门不是公共部门时，则要清除旧所属系统的该用户，再保存到新所属系统中
+                pushType = "clear";
+            }
+        }
+        // 根据所属部门来判断，要向哪个子系统推送保存操作
+        // 根据部门id找出该部门的二级部门，获取这个二级部门的别名code
+        String officeCode = getServiceByOffice(rosterBase.getOfficeId());
+        // 清除旧所属系统的该用户
+        if (StringUtils.isNotBlank(pushType)&&pushType.equals("clear")) {
+            String officeCodeOld = getServiceByOffice(oldOfficeId);  // 根据这个部门id获取二级部门的别名code来获取所属哪个子系统
+            if (StringUtils.isNotBlank(officeCodeOld)) {
+                // 评估
+                if (ServiceAliasEnum.CPA_EVALUATION.getValue().equals(officeCodeOld) || (ServiceAliasEnum.CPA_PUBLIC.getValue().equals(officeCodeOld) && !ServiceAliasEnum.CPA_EVALUATION.getValue().equals(officeCode))) {
+                    // 首先将数据记录为清除失败，待获取到其他系统执行成功的回值后再将此记录删掉
+                    String dataId = sysUserFailedLogService.deleteFailedLog(rosterBase.getUserId(), ServiceAliasEnum.CPA_EVALUATION.getValue());
+                    // 调用其他系统的用户删除操作
+                    Object res = restTemplateService.postCPA_EVALUATION("/roster/base/deleteUserRoster",null,null,bodyMap);
+                    if (ObjectUtil.isNotEmpty(res)) {
+                        Map<String,Object> resMap = JSONObject.parseObject(JSON.toJSONString(res), Map.class);
+                        if ((Boolean) resMap.get("success")) {
+                            // 保存成功，将刚才记录的数据删除
+                            sysUserFailedLogService.removeById(dataId);
+                        }
+                    }
+                }
+                // 财务
+                if (ServiceAliasEnum.CPA_FINANCE.getValue().equals(officeCodeOld) || (ServiceAliasEnum.CPA_PUBLIC.getValue().equals(officeCodeOld) && !ServiceAliasEnum.CPA_FINANCE.getValue().equals(officeCode))) {
+                    // 首先将数据记录为清除失败，待获取到其他系统执行成功的回值后再将此记录删掉
+                    String dataId = sysUserFailedLogService.deleteFailedLog(rosterBase.getUserId(), ServiceAliasEnum.CPA_FINANCE.getValue());
+                    // 调用其他系统的用户删除操作
+                    Object res = restTemplateService.postCPA_FINANCE("/roster/base/deleteUserRoster",null,null,bodyMap);
+                    if (ObjectUtil.isNotEmpty(res)) {
+                        Map<String,Object> resMap = JSONObject.parseObject(JSON.toJSONString(res), Map.class);
+                        if ((Boolean) resMap.get("success")) {
+                            // 保存成功，将刚才记录的数据删除
+                            sysUserFailedLogService.removeById(dataId);
+                        }
+                    }
+                }
+                // 中审
+                if (ServiceAliasEnum.CPA_AUDIT.getValue().equals(officeCodeOld) || (ServiceAliasEnum.CPA_PUBLIC.getValue().equals(officeCodeOld)) && !ServiceAliasEnum.CPA_AUDIT.getValue().equals(officeCode)) {
+                    // 首先将数据记录为清除失败，待获取到其他系统执行成功的回值后再将此记录删掉
+                    String dataId = sysUserFailedLogService.deleteFailedLog(rosterBase.getUserId(), ServiceAliasEnum.CPA_AUDIT.getValue());
+                    // 调用其他系统的用户删除操作
+                    Object res = restTemplateService.postCPA_AUDIT("/roster/base/deleteUserRoster",null,null,bodyMap);
+                    if (ObjectUtil.isNotEmpty(res)) {
+                        Map<String,Object> resMap = JSONObject.parseObject(JSON.toJSONString(res), Map.class);
+                        if ((Boolean) resMap.get("success")) {
+                            // 保存成功，将刚才记录的数据删除
+                            sysUserFailedLogService.removeById(dataId);
+                        }
+                    }
+                }
+            }
+        }
+
+        // 向子系统推送保存操作
+        if (StringUtils.isNotBlank(officeCode)) {
+            // 评估
+            if (ServiceAliasEnum.CPA_EVALUATION.getValue().equals(officeCode) || ServiceAliasEnum.CPA_PUBLIC.getValue().equals(officeCode)) {
+                // 首先将数据记录为保存失败，待获取到其他系统执行成功的回值后再将此记录删掉
+                String dataId = sysUserFailedLogService.saveFailedLog(rosterBase.getUserId(), ServiceAliasEnum.CPA_EVALUATION.getValue());
+                // 调用其他系统的用户保存操作
+                Object res = restTemplateService.postCPA_EVALUATION("/roster/base/saveOrUpdateUserRoster",null,null,bodyMap);
+                if (ObjectUtil.isNotEmpty(res)) {
+                    Map<String,Object> resMap = JSONObject.parseObject(JSON.toJSONString(res), Map.class);
+                    if ((Boolean) resMap.get("success")) {
+                        // 保存成功，将刚才记录的数据删除
+                        sysUserFailedLogService.removeById(dataId);
+                    }
+                }
+            }
+            // 财务
+            if (ServiceAliasEnum.CPA_FINANCE.getValue().equals(officeCode) || ServiceAliasEnum.CPA_PUBLIC.getValue().equals(officeCode)) {
+                // 首先将数据记录为保存失败，待获取到其他系统执行成功的回值后再将此记录删掉
+                String dataId = sysUserFailedLogService.saveFailedLog(rosterBase.getUserId(), ServiceAliasEnum.CPA_FINANCE.getValue());
+                // 调用其他系统的用户保存操作
+                Object res = restTemplateService.postCPA_FINANCE("/roster/base/saveOrUpdateUserRoster",null,null,bodyMap);
+                if (ObjectUtil.isNotEmpty(res)) {
+                    Map<String,Object> resMap = JSONObject.parseObject(JSON.toJSONString(res), Map.class);
+                    if ((Boolean) resMap.get("success")) {
+                        // 保存成功，将刚才记录的数据删除
+                        sysUserFailedLogService.removeById(dataId);
+                    }
+                }
+            }
+            // 中审
+            if (ServiceAliasEnum.CPA_AUDIT.getValue().equals(officeCode) || ServiceAliasEnum.CPA_PUBLIC.getValue().equals(officeCode)) {
+                // 首先将数据记录为保存失败，待获取到其他系统执行成功的回值后再将此记录删掉
+                String dataId = sysUserFailedLogService.saveFailedLog(rosterBase.getUserId(), ServiceAliasEnum.CPA_AUDIT.getValue());
+                // 调用其他系统的用户保存操作
+                Object res = restTemplateService.postCPA_AUDIT("/roster/base/saveOrUpdateUserRoster",null,null,bodyMap);
+                if (ObjectUtil.isNotEmpty(res)) {
+                    Map<String,Object> resMap = JSONObject.parseObject(JSON.toJSONString(res), Map.class);
+                    if ((Boolean) resMap.get("success")) {
+                        // 保存成功，将刚才记录的数据删除
+                        sysUserFailedLogService.removeById(dataId);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * 根据部门id找出该部门的二级部门(包含此部门就是二级部门的可能)，然后获取这个二级部门的别名code
+     * @param officeId
+     * @return
+     */
+    public String getServiceByOffice(String officeId) {
+        String officeAlias = "";
+        Office office = officeService.getById(officeId);
+        if (ObjectUtil.isNotEmpty(office)) {
+            if (StringUtils.isNotBlank(office.getIsPublic()) && "1".equals(office.getIsPublic())) {
+                officeAlias = ServiceAliasEnum.CPA_PUBLIC.getValue(); // 共有部门
+            }else if (StringUtils.isNotBlank(office.getGrade()) && "2".equals(office.getGrade())) {
+                officeAlias =  StringUtils.isNotBlank(office.getCode()) ? office.getCode() : "";
+            } else {
+                if (StringUtils.isNotBlank(office.getParentIds())) {
+                    String[] split = office.getParentIds().split(",");
+                    List<String> ids = Arrays.asList(split);
+                    for (String oId : ids) {
+                        Office o = officeService.getById(oId);
+                        if (ObjectUtil.isNotEmpty(o) && StringUtils.isNotBlank(o.getGrade()) && "2".equals(o.getGrade())) {
+                            officeAlias =  StringUtils.isNotBlank(o.getCode()) ? o.getCode() : "";
+                        }
+                    }
+                }
+            }
+        }
+        return officeAlias;
+    }
+
+    /**
+     * 查询当前花名册推送子系统是否成功
+     * @param userId
+     * @return
+     */
+    public Map<String,Object> checkIsSyncFailed(String userId) {
+        User user = userService.getById(userId);
+        Map<String,Object> res = new HashMap<>();
+        if (ObjectUtil.isNotEmpty(user)) {
+            // 查询当前用户推送子系统是否成功， isPush != 1说明未推送成功
+            List<SysUserFailedLog> sysUserFailedLogList = sysUserFailedLogService.list(new LambdaQueryWrapper<SysUserFailedLog>()
+                    .eq(SysUserFailedLog::getUserId, user.getId())
+                    .ne(SysUserFailedLog::getIsPush, "1")
+            );
+            if (sysUserFailedLogList.size() > 0) {
+                res.put("success", false);
+                List<String> msg = changeFailedLogToMsg(sysUserFailedLogList);
+                if (msg.size() > 0) {
+                    String message = msg.stream().collect(Collectors.joining(","));
+                    res.put("message", message);
+                } else {
+                    res.put("message", "有推送失败的数据");
+                }
+            } else {
+                res.put("success", true);
+            }
+        } else {
+            res.put("success", false);
+            res.put("message", "没有获取到当前用户数据");
+        }
+
+        return res;
+    }
+
+    // 推送到子系统未成功的日志转换为msg
+    public List<String> changeFailedLogToMsg(List<SysUserFailedLog> sysUserFailedLogList) {
+        List<String> msg = new ArrayList<>();
+        sysUserFailedLogList.stream().forEach(item -> {
+            ServiceAliasEnum serviceAliasEnum = ServiceAliasEnum.getByValue(item.getBelongService());
+            String label = serviceAliasEnum.getLabel();
+            if ("0".equals(item.getIsSuccess())) {
+                msg.add("“" + label + "”系统同步保存数据未成功");
+            } else if ("1".equals(item.getIsSuccess())) {
+                msg.add("清除”" + label + "“系统的数据未成功");
+            } else if ("2".equals(item.getIsSuccess())) {
+                msg.add("“" + label + "”系统同步删除数据未成功");
+            }
+        });
+        return msg;
+    }
 
 }

jeeplus-platform/jeeplus-admin/src/main/java/com/jeeplus/sys/service/UserService.java

@@ -6,6 +6,11 @@ package com.jeeplus.sys.service;
 import cn.hutool.core.collection.CollectionUtil;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.jeeplus.center.enums.ServiceAliasEnum;
+import com.jeeplus.centerservice.utils.RestTemplateService;
 import com.jeeplus.sys.domain.*;
 import com.jeeplus.sys.mapper.OfficeMapper;
 import com.jeeplus.sys.service.dto.CertDTO;
@@ -36,6 +41,7 @@ import org.springframework.transaction.annotation.Transactional;
 
 import javax.servlet.http.HttpServletRequest;
 import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.stream.Collectors;
 
 /**
@@ -71,6 +77,12 @@ public class UserService  extends ServiceImpl<UserMapper, User> {
 	@Autowired
 	private RosterBaseCService rosterBaseCService;
 
+	@Autowired
+	private SysUserFailedLogService sysUserFailedLogService;
+
+	@Autowired
+	private RestTemplateService restTemplateService;
+
 	/**
 	 * 单一登录判断，是否允许登录
 	 * @return
@@ -197,9 +209,15 @@ public class UserService  extends ServiceImpl<UserMapper, User> {
 	 */
 	public IPage <UserDTO> findPage(Page <UserDTO> page, QueryWrapper queryWrapper) {
 		queryWrapper.eq ("a.del_flag", 0 ); // 排除已经删除
-		return  baseMapper.findList (page, queryWrapper);
-
-
+		IPage<UserDTO> list = baseMapper.findList(page, queryWrapper);
+		if(CollectionUtil.isNotEmpty(list.getRecords())){
+			list.getRecords().stream().forEach(item->{
+				// 查询是否有需要手动推送到子系统的数据
+				Map<String,Object> checkResp = rosterBaseCService.checkIsSyncFailed(item.getId());
+				item.setPushFailed((Boolean)checkResp.get("success"));
+			});
+		}
+		return list;
 	}
 
 	/**
@@ -252,6 +270,14 @@ public class UserService  extends ServiceImpl<UserMapper, User> {
 	 * @param userDTO
 	 */
 	public void saveOrUpdate(UserDTO userDTO) throws Exception {
+		// 获取修改前的所属部门id
+		String oldOffice = "";
+		if (ObjectUtil.isNotEmpty(userDTO) && StringUtils.isNotBlank(userDTO.getId())) {
+			User byIdUser = baseMapper.selectById(userDTO.getId());
+			if (ObjectUtil.isNotEmpty(byIdUser) && StringUtils.isNotBlank(byIdUser.getOfficeId())) {
+				oldOffice = byIdUser.getOfficeId();
+			}
+		}
 		User user = userWrapper.toEntity (userDTO);
 		super.saveOrUpdate ( user );
 		if( StrUtil.isBlank ( userDTO.getId () ) ){
@@ -282,21 +308,103 @@ public class UserService  extends ServiceImpl<UserMapper, User> {
 		this.updateUserManageOffice(officeIdList, userDTO);
 
 		// 新增/修改关联花名册数据
-		this.saveOrUpdateRoster(user);
+		this.saveOrUpdateRoster(user, oldOffice);
 
 		UserUtils.deleteCache ( userDTO );
 	}
 
 
-	public void deleteUser(UserDTO userDTO) {
-		baseMapper.deleteUserRole(userDTO.getId ());
-		baseMapper.deleteUserPost ( userDTO.getId () );
-		super.removeById (userDTO.getId ());
-		if (StringUtils.isNotBlank(userDTO.getRosterId())) {
-			// 删除与用户关联的花名册数据
-			rosterBaseCService.removeById(userDTO.getRosterId());
+	public Map<String,Object> deleteUser(UserDTO userDTO) {
+		Map<String,Object> responseMap = new HashMap<>();
+		if (ObjectUtil.isNotEmpty(userDTO) && StringUtils.isNotBlank(userDTO.getRosterId())) {
+			String rosterId = userDTO.getRosterId();
+			AtomicBoolean runSuccess = new AtomicBoolean(true);
+			// 先删除子系统花名册以及用户数据
+			Map<String,Object> paramMap = new HashMap<>();
+			paramMap.put("rosterId",rosterId);
+			User u = this.getOne(new QueryWrapper<User>().lambda().eq(User::getRosterId, rosterId));
+			paramMap.put("userId",u.getId());
+			String officeCode = rosterBaseCService.getServiceByOffice(u.getOfficeId());  // 根据这个部门id获取二级部门的别名code来获取所属哪个子系统
+			if (StringUtils.isNotBlank(officeCode)) {
+				// 评估
+				if (ServiceAliasEnum.CPA_EVALUATION.getValue().equals(officeCode) || ServiceAliasEnum.CPA_PUBLIC.getValue().equals(officeCode)) {
+					// 首先将数据记录为清除失败，待获取到其他系统执行成功的回值后再将此记录删掉
+					boolean succ = false;
+					String dataId_evaluation = sysUserFailedLogService.removeFailedLog(u.getId(), ServiceAliasEnum.CPA_EVALUATION.getValue());
+					Object res_evaluation = restTemplateService.getCPA_EVALUATION("/roster/base/removeByRosterId",null,paramMap);
+					if (ObjectUtil.isNotEmpty(res_evaluation)) {
+						Map<String,Object> resMap = JSONObject.parseObject(JSON.toJSONString(res_evaluation), Map.class);
+						if ((Boolean) resMap.get("success")) {
+							// 删除成功，将刚才记录的数据删除
+							sysUserFailedLogService.removeById(dataId_evaluation);
+							succ = true;
+						}
+					}
+					if (!succ) { // succ的值为false，那么说明数据删除失败
+						runSuccess.set(false);
+					}
+				}
+				// 财务
+				if (ServiceAliasEnum.CPA_FINANCE.getValue().equals(officeCode) || ServiceAliasEnum.CPA_PUBLIC.getValue().equals(officeCode)) {
+					// 首先将数据记录为清除失败，待获取到其他系统执行成功的回值后再将此记录删掉
+					boolean succ = false;
+					String dataId_finance = sysUserFailedLogService.removeFailedLog(u.getId(), ServiceAliasEnum.CPA_FINANCE.getValue());
+					Object res_finance = restTemplateService.getCPA_FINANCE("/roster/base/removeByRosterId",null,paramMap);
+					if (ObjectUtil.isNotEmpty(res_finance)) {
+						Map<String,Object> resMap = JSONObject.parseObject(JSON.toJSONString(res_finance), Map.class);
+						if ((Boolean) resMap.get("success")) {
+							// 删除成功，将刚才记录的数据删除
+							sysUserFailedLogService.removeById(dataId_finance);
+							succ = true;
+						}
+					}
+					if (!succ) { // succ的值为false，那么说明数据删除失败
+						runSuccess.set(false);
+					}
+				}
+				// 中审
+				if (ServiceAliasEnum.CPA_AUDIT.getValue().equals(officeCode) || ServiceAliasEnum.CPA_PUBLIC.getValue().equals(officeCode)) {
+					// 首先将数据记录为清除失败，待获取到其他系统执行成功的回值后再将此记录删掉
+					boolean succ = false;
+					String dataId_audit = sysUserFailedLogService.removeFailedLog(u.getId(), ServiceAliasEnum.CPA_AUDIT.getValue());
+					Object res_audit = restTemplateService.getCPA_AUDIT("/roster/base/removeByRosterId",null,paramMap);
+					if (ObjectUtil.isNotEmpty(res_audit)) {
+						Map<String,Object> resMap = JSONObject.parseObject(JSON.toJSONString(res_audit), Map.class);
+						if ((Boolean) resMap.get("success")) {
+							// 删除成功，将刚才记录的数据删除
+							sysUserFailedLogService.removeById(dataId_audit);
+							succ = true;
+						}
+					}
+					if (!succ) { // succ的值为false，那么说明数据删除失败
+						runSuccess.set(false);
+					}
+				}
+			}
+			if (runSuccess.get()) { // runSuccess的值为true，则说明子系统的操作都执行成功
+				// 删除花名册数据
+				rosterBaseCService.removeById(rosterId);
+				// 删除用户关联的管理部门信息
+				this.deleteUserManageOffice(userDTO);  //  根据用户id删除用户的管理部门信息
+				// 删除用户关联的岗位信息
+				this.deleteUserPost(userDTO.getId());
+				// 删除用户关联的角色信息
+				this.deleteUserRole(userDTO.getId());
+				// 删除用户
+				this.removeById(userDTO.getId());
+				// 清除redis缓存
+				UserUtils.deleteCache ( userDTO );
+				responseMap.put("success", true);
+				responseMap.put("message", "删除成功");
+			} else {
+				responseMap.put("success", false);
+				responseMap.put("message", "删除失败，子系统删除数据未成功");
+			}
+		} else {
+			responseMap.put("success", false);
+			responseMap.put("message", "删除失败，未找到用户或关联花名册数据");
 		}
-		UserUtils.deleteCache ( userDTO );
+		return responseMap;
 	}
 
 	public void updateUserLoginInfo(UserDTO userDTO) {
@@ -497,7 +605,7 @@ public class UserService  extends ServiceImpl<UserMapper, User> {
 	}
 
 	// 新增/修改花名册数据
-	public void saveOrUpdateRoster (User user) throws Exception {
+	public void saveOrUpdateRoster (User user, String oldOfficeId) throws Exception {
 		RosterBaseC r = new RosterBaseC();
 		r.setName(user.getName());  // 姓名
 		r.setOfficeId("");  // 部门
@@ -534,15 +642,25 @@ public class UserService  extends ServiceImpl<UserMapper, User> {
 		rosterBaseCService.saveOrUpdate(r);
 		user.setRosterId(r.getId());
 		this.updateById(user);
+		r.setUserId(u.getId());
+		rosterBaseCService.syncPushSubsystem(r,oldOfficeId);
 	}
 
 	// 修改用户信息
 	public ResponseEntity updateInfo(UserDTO userDTO) throws Exception {
+		// 获取修改前的所属部门id
+		String oldOffice = "";
+		if (ObjectUtil.isNotEmpty(userDTO) && StringUtils.isNotBlank(userDTO.getId())) {
+			User byIdUser = baseMapper.selectById(userDTO.getId());
+			if (ObjectUtil.isNotEmpty(byIdUser) && StringUtils.isNotBlank(byIdUser.getOfficeId())) {
+				oldOffice = byIdUser.getOfficeId();
+			}
+		}
 		User user = UserWrapper.INSTANCE.toEntity(userDTO);
 		// 根据用户id修改用户信息
 		this.updateById (user);
 		// 修改用户信息的同时更新花名册数据
-		this.saveOrUpdateRoster(user);
+		this.saveOrUpdateRoster(user, oldOffice);
 		//更新缓存信息
 		UserUtils.deleteCache ( UserUtils.getCurrentUserDTO ( ) );
 		return ResponseEntity.ok ( "修改个人资料成功!" );
@@ -557,4 +675,119 @@ public class UserService  extends ServiceImpl<UserMapper, User> {
 	public List<User> getUserIdByPost(String postId) {
 		return userMapper.getUserByPost(postId);
 	}
+
+	public void deleteUserManageOffice(UserDTO userDTO) {
+		userMapper.deleteUserManageOffice(userDTO);
+	}
+
+	public void deleteUserPost(String id) {
+		userMapper.deleteUserPost(id);
+	}
+
+	public void deleteUserRole(String id) {
+		userMapper.deleteUserRole(id);
+	}
+
+	/**
+	 * 手动向子系统推送之前同步失败的数据
+	 * @param userId
+	 * @return
+	 */
+	public boolean pushUserSync(String userId) {
+		AtomicBoolean respBool = new AtomicBoolean(true);
+		User user = this.getById(userId);
+		RosterBaseC rosterBase = rosterBaseCService.getById(user.getRosterId());
+		rosterBase.setUserId(userId);
+		Map<String,Object> bodyMap = JSONObject.parseObject(JSON.toJSONString(rosterBase), Map.class);
+		// 查询日志表中未重新推送的”删除”推送
+		List<SysUserFailedLog> deleteUserFailedLogList = sysUserFailedLogService.list(new LambdaQueryWrapper<SysUserFailedLog>()
+				.eq(SysUserFailedLog::getUserId, user.getId())
+				.eq(SysUserFailedLog::getIsSuccess, "2") // 查询删除操作
+				.ne(SysUserFailedLog::getIsPush, "1") // isPush != 1说明未推送成功
+				.orderByDesc(SysUserFailedLog::getCreateDate)
+		);
+		// 查询当前用户推送子系统是否成功， isPush != 1说明未推送成功
+		List<SysUserFailedLog> sysUserFailedLogList = sysUserFailedLogService.list(new LambdaQueryWrapper<SysUserFailedLog>()
+				.eq(SysUserFailedLog::getUserId, user.getId())
+				.ne(SysUserFailedLog::getIsPush, "1")
+				.orderByDesc(SysUserFailedLog::getCreateDate)
+		);
+		if (CollectionUtil.isNotEmpty(sysUserFailedLogList)) {
+			sysUserFailedLogList.stream().forEach(sysUserFailedLog -> {
+				switch (sysUserFailedLog.getIsSuccess()) {
+					case "0": // 保存操作失败
+						boolean succ = false;
+						Object res = null;
+						if (ServiceAliasEnum.CPA_EVALUATION.getValue().equals(sysUserFailedLog.getBelongService())) {
+							// 调用评估系统的用户保存操作
+							res = restTemplateService.postCPA_EVALUATION("/roster/base/saveOrUpdateUserRoster",null,null,bodyMap);
+
+						} else if (ServiceAliasEnum.CPA_FINANCE.getValue().equals(sysUserFailedLog.getBelongService())) {
+							// 调用财务系统的用户保存操作
+							res = restTemplateService.postCPA_FINANCE("/roster/base/saveOrUpdateUserRoster",null,null,bodyMap);
+
+						} else if (ServiceAliasEnum.CPA_AUDIT.getValue().equals(sysUserFailedLog.getBelongService())) {
+							// 调用财务系统的用户保存操作
+							res = restTemplateService.postCPA_AUDIT("/roster/base/saveOrUpdateUserRoster",null,null,bodyMap);
+
+						}
+						if (ObjectUtil.isNotEmpty(res)) {
+							Map<String,Object> resMap = JSONObject.parseObject(JSON.toJSONString(res), Map.class);
+							if ((Boolean) resMap.get("success")) {
+								// 保存成功，将推送日志表中的数据修改为推送完成
+								sysUserFailedLogService.finishById(sysUserFailedLog.getId());
+								succ = true;
+							}
+						}
+						if (!succ) { // succ的值为false，说明此次手动推送失败
+							respBool.set(false);
+						}
+						break;
+					case "1": case "2": // 1:清除操作失败（这里指的是切换所属系统，要清除原系统中的人员信息）   2:删除操作失败
+						boolean succ1 = false;
+						Object res1 = null;
+						if (ServiceAliasEnum.CPA_EVALUATION.getValue().equals(sysUserFailedLog.getBelongService())) {
+							// 调用评估系统的用户清除操作
+							res1 = restTemplateService.postCPA_EVALUATION("/roster/base/deleteUserRoster",null,null,bodyMap);
+						} else if (ServiceAliasEnum.CPA_FINANCE.getValue().equals(sysUserFailedLog.getBelongService())) {
+							// 调用财务系统的用户清除操作
+							res1 = restTemplateService.postCPA_FINANCE("/roster/base/deleteUserRoster",null,null,bodyMap);
+						} else if (ServiceAliasEnum.CPA_AUDIT.getValue().equals(sysUserFailedLog.getBelongService())) {
+							// 调用财务系统的用户清除操作
+							res1 = restTemplateService.postCPA_AUDIT("/roster/base/deleteUserRoster",null,null,bodyMap);
+						}
+						if (ObjectUtil.isNotEmpty(res1)) {
+							Map<String,Object> resMap = JSONObject.parseObject(JSON.toJSONString(res1), Map.class);
+							if ((Boolean) resMap.get("success")) {
+								// 清除成功，将推送日志表中的数据修改为推送完成
+								sysUserFailedLogService.finishById(sysUserFailedLog.getId());
+								succ1 = true;
+							}
+						}
+						if (!succ1) { // succ的值为false，说明此次手动推送失败
+							respBool.set(false);
+						}
+						break;
+				}
+			});
+			// respBool值为true 说明推送失败的操作现已全部重新推送
+			if (respBool.get()) {
+				if (CollectionUtil.isNotEmpty(deleteUserFailedLogList)) { // deleteUserFailedLogList不是空，说明有删除操作
+					// 删除花名册数据
+					rosterBaseCService.removeById(rosterBase.getId());
+					// 删除用户
+					this.removeById(userId);
+					UserDTO userDTO = new UserDTO();
+					userDTO.setId(userId);
+					// 删除用户关联的管理部门信息
+					this.deleteUserManageOffice(userDTO);  //  根据用户id删除用户的管理部门信息
+					// 删除用户关联的岗位信息
+					this.deleteUserPost(userId);
+					// 删除用户关联的角色信息
+					this.deleteUserRole(userId);
+				}
+			}
+		}
+		return respBool.get();
+	}
 }

jeeplus-platform/jeeplus-admin/src/main/java/com/jeeplus/sys/service/dto/UserDTO.java

@@ -314,4 +314,9 @@ public class  UserDTO extends BaseDTO {
      */
     private String rosterId;
 
+    /**
+     * 是否有未推送成功的子系统
+     */
+    private boolean pushFailed;
+
 }