OrgSyncByJyzyService.java

package com.tanpu.feo.feojob.service;

import cn.hutool.core.date.DateTime;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.tanpu.common.api.CommonResp;
import com.tanpu.feo.feojob.dao.user.entity.*;
import com.tanpu.feo.feojob.dto.JyzyTeamDto;
import com.tanpu.feo.feojob.dto.OrgInfoDto;
import com.tanpu.feo.feojob.dto.OrgSyncDto;
import com.tanpu.feo.feojob.dto.WorkDataDto;
import com.tanpu.feo.feojob.dao.jyzyuser.entity.JyzyOrgEntity;
import com.tanpu.feo.feojob.dao.jyzyuser.entity.JyzyTeamEntity;
import com.tanpu.feo.feojob.dao.jyzyuser.entity.JyzyUserInfoEntity;
import com.tanpu.feo.feojob.enums.EmployeeDutyEnum;
import com.tanpu.feo.feojob.enums.RoleTypeEnum;
import com.tanpu.feo.feojob.service.jyzy.JyzyOrgService;
import com.tanpu.feo.feojob.service.jyzy.JyzyTeamService;
import com.tanpu.feo.feojob.service.jyzy.JyzyUserInfoService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

@Service
@Slf4j
public class OrgSyncByJyzyService {
    @Resource
    private OrgService orgService;
    @Resource
    private UserInfoService userInfoService;
    @Resource
    private DepartmentService departmentService;
    @Resource
    private DepartmentEmployeeService departmentEmployeeService;
    @Resource
    private EmployeeService employeeService;
    @Resource
    private EmployeeRoleService employeeRoleService;
    @Resource
    private RoleService roleService;
    @Resource
    private JyzyOrgService jyzyOrgService;
    @Resource
    private JyzyTeamService jyzyTeamService;
    @Resource
    private JyzyUserInfoService jyzyUserInfoService;
    @Resource
    private OrgSyncService orgSyncService;

    public CommonResp<String> orgSyncByJyzy(OrgSyncDto orgSyncDto) {
        try {
            //1 从精业展业 数据库中 获取组织及用户 信息
            List<JyzyTeamDto> jyzyTeamDtoList = getJyzyTeamByOrgCode(orgSyncDto.getJyzyOrgCode());
            log.info("====== 精业展业 获取的数据为：{}", JSONUtil.toJsonStr(jyzyTeamDtoList));
            //2 从feo 数据库中 获取现有的 组织及人员 信息
            OrgInfoDto orgInfoDto = getOrgInfoByFeoOrgCode(orgSyncDto.getFeoOrgCode());
            log.info("====== 理财师机构版 获取的数据为：{}", JSONUtil.toJsonStr(orgInfoDto));
            //3 数据对比
            WorkDataDto<UserInfoEntity> workUserInfo = new WorkDataDto<>();
            WorkDataDto<EmployeeEntity> workEmployee = new WorkDataDto<>();
            WorkDataDto<DepartmentEntity> workDepartment = new WorkDataDto<>();
            WorkDataDto<DepartmentEmployeeEntity> workDepartmentEmployee = new WorkDataDto<>();
            WorkDataDto<EmployeeRoleEntity> workEmployeeRole = new WorkDataDto<>();
            dataCompare(workUserInfo, workEmployee, workDepartment, workDepartmentEmployee, workEmployeeRole, jyzyTeamDtoList, orgInfoDto);
            //4 数据操作
            orgSyncService.updateData(orgInfoDto.getOrgId(), workUserInfo, workEmployee, workDepartment, workDepartmentEmployee, workEmployeeRole);

        } catch (Exception e) {
            log.error("=========从 精业展业 同步 机构信息失败，原因--->{}", e.getMessage());
            return CommonResp.failed(e.getMessage());
        }
        return CommonResp.success("同步成功");
    }

    private void dataCompare(WorkDataDto<UserInfoEntity> workUserInfo, WorkDataDto<EmployeeEntity> workEmployee, WorkDataDto<DepartmentEntity> workDepartment,
                             WorkDataDto<DepartmentEmployeeEntity> workDepartmentEmployee, WorkDataDto<EmployeeRoleEntity> workEmployeeRole,
                             List<JyzyTeamDto> jyzyTeamDtoList, OrgInfoDto orgInfoDto) {
        log.info("======开始数据对比======");
        try {


            HashMap<String, JyzyUserInfoEntity> jyzyUserInfoHashMap = new HashMap<>();
            jyzyTeamDtoList.forEach(jyzyTeamDto -> jyzyTeamDto.getJyzyUserInfos().forEach(jyzyUserInfo -> jyzyUserInfoHashMap.put(jyzyUserInfo.getId(), jyzyUserInfo)));

            Map<String, String> infoNoAdmin = roleService.findInfoNoAdmin();

            // 1 user_info
            List<UserInfoEntity> insertUserInfoList = new ArrayList<>();
            List<UserInfoEntity> deleteUserInfoList = new ArrayList<>();
            List<UserInfoEntity> updateUserInfoList = new ArrayList<>();

            orgInfoDto.getUserInfoList().forEach(userInfo -> {
                JyzyUserInfoEntity jyzyUserInfo = jyzyUserInfoHashMap.get(userInfo.getId());
                // 删除
                if (ObjectUtil.isNull(jyzyUserInfo)) {
                    deleteUserInfoList.add(userInfo);
                    return; // 跳过当前循环
                }
                // 更新
                if (!jyzyUserInfo.getMD5().equals(userInfo.getMD5()) || StrUtil.isBlank(userInfo.getUiWechatXcxQrcode())) {
                    userInfo.update(jyzyUserInfo);
                    if (StrUtil.isBlank(userInfo.getUiWechatXcxQrcode())) { //重新生成 小程序 球形码
                        userInfo.setUiWechatXcxQrcode(orgSyncService.createWechatXcxQrcode(userInfo.getId(), userInfo.getUiHeadimg()));
                    }
                    updateUserInfoList.add(userInfo);
                }
                jyzyUserInfoHashMap.remove(userInfo.getId());
            });
            jyzyUserInfoHashMap.forEach((key, jyzyUserInfo) -> {
                // 新增
                UserInfoEntity userInfo = new UserInfoEntity(jyzyUserInfo);
                userInfo.setOrgId(orgInfoDto.getOrgId());
                userInfo.setLevel(2);
                userInfo.setUiGrade("0");
                userInfo.setUiRegisterTime(DateTime.now());
                userInfo.setUiWechatXcxQrcode(orgSyncService.createWechatXcxQrcode(userInfo.getId(), userInfo.getUiHeadimg()));
                insertUserInfoList.add(userInfo);
            });

            List<EmployeeEntity> insertEmployeeList = new ArrayList<>();
            List<EmployeeEntity> updateEmployeeList = new ArrayList<>();
            List<EmployeeEntity> deleteEmployeeList = new ArrayList<>();

            List<EmployeeRoleEntity> insertEmployeeRoleList = new ArrayList<>();
            List<EmployeeRoleEntity> updateEmployeeRoleList = new ArrayList<>();
            List<EmployeeRoleEntity> deleteEmployeeRoleList = new ArrayList<>();

            List<DepartmentEmployeeEntity> insertDepartmentEmployeeList = new ArrayList<>();
            List<DepartmentEmployeeEntity> updateDepartmentEmployeeList = new ArrayList<>();
            List<DepartmentEmployeeEntity> deleteDepartmentEmployeeList = new ArrayList<>();

            // 员工新增
            insertUserInfoList.forEach(userInfoEntity -> {
                // employee
                EmployeeEntity employeeEntity = new EmployeeEntity(userInfoEntity);
                employeeEntity.setOrgId(orgInfoDto.getOrgId());
                employeeEntity.setBoundWechat(StrUtil.isNotBlank(userInfoEntity.getUiOpenid()) ? orgInfoDto.getOrgId() + "_" + userInfoEntity.getId() : null);
                insertEmployeeList.add(employeeEntity);

                // employee_role
                EmployeeRoleEntity employeeRoleEntity = new EmployeeRoleEntity();
                employeeRoleEntity.setEmployeeId(userInfoEntity.getId());
                employeeRoleEntity.setRoleId(infoNoAdmin.get("1".equals(userInfoEntity.getUiShenfen()) ? RoleTypeEnum.TEAM.code : RoleTypeEnum.IFA.code));
                employeeRoleEntity.setOrgId(orgInfoDto.getOrgId());
                insertEmployeeRoleList.add(employeeRoleEntity);

                // department_employee 在精业展业中 一个用户对应一个部门
                DepartmentEmployeeEntity departmentEmployee = new DepartmentEmployeeEntity();
                departmentEmployee.setEmployeeId(userInfoEntity.getId());
                departmentEmployee.setDepartmentId(userInfoEntity.getTeamId());
                departmentEmployee.setType("1".equals(userInfoEntity.getUiShenfen()) ? EmployeeDutyEnum.DIRECTOR.code: EmployeeDutyEnum.STAFF.code);
                departmentEmployee.setOrgId(orgInfoDto.getOrgId());
                insertDepartmentEmployeeList.add(departmentEmployee);

            });

            // 员工修改
            updateUserInfoList.forEach(userInfoEntity -> {
                // employee
                Optional<EmployeeEntity> employeeEntityOptional = orgInfoDto.getEmployeeList().stream().filter(employee -> employee.getEmployeeId().equals(userInfoEntity.getId())).findFirst();
                if (employeeEntityOptional.isPresent()) {
                    EmployeeEntity employeeEntity = employeeEntityOptional.get();
                    if (StrUtil.compare(employeeEntity.getName(), userInfoEntity.getUiUsername(), true) != 0
                            || StrUtil.compare(employeeEntity.getPhone(), userInfoEntity.getUiTelphone(), true) != 0
                            || StrUtil.compare(employeeEntity.getMail(), userInfoEntity.getUiEmailMp(), true) != 0
                            || StrUtil.compare(employeeEntity.getNumber(), userInfoEntity.getStaffNo(), true) != 0) {

                        employeeEntity.setName(userInfoEntity.getUiUsername());
                        employeeEntity.setPhone(userInfoEntity.getUiTelphone());
                        employeeEntity.setMail(userInfoEntity.getUiEmailMp());
                        employeeEntity.setNumber(userInfoEntity.getStaffNo());
                        employeeEntity.setBoundWechat(StrUtil.isNotBlank(userInfoEntity.getUiOpenid()) ? orgInfoDto.getOrgId() + "_" + userInfoEntity.getUiUsername() : null);
                        updateEmployeeList.add(employeeEntity);
                    }

                }

                // employee_role
                Optional<EmployeeRoleEntity> employeeRoleEntityOptional = orgInfoDto.getEmployeeRoleList().stream().filter(employeeRole -> employeeRole.getEmployeeId().equals(userInfoEntity.getId())).findFirst();
                if (employeeRoleEntityOptional.isPresent()) {
                    EmployeeRoleEntity employeeRoleEntity = employeeRoleEntityOptional.get();
                    String role = "1".equals(userInfoEntity.getUiShenfen()) ? RoleTypeEnum.TEAM.code : RoleTypeEnum.IFA.code;
                    if (StrUtil.compare(infoNoAdmin.get(role), employeeRoleEntity.getRoleId(), true) != 0) {
                        employeeRoleEntity.setRoleId(infoNoAdmin.get(role));
                        updateEmployeeRoleList.add(employeeRoleEntity);
                    }

                }

                // department_employee
                Optional<DepartmentEmployeeEntity> departmentEmployeeEntityOptional = orgInfoDto.getDepartmentEmployeeList().stream().filter(departmentEmployee -> departmentEmployee.getEmployeeId().equals(userInfoEntity.getId())).findFirst();
                if (departmentEmployeeEntityOptional.isPresent()) {
                    DepartmentEmployeeEntity departmentEmployeeEntity = departmentEmployeeEntityOptional.get();
                    if (StrUtil.compare(userInfoEntity.getTeamId(), departmentEmployeeEntity.getDepartmentId(), true) != 0) {
                        departmentEmployeeEntity.setDepartmentId(userInfoEntity.getTeamId());
                        updateDepartmentEmployeeList.add(departmentEmployeeEntity);
                    }
                }


            });

            // 员工删除
            deleteUserInfoList.forEach(userInfoEntity -> {
                // employee
                Optional<EmployeeEntity> employeeEntityOptional = orgInfoDto.getEmployeeList().stream().filter(employee -> employee.getEmployeeId().equals(userInfoEntity.getId())).findFirst();
                if (employeeEntityOptional.isPresent()) {
                    EmployeeEntity employeeEntity = employeeEntityOptional.get();
                    deleteEmployeeList.add(employeeEntity);
                }

                // employee_role
                Optional<EmployeeRoleEntity> employeeRoleEntityOptional = orgInfoDto.getEmployeeRoleList().stream().filter(employeeRole -> employeeRole.getEmployeeId().equals(userInfoEntity.getId())).findFirst();
                if (employeeRoleEntityOptional.isPresent()) {
                    EmployeeRoleEntity employeeRoleEntity = employeeRoleEntityOptional.get();
                    deleteEmployeeRoleList.add(employeeRoleEntity);
                }

                // department_employee
                Optional<DepartmentEmployeeEntity> departmentEmployeeEntityOptional = orgInfoDto.getDepartmentEmployeeList().stream().filter(departmentEmployee -> departmentEmployee.getEmployeeId().equals(userInfoEntity.getId())).findFirst();
                if (departmentEmployeeEntityOptional.isPresent()) {
                    DepartmentEmployeeEntity departmentEmployeeEntity = departmentEmployeeEntityOptional.get();
                    deleteDepartmentEmployeeList.add(departmentEmployeeEntity);
                }

            });

            workUserInfo.setInsertList(insertUserInfoList);
            workUserInfo.setUpdateList(updateUserInfoList);
            workUserInfo.setDeleteList(deleteUserInfoList);

            workEmployee.setInsertList(insertEmployeeList);
            workEmployee.setUpdateList(updateEmployeeList);
            workEmployee.setDeleteList(deleteEmployeeList);

            workDepartmentEmployee.setInsertList(insertDepartmentEmployeeList);
            workDepartmentEmployee.setUpdateList(updateDepartmentEmployeeList);
            workDepartmentEmployee.setDeleteList(deleteDepartmentEmployeeList);

            workEmployeeRole.setInsertList(insertEmployeeRoleList);
            workEmployeeRole.setUpdateList(updateEmployeeRoleList);
            workEmployeeRole.setDeleteList(deleteEmployeeRoleList);

            // 部门
            List<DepartmentEntity> insertDepartmentList = new ArrayList<>();
            List<DepartmentEntity> updateDepartmentList = new ArrayList<>();
            List<DepartmentEntity> deleteDepartmentList = new ArrayList<>();

            Map<String, JyzyTeamEntity> jyzyTeamEntityMap = jyzyTeamDtoList.stream().collect(Collectors.toMap(jyzyTeamDto -> jyzyTeamDto.getJyzyTeam().getId(), JyzyTeamDto::getJyzyTeam));
            orgInfoDto.getDepartmentList().forEach(departmentEntity -> {
                JyzyTeamEntity jyzyTeamEntity = jyzyTeamEntityMap.get(departmentEntity.getDepartmentId());
                // 删除
                if (ObjectUtil.isNull(jyzyTeamEntity)) {
                    deleteDepartmentList.add(departmentEntity);
                    return;
                }
                // 更新
                int memberNums = 0;
                Optional<JyzyTeamDto> jyzyTeamDtoOptional = jyzyTeamDtoList.stream().filter(jyzyTeamDto -> jyzyTeamDto.getJyzyTeam().getId().equals(departmentEntity.getDepartmentId())).findFirst();
                if (jyzyTeamDtoOptional.isPresent()) {
                    memberNums = jyzyTeamDtoOptional.get().getJyzyUserInfos().size();
                }
                if (StrUtil.compare(departmentEntity.getDepartmentName(), jyzyTeamEntity.getTeamName(), true) != 0
                        || StrUtil.compare(departmentEntity.getParentDepartId(), jyzyTeamEntity.getPId(), true) != 0
                        || !departmentEntity.getMembers().equals(memberNums)) {
                    departmentEntity.setDepartmentName(jyzyTeamEntity.getTeamName());
                    departmentEntity.setParentDepartId(jyzyTeamEntity.getPId());
                    departmentEntity.setMembers(memberNums);
                    updateDepartmentList.add(departmentEntity);
                }
                jyzyTeamEntityMap.remove(departmentEntity.getDepartmentId());
            });


            // 新增
            jyzyTeamEntityMap.forEach((id, jyzyTeamEntity) -> {
                int memberNums = 0;
                Optional<JyzyTeamDto> jyzyTeamDtoOptional = jyzyTeamDtoList.stream().filter(jyzyTeamDto -> jyzyTeamDto.getJyzyTeam().getId().equals(id)).findFirst();
                if (jyzyTeamDtoOptional.isPresent()) {
                    memberNums = jyzyTeamDtoOptional.get().getJyzyUserInfos().size();
                }
                DepartmentEntity department = new DepartmentEntity();
                department.setDepartmentId(id);
                department.setParentDepartId(jyzyTeamEntity.getPId());
                department.setDepartmentName(jyzyTeamEntity.getTeamName());
                int length = jyzyTeamEntity.getFullPathId().split("/").length;
                department.setLevel(length - 1);
                department.setMembers(memberNums);
                department.setOrgId(orgInfoDto.getOrgId());
                insertDepartmentList.add(department);
            });
            workDepartment.setInsertList(insertDepartmentList);
            workDepartment.setUpdateList(updateDepartmentList);
            workDepartment.setDeleteList(deleteDepartmentList);
        } catch (Exception e) {
            log.error("====== 数据对比失败，失败原因-->", e);
        }
        log.info("======结束数据对比======");
    }

    /**
     * @description: 根据理财师机构版的机构code 获取其的 机构及用户信息列表
     * @Author: zejia zj wu
     * @date: 2021/5/27 3:13 下午
     */
    private OrgInfoDto getOrgInfoByFeoOrgCode(String feoOrgCode) throws Exception {
        OrgInfoDto.OrgInfoDtoBuilder orgInfoDtoBuilder = OrgInfoDto.builder();
        try {
            // 1 根据orgcode 获取机构信息
            OrgEntity org = orgService.findByOrgCode(feoOrgCode);
            if (ObjectUtil.isEmpty(org) || StrUtil.isBlank(org.getId())) {
                throw new Exception("feoOrgCode 不存在");
            }
            String orgId = org.getId();
            orgInfoDtoBuilder.orgId(orgId);
            // 2 根据 orgId 获取 userInfoList信息
            List<UserInfoEntity> userInfoList = userInfoService.getUserInfoListByOrgId(orgId);
            orgInfoDtoBuilder.userInfoList(userInfoList);
            // 3 根据 orgId 获取 Employee信息
            List<EmployeeEntity> employeeList = employeeService.getEmployeeSListByOrgId(orgId);
            orgInfoDtoBuilder.employeeList(employeeList);
            // 4 根据 orgId 获取 Department信息
            List<DepartmentEntity> departmentList = departmentService.findDepartmentByOrgId(orgId);
            orgInfoDtoBuilder.departmentList(departmentList);
            // 5 根据 orgId 获取 DepartmentEmployee信息
            List<DepartmentEmployeeEntity> departmentEmployeeList = departmentEmployeeService.findInfoByOrgId(orgId);
            orgInfoDtoBuilder.departmentEmployeeList(departmentEmployeeList);
            // 6 根据 orgId 获取 EmployeeRole信息
            List<EmployeeRoleEntity> employeeRoleList = employeeRoleService.findInfoByOrgId(orgId);
            orgInfoDtoBuilder.employeeRoleList(employeeRoleList);
            // 7 整理数据 将用户安排到 组织下面
            return orgInfoDtoBuilder.build();
        } catch (Exception e) {
            log.error("=======从理财师机构版 数据库中 获取组织及用户 信息 方法出错-->{}======", e.getMessage());
            throw new Exception("同步失败，-->" + e.getMessage());
        }
    }

    /**
     * @description: 根据精业展业的机构code 获取精业展业的 机构及人员信息列表
     * @Author: zejia zj wu
     * @date: 2021/5/27 3:12 下午
     */
    private List<JyzyTeamDto> getJyzyTeamByOrgCode(String jyzyOrgCode) throws Exception {
        try {
            // 1 根据orgcode 获取机构信息
            JyzyOrgEntity jyzyOrg = jyzyOrgService.getOrgByOrgCode(jyzyOrgCode);
            if (ObjectUtil.isEmpty(jyzyOrg) || StrUtil.isBlank(jyzyOrg.getId())) {
                throw new Exception("jyzyOrgCode 不存在");
            }
            // 2 根据 orgId 获取 团队信息 (不包含虚拟组织)
            List<JyzyTeamEntity> jyzyTeamList = jyzyTeamService.getTeamListByOrgId(jyzyOrg.getId());
            // 3 根据 orgId 获取 用户信息 (包含虚拟组织下面的用户)
            List<JyzyUserInfoEntity> userInfoList = jyzyUserInfoService.getUserListByOrgId(jyzyOrg.getId());
            // 4 整理数据 将用户安排到 组织下面 (去除虚拟组织下的用户)
            return jyzyTeamList.stream().map(jyzyTeam -> JyzyTeamDto.builder()
                    .jyzyTeam(jyzyTeam)
                    .jyzyUserInfos(userInfoList.stream().filter(jyzyUserInfo -> jyzyUserInfo.getTeamId().equals(jyzyTeam.getId())).collect(Collectors.toList()))
                    .build()).collect(Collectors.toList());
        } catch (Exception e) {
            log.error("=======从精业展业 数据库中 获取组织及用户 信息 方法出错-->{}======", e.getMessage());
            throw new Exception("同步失败，-->" + e.getMessage());
        }
    }

}