花名册同步子系统

jeeplus-module/jeeplus-test/pom.xml

@@ -31,6 +31,11 @@
         </dependency>
         <dependency>
             <groupId>org.jeeplus</groupId>
+            <artifactId>jeeplus-center</artifactId>
+            <version>${project.parent.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jeeplus</groupId>
             <artifactId>jeeplus-flowable</artifactId>
             <version>${project.parent.version}</version>
         </dependency>

jeeplus-module/jeeplus-test/src/main/java/com/jeeplus/test/centerservice/controller/TranspondController.java

@@ -1,10 +1,8 @@
 package com.jeeplus.test.centerservice.controller;
 
-import com.jeeplus.centerservice.enums.TaskAliasEnum;
 import com.jeeplus.test.centerservice.dto.TranspondDTO;
 import com.jeeplus.test.centerservice.service.TranspondService;
 import com.jeeplus.test.reimbursement.reimbursementInfo.service.ReimbursementInfoService;
-import com.jeeplus.test.reimbursement.reimbursementInfo.service.dto.SaveInfoDto;
 import org.springframework.stereotype.Controller;
 import org.springframework.web.bind.annotation.*;
 

jeeplus-module/jeeplus-test/src/main/java/com/jeeplus/test/roster/controller/RosterBaseController.java

@@ -61,6 +61,7 @@ import javax.validation.Valid;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 @Api("花名册")
@@ -220,4 +221,38 @@ public class RosterBaseController {
 
     }
 
+    /**
+     * 查询当前花名册推送子系统是否成功
+     * @param rosterId
+     * @return
+     */
+    @GetMapping("checkIsSyncFailed")
+    public ResponseEntity checkIsSyncFailed(String rosterId) {
+        Map<String, Object> res = rosterBaseService.checkIsSyncFailed(rosterId);
+        return ResponseEntity.ok (res);
+    }
+
+
+    /**
+     * 查询推送失败的数据
+     * @param rosterId
+     * @return
+     */
+    @GetMapping("getPushFailedMsg")
+    public ResponseEntity getPushFailedMsg(String rosterId) {
+        Map<String, Object> res = rosterBaseService.getPushFailedMsg(rosterId);
+        return ResponseEntity.ok (res);
+    }
+
+    /**
+     * 手动向子系统推送之前同步失败的数据
+     * @param rosterBaseDTO
+     * @return
+     */
+    @PostMapping("pushRosterSync")
+    public ResponseEntity pushRosterSync(@RequestBody RosterBaseDTO rosterBaseDTO) {
+        boolean s = rosterBaseService.pushRosterSync(rosterBaseDTO.getId());
+        return ResponseEntity.ok (s);
+    }
+
 }

jeeplus-module/jeeplus-test/src/main/java/com/jeeplus/test/roster/domain/RosterBase.java

@@ -238,6 +238,36 @@ public class RosterBase extends BaseEntity {
     @TableField(exist = false)
     private String companyId;
 
+    /**
+     * 密码
+     */
+    @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-module/jeeplus-test/src/main/java/com/jeeplus/test/roster/mapper/xml/RosterBaseMapper.xml

@@ -50,6 +50,8 @@
     <result column="headshot" jdbcType="VARCHAR" property="headshot" />
     <result column="office_name" jdbcType="VARCHAR" property="officeName" />
     <result column="person_type" jdbcType="VARCHAR" property="personType" />
+    <result column="login_flag" jdbcType="VARCHAR" property="loginFlag" />
+    <result column="other_service_flag" jdbcType="VARCHAR" property="otherServiceFlag" />
     <association property="rosterContractDTO" javaType="com.jeeplus.test.roster.service.dto.RosterContractDTO" column="id" select="getContractDTO"></association>
     <association property="rosterLeadershipDTO" javaType="com.jeeplus.test.roster.service.dto.RosterLeadershipDTO" column="id" select="getLeadershipDTO"></association>
     <collection property="rosterBankCardsDTOList" ofType="com.jeeplus.test.roster.service.dto.RosterBankCardsDTO" column="id" select="getBankCardsList"></collection>
@@ -323,7 +325,9 @@
   <select id="findList" resultMap="BaseResultMap">
     select
     <include refid="Base_Column_List"></include>,
-    so.name office_name
+    so.name office_name,
+    su.other_service_flag,
+    su.login_flag
     from roster_base rb
     left join sys_office so on rb.office_id = so.id and so.del_flag = '0'
     LEFT JOIN sys_user su ON su.roster_id = rb.id and su.del_flag = 0
@@ -335,8 +339,11 @@
 
   <select id="queryById" resultMap="BaseResultMap">
     select
-    <include refid="Base_Column_List"></include>
+    <include refid="Base_Column_List"></include>,
+    su.other_service_flag,
+    su.login_flag
     from roster_base rb
+    left join sys_user su on su.roster_id = rb.id and su.del_flag = '0'
     where rb.id = #{id}
   </select>
 

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

@@ -2,21 +2,25 @@ package com.jeeplus.test.roster.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.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.jeeplus.centerservice.utils.RestTemplateService;
 import com.jeeplus.core.excel.utils.EasyPoiUtil;
 import com.jeeplus.core.query.QueryWrapperGenerator;
 import com.jeeplus.security.util.SecurityUtils;
 import com.jeeplus.sys.constant.enums.OfficeTypeEnum;
 import com.jeeplus.sys.domain.*;
+import com.jeeplus.sys.mapper.SysUserFailedLogMapper;
 import com.jeeplus.sys.mapper.UserMapper;
 import com.jeeplus.sys.service.CertService;
 import com.jeeplus.sys.service.OfficeService;
+import com.jeeplus.sys.service.SysUserFailedLogService;
 import com.jeeplus.sys.service.UserService;
 import com.jeeplus.sys.service.dto.CertDTO;
 import com.jeeplus.sys.service.dto.UserDTO;
@@ -25,27 +29,24 @@ import com.jeeplus.sys.utils.DictUtils;
 import com.jeeplus.sys.utils.StringUtils;
 import com.jeeplus.sys.utils.UserUtils;
 import com.jeeplus.test.cw.common.CommonUtils;
-import com.jeeplus.test.cw.invoice.service.dto.CwFinanceInvoiceDetailDTO;
-import com.jeeplus.test.jobPosion.service.dto.JobPositionDTO;
 import com.jeeplus.test.jobPosion.utils.BeanUtils;
 import com.jeeplus.test.mould.service.SerialnumTplService;
 import com.jeeplus.test.oss.service.OssService;
-import com.jeeplus.test.rank.service.dto.RankSystemTableDTO;
 import com.jeeplus.test.roster.domain.*;
 import com.jeeplus.test.roster.mapper.RosterBaseMapper;
 import com.jeeplus.test.roster.service.dto.*;
 import com.jeeplus.test.roster.service.mapstruct.*;
-import com.jeeplus.test.workContract.service.dto.WorkContractInfoDto;
-import org.apache.commons.compress.utils.Lists;
+import com.jeeplus.center.enums.ServiceAliasEnum;
+import com.sun.org.apache.xpath.internal.operations.Bool;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.multipart.MultipartFile;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 
 import static com.jeeplus.test.jobPosion.utils.BeanUtils.objectCheckIsNull;
@@ -97,8 +98,17 @@ public class RosterBaseService extends ServiceImpl<RosterBaseMapper, RosterBase>
     private UserMapper userMapper;
 
     @Autowired
+    private RestTemplateService restTemplateService;
+
+    @Autowired
+    private SysUserFailedLogMapper sysUserFailedLogMapper;
+
+    @Autowired
     private CertService certService;
 
+    @Autowired
+    private SysUserFailedLogService sysUserFailedLogService;
+
     public IPage<RosterBaseDTO> findList(Page<RosterBaseDTO> page, RosterBaseDTO rosterBaseDTO) throws Exception {
         RosterBase rosterBase = RosterBaseWrapper.INSTANCE.toEntity(rosterBaseDTO);
         QueryWrapper<RosterBase> queryWrapper = QueryWrapperGenerator.buildQueryCondition ( rosterBase, RosterBase.class );
@@ -157,6 +167,9 @@ public class RosterBaseService extends ServiceImpl<RosterBaseMapper, RosterBase>
                     }).map(Role::getName).collect(Collectors.joining(","));
                     item.setRoleNames(roleNames);
                 }
+                // 查询是否有需要手动推送到子系统的数据
+                Map<String,Object> checkResp = checkIsSyncFailed(item.getId());
+                item.setPushFailed((Boolean)checkResp.get("success"));
             });
         }
         return rosterBaseDTOIPage;
@@ -247,9 +260,12 @@ public class RosterBaseService extends ServiceImpl<RosterBaseMapper, RosterBase>
 
     public ResponseEntity saveRoster(RosterBaseDTO rosterBaseDTO) throws Exception{
 
+        String oldOfficeId = "";
+
         if(ObjectUtil.isNotEmpty(rosterBaseDTO)){
             if(StringUtils.isNotBlank(rosterBaseDTO.getId())){
                 RosterBase byId = this.getById(rosterBaseDTO.getId());
+                oldOfficeId = StringUtils.isNotBlank(byId.getOfficeId()) ? byId.getOfficeId() : "";
                 // 原数据的人员类型为员工，现在要修改成游客，
                 // 原数据关联的用户删除掉
                 // 删除原数据关联表的数据，删除与游客无关的数据
@@ -327,12 +343,19 @@ public class RosterBaseService extends ServiceImpl<RosterBaseMapper, RosterBase>
 
         // 新增或修改花名册数据
         this.saveOrUpdate(rosterBase);
+        rosterBase.setNewPassword(rosterBaseDTO.getNewPassword());
+        rosterBase.setLoginFlag(rosterBaseDTO.getLoginFlag());
+        rosterBase.setOtherServiceFlag(rosterBaseDTO.getOtherServiceFlag());
 
         // 新增或修改用户数据(花名册的人员类型为员工时)
         if ("1".equals(rosterBase.getPersonType())) {
-            this.saveOrUpdateUser(rosterBase, CommonUtils.getFirstCompanyId());
+            String userId = this.saveOrUpdateUser(rosterBase, CommonUtils.getFirstCompanyId());
+            rosterBase.setUserId(userId);
         }
 
+        // 推送其他系统同步保存用户信息
+        syncPushSubsystem(rosterBase, oldOfficeId);
+
         if(ObjectUtil.isNotEmpty(rosterBaseDTO)){
             //保存合同信息
             if(ObjectUtil.isNotEmpty(rosterBaseDTO.getRosterContractDTO())){
@@ -436,30 +459,30 @@ public class RosterBaseService extends ServiceImpl<RosterBaseMapper, RosterBase>
                 rosterFilesService.remove(new QueryWrapper<RosterFiles>().eq("base_id",rosterBase.getId()));
             }
             //保存直属领导
-            if(ObjectUtil.isNotEmpty(rosterBaseDTO.getRosterLeadershipDTO())){
-                RosterLeadership rosterLeadership = RosterLeadershipWrapper.INSTANCE.toEntity(rosterBaseDTO.getRosterLeadershipDTO());
-                rosterLeadership.setBaseId(rosterBase.getId());
-                rosterLeadershipService.remove(new QueryWrapper<RosterLeadership>().eq("base_id",rosterBase.getId()));
-                rosterLeadershipService.saveOrUpdate(rosterLeadership);
-            }else{
-                rosterLeadershipService.remove(new QueryWrapper<RosterLeadership>().eq("base_id",rosterBase.getId()));
-            }
+//            if(ObjectUtil.isNotEmpty(rosterBaseDTO.getRosterLeadershipDTO())){
+//                RosterLeadership rosterLeadership = RosterLeadershipWrapper.INSTANCE.toEntity(rosterBaseDTO.getRosterLeadershipDTO());
+//                rosterLeadership.setBaseId(rosterBase.getId());
+//                rosterLeadershipService.remove(new QueryWrapper<RosterLeadership>().eq("base_id",rosterBase.getId()));
+//                rosterLeadershipService.saveOrUpdate(rosterLeadership);
+//            }else{
+//                rosterLeadershipService.remove(new QueryWrapper<RosterLeadership>().eq("base_id",rosterBase.getId()));
+//            }
             User user = userService.getOne(new QueryWrapper<User>().lambda().eq(User::getRosterId, rosterBase.getId()));
             if (ObjectUtil.isNotEmpty(user)) {
                 // 保存花名册关联用户的资质信息
-                certService.remove(new QueryWrapper<Cert>().lambda().eq(Cert::getUserId,user.getId()));
-                if(ObjectUtil.isNotEmpty(rosterBaseDTO.getCertDTOList())){
-                    List<Cert> certList = new ArrayList<>();
-                    rosterBaseDTO.getCertDTOList().stream().forEach(i -> {
-                        Cert cert = CertWrapper.INSTANCE.toEntity(i);
-                        cert.setUserId(user.getId());
-                        cert.setId("");
-                        certList.add(cert);
-                    });
-                    if (CollectionUtil.isNotEmpty(certList)) {
-                        certService.saveBatch(certList);
-                    }
-                }
+//                certService.remove(new QueryWrapper<Cert>().lambda().eq(Cert::getUserId,user.getId()));
+//                if(ObjectUtil.isNotEmpty(rosterBaseDTO.getCertDTOList())){
+//                    List<Cert> certList = new ArrayList<>();
+//                    rosterBaseDTO.getCertDTOList().stream().forEach(i -> {
+//                        Cert cert = CertWrapper.INSTANCE.toEntity(i);
+//                        cert.setUserId(user.getId());
+//                        cert.setId("");
+//                        certList.add(cert);
+//                    });
+//                    if (CollectionUtil.isNotEmpty(certList)) {
+//                        certService.saveBatch(certList);
+//                    }
+//                }
                 // 保存花名册关联用户的角色
                 userMapper.deleteUserRole(user.getId());  //  删除用户的角色
                 if (CollectionUtil.isNotEmpty(rosterBaseDTO.getRoleIdList())) {
@@ -492,6 +515,153 @@ public class RosterBaseService extends ServiceImpl<RosterBaseMapper, RosterBase>
         return ResponseEntity.ok("花名册保存成功");
     }
 
+    /**
+     * 推送其他系统同步保存用户信息
+     * @param rosterBase
+     */
+    public void syncPushSubsystem(RosterBase 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;
+    }
+
     // 导入花名册excel
     public ResponseEntity importFile(MultipartFile file) {
         try {
@@ -635,7 +805,7 @@ public class RosterBaseService extends ServiceImpl<RosterBaseMapper, RosterBase>
     /**
      * 新增或修改花名册的时候，同步创建或修改用户数据
      */
-    public void saveOrUpdateUser (RosterBase rosterBase,String companyId) {
+    public String saveOrUpdateUser (RosterBase rosterBase,String companyId) {
         User user = new User();
         user.setRosterId(rosterBase.getId());  // 花名册id
         user.setOfficeId(rosterBase.getOfficeId());  //  部门
@@ -656,30 +826,137 @@ public class RosterBaseService extends ServiceImpl<RosterBaseMapper, RosterBase>
         if (ObjectUtil.isNotEmpty(u)) {
             user.setId(u.getId());  //  用户id
             user.setUpPassword("1");  //  密码修改状态改为 ”已修改“
+            // 密码
+            if (StringUtils.isNotBlank(rosterBase.getNewPassword())) {
+                user.setPassword(SecurityUtils.encryptPassword(rosterBase.getNewPassword()));
+            }
+            //  是否允许登录
+            if (StringUtils.isNotBlank(rosterBase.getLoginFlag())) {
+                user.setLoginFlag(rosterBase.getLoginFlag());
+            }
+            // 访问其他系统权限
+            if (StringUtils.isNotBlank(rosterBase.getOtherServiceFlag())) {
+                user.setOtherServiceFlag(rosterBase.getOtherServiceFlag());
+            }
         } else {
-            user.setLoginFlag("1");  //  是否允许登录     默认直接给 “1” 允许登录
-            user.setPassword(SecurityUtils.encryptPassword("123456"));  //  密码     默认密码 “123456”
+            //  是否允许登录
+            if (StringUtils.isNotBlank(rosterBase.getLoginFlag())) {
+                user.setLoginFlag(rosterBase.getLoginFlag());
+            } else {
+                user.setLoginFlag("1");  //  是否允许登录     默认直接给 “1” 允许登录
+            }
+            // 访问其他系统权限
+            if (StringUtils.isNotBlank(rosterBase.getOtherServiceFlag())) {
+                user.setOtherServiceFlag(rosterBase.getOtherServiceFlag());
+            } else {
+                user.setOtherServiceFlag("0");  //  访问其他系统权限     默认直接给 “0” 不允许访问其他系统
+            }
+            //  密码
+            if (StringUtils.isNotBlank(rosterBase.getNewPassword())) {
+                user.setPassword(SecurityUtils.encryptPassword(rosterBase.getNewPassword()));
+            } else {
+                user.setPassword(SecurityUtils.encryptPassword("123456"));  //  密码     默认密码 “123456”
+            }
         }
         userService.saveOrUpdate(user);
+        return user.getId();
     }
 
     public ResponseEntity removeByRosterIds(String[] ids) {
-        // 删除花名册数据
-        this.removeByIds(Arrays.asList(ids));
-        // 删除花名册关联用户数据
-        // 员工切换为游客、花名册直接删除   这两种情况都要删除用户信息以及用户关联的角色等信息
-        userService.remove(new QueryWrapper<User>().lambda().in(User::getRosterId, ids));
-        Arrays.asList(ids).stream().forEach(item -> {
-            UserDTO u = new UserDTO();
-            u.setId(item);
-            // 删除用户关联的管理部门信息
-            userMapper.deleteUserManageOffice(u);  //  根据用户id删除用户的管理部门信息
-            // 删除用户关联的岗位信息
-            userMapper.deleteUserPost(item);
-            // 删除用户关联的角色信息
-            userMapper.deleteUserRole(item);
+        List<String> rosterIds = Arrays.asList(ids);
+        AtomicBoolean runSuccess = new AtomicBoolean(true);
+        // 先删除子系统花名册以及用户数据
+        rosterIds.stream().forEach(rosterId -> {
+            Map<String,Object> paramMap = new HashMap<>();
+            paramMap.put("rosterId",rosterId);
+            User u = userService.getOne(new QueryWrapper<User>().lambda().eq(User::getRosterId, rosterId));
+            paramMap.put("userId",u.getId());
+            String officeCode = 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);
+                    }
+                }
+            }
         });
-        return ResponseEntity.ok ("删除花名册成功");
+        Map<String,Object> resMap = new HashMap<>();
+        if (runSuccess.get()) { // runSuccess的值为true，则说明子系统的操作都执行成功
+            // 删除花名册数据
+            this.removeByIds(rosterIds);
+            // 删除花名册关联用户数据。删除用户信息以及用户关联的角色等信息
+            rosterIds.stream().forEach(rosterId -> {
+                // 通过花名册id查询用户
+                User u = userService.getOne(new QueryWrapper<User>().lambda().eq(User::getRosterId, rosterId));
+                if (ObjectUtil.isNotEmpty(u)) {
+                    // 删除用户
+                    userService.removeById(u.getId());
+                    UserDTO userDTO = new UserDTO();
+                    userDTO.setId(u.getId());
+                    // 删除用户关联的管理部门信息
+                    userMapper.deleteUserManageOffice(userDTO);  //  根据用户id删除用户的管理部门信息
+                    // 删除用户关联的岗位信息
+                    userMapper.deleteUserPost(u.getId());
+                    // 删除用户关联的角色信息
+                    userMapper.deleteUserRole(u.getId());
+                }
+            });
+            resMap.put("success", true);
+            resMap.put("message", "删除花名册成功");
+        } else {
+            resMap.put("success", false);
+            resMap.put("message", "删除花名册失败，子系统删除数据未成功");
+        }
+        return ResponseEntity.ok(resMap);
     }
 
     public RosterBaseDTO deleteRosterWorker (RosterBaseDTO rosterBaseDTO) {
@@ -757,4 +1034,186 @@ public class RosterBaseService extends ServiceImpl<RosterBaseMapper, RosterBase>
         this.update(wrapper);
         return rosterBaseDTO;
     }
+
+    /**
+     * 查询当前花名册推送子系统是否成功
+     * @param rosterId
+     * @return
+     */
+    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);
+            } else {
+                res.put("message", "有推送失败的数据，请重新推送后再进行尝试");
+            }
+        } else {
+            res.put("success", true);
+        }
+        return res;
+    }
+
+    /**
+     * 查询推送失败的数据
+     * @param rosterId
+     * @return
+     */
+    public Map<String,Object> getPushFailedMsg(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);
+            } else {
+                res.put("message", "有推送失败的数据，是否重新推送");
+            }
+        } else {
+            res.put("success", true);
+        }
+        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;
+    }
+
+    /**
+     * 手动向子系统推送之前同步失败的数据
+     * @param rosterId
+     * @return
+     */
+    public boolean pushRosterSync(String rosterId) {
+        AtomicBoolean respBool = new AtomicBoolean(true);
+        RosterBase rosterBase = this.getById(rosterId);
+        User user = userService.getOne(new LambdaQueryWrapper<User>().eq(User::getRosterId, rosterId));
+        rosterBase.setUserId(user.getId());
+        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不是空，说明有删除操作
+                    // 删除花名册数据
+                    this.removeById(rosterId);
+                    // 通过花名册id查询用户
+                    User u = userService.getOne(new QueryWrapper<User>().lambda().eq(User::getRosterId, rosterId));
+                    if (ObjectUtil.isNotEmpty(u)) {
+                        // 删除用户
+                        userService.removeById(u.getId());
+                        UserDTO userDTO = new UserDTO();
+                        userDTO.setId(u.getId());
+                        // 删除用户关联的管理部门信息
+                        userMapper.deleteUserManageOffice(userDTO);  //  根据用户id删除用户的管理部门信息
+                        // 删除用户关联的岗位信息
+                        userMapper.deleteUserPost(u.getId());
+                        // 删除用户关联的角色信息
+                        userMapper.deleteUserRole(u.getId());
+                    }
+                }
+            }
+        }
+        return respBool.get();
+    }
 }

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

@@ -380,5 +380,30 @@ public class RosterBaseDTO extends BaseDTO {
     @Query(type = QueryType.EQ, tableColumn = "o.id", javaField = "officeDTO.id")
     private OfficeDTO officeDTO;
 
+    /**
+     * 密码
+     */
+    private String newPassword;
+
+    /**
+     * 确认密码
+     */
+    private String confirmNewPassword;
+
+    /**
+     * 是否允许登录
+     */
+    private String loginFlag;
+
+    /**
+     * 访问其他系统权限
+     */
+    private String otherServiceFlag;
+
+    /**
+     * 是否有未推送成功的子系统
+     */
+    private boolean pushFailed;
+
     private static final long serialVersionUID = 1L;
 }

jeeplus-platform/jeeplus-admin/pom.xml

@@ -29,6 +29,11 @@
             <artifactId>jeeplus-common</artifactId>
             <version>${project.parent.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.jeeplus</groupId>
+            <artifactId>jeeplus-center</artifactId>
+            <version>${project.parent.version}</version>
+        </dependency>
 
         <dependency>
             <groupId>org.jasig.cas.client</groupId>

jeeplus-plugins/jeeplus-flowable/src/main/java/com/jeeplus/centerservice/config/RestTemplateConfig.java

@@ -1,19 +1,14 @@
-package com.jeeplus.centerservice.config;
+package com.jeeplus.center.config;
 
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.http.MediaType;
 import org.springframework.http.client.ClientHttpRequestFactory;
 import org.springframework.http.client.SimpleClientHttpRequestFactory;
-import org.springframework.http.converter.HttpMessageConverter;
-import org.springframework.http.converter.StringHttpMessageConverter;
 import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
 import org.springframework.web.client.RestTemplate;
 
-import java.nio.charset.Charset;
-import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 
 @Configuration

jeeplus-plugins/jeeplus-flowable/pom.xml

@@ -40,6 +40,11 @@
             <artifactId>jeeplus-mail</artifactId>
             <version>${project.parent.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.jeeplus</groupId>
+            <artifactId>jeeplus-center</artifactId>
+            <version>${project.parent.version}</version>
+        </dependency>
 
         <dependency>
             <groupId>commons-fileupload</groupId>

jeeplus-plugins/pom.xml

@@ -26,6 +26,7 @@
         <module>jeeplus-tools</module>
         <module>jeeplus-ureport</module>
         <module>jeeplus-wps</module>
+        <module>jeeplus-center</module>
     </modules>
 
 

jeeplus-web/src/main/resources/application-development.yml

@@ -1,5 +1,5 @@
 server:
-  port: 8084
+  port: 8085
   servlet:
     context-path:
   tomcat:
@@ -47,7 +47,7 @@ spring:
       datasource:
         master:
           username: root
-          password: root
+          password: 123456
           url: jdbc:mysql://127.0.0.1:3306/assess_process_master?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false&nullCatalogMeansCurrent=true&serverTimezone=Asia/Shanghai
           driver-class-name: com.mysql.cj.jdbc.Driver
 
@@ -253,7 +253,15 @@ template_id: 435329
 code_type: 1
 
 #其他系统的地址
+#CCPM系统地址
 CCPM_PATH:  http://localhost:8090
+#CPA-评估系统地址
+CPA_EVALUATION_PATH: http://localhost:8084
+#CPA-财务系统地址
+CPA_FINANCE_PATH: http://localhost:8086
+#CPA-中审系统地址
+CPA_AUDIT_PATH: http://localhost:8087
+
 #待办中展示其他系统的流程
 #ccpm =》 13、102 报销申请、39 项目登记
 CCPM_TASK:  13,102,39