OrgSyncByWxcpJob.java

package com.tanpu.feo.feojob.jobs;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.crypto.digest.MD5;
import cn.hutool.json.JSONUtil;
import com.tanpu.common.util.JsonUtil;
import com.tanpu.feo.feojob.constant.BaseConstant;
import com.tanpu.feo.feojob.constant.OrgExtConstant;
import com.tanpu.feo.feojob.dao.user.entity.*;
import com.tanpu.feo.feojob.dto.WorkDataDto;
import com.tanpu.feo.feojob.dto.WxCpDepartDto;
import com.tanpu.feo.feojob.enums.EmployeeDutyEnum;
import com.tanpu.feo.feojob.enums.RoleTypeEnum;
import com.tanpu.feo.feojob.feign.CommonResp;
import com.tanpu.feo.feojob.feign.fatools.FeignClientForFatools;
import com.tanpu.feo.feojob.service.*;
import lombok.extern.slf4j.Slf4j;
import me.chanjar.weixin.common.error.WxErrorException;
import me.chanjar.weixin.cp.api.WxCpService;
import me.chanjar.weixin.cp.api.impl.WxCpServiceImpl;
import me.chanjar.weixin.cp.bean.Gender;
import me.chanjar.weixin.cp.bean.WxCpDepart;
import me.chanjar.weixin.cp.bean.WxCpUser;
import me.chanjar.weixin.cp.config.impl.WxCpDefaultConfigImpl;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

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

/**
 * @author zejia zj wu
 * @date 2021-05-18
 * @Description 从企业微信 同步 组织信息 及 员工信息
 */
@Component
@Slf4j
public class OrgSyncByWxcpJob {

    final static String keyStr = "{\"corpId\":\"ww08675a3a48c9e8a2\",\"agentId\":\"1000013\",\"corpSecret\":\"l7eLNC5DDNxmucc9emHsEaSXym4VKDy_D5w4IoOpvqk\",\"token\":\"E1zDvDkXWt\",\"aesKey\":\"43P8lbP5yt8AHLOUPGBPS252c60K9Vzofzm5NOxHHeP\",\"sendMessageAppId\":\"wxe177c62fa1e1c602\"}\n";
    @Resource
    private OrgExtService orgExtService;
    @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 OrgSyncService orgSyncService;
    @Value("${tanpu.sync.job.skipped:true}")
    private boolean jobSkipped;
    @Resource
    private FeignClientForFatools feignClientForFatools;

    @Scheduled(cron = "10 0/10 6-19/1 * * ?")   //每日凌晨6点30开始执行，半小时检查一次
    public void execute() {
        log.info("====== 开始执行OrgSyncByWxcpJob ======");
        try {
            if (!jobSkipped) {
                orgSyncByWxcp("Y");
            }
        } catch (Exception e) {
            log.error("====== 异常结束执行OrgSyncByWxcpJob，错误：{}=======", e.getMessage(), e);
        }
        log.info("====== 结束执行OrgSyncByWxcpJob ======");
    }

    /**
     * 执行 部门 及 员工 同步任务
     *
     * @param isAuto 任务触发类型 Y 定时任务 / N 手动
     */
    public void orgSyncByWxcp(String isAuto) {
        // 1 扫描 org_ext 表 获取需要 执行同步的 机构
        List<OrgExtEntity> orgExtList = orgExtService.findOrgExtByModel(OrgExtConstant.MODEL_ONE);
        for (OrgExtEntity orgExtEntity : orgExtList) {
            String orgId = orgExtEntity.getOrgId();
            log.info("======开始同步机构：{} 的信息======", orgId);

            //2  根据orgId 查找机构 相关信息
            OrgEntity orgEntity = orgService.findById(orgId);

            //3 从企业微信获取组织信息及员工信息
            log.info("======从企业微信获取组织信息及员工信息 开始======");
            WxCpDefaultConfigImpl wxCpDefaultConfig = JSONUtil.toBean(orgExtEntity.getJsonWxcpKey(), WxCpDefaultConfigImpl.class);

            List<WxCpDepart> wxCpDepartList; // 机构信息
            List<WxCpDepartDto> wxCpDepartDtoList;//自定义的 部门信息
            try {
                wxCpDepartList = getWxCpDepartList(wxCpDefaultConfig);
                wxCpDepartDtoList = getWxCpUserList(wxCpDepartList, wxCpDefaultConfig);
            } catch (Exception e) {
                log.error("======从企业微信获取组织信息及员工信息失败->机构：{} -> 错误信息-> {}======", orgId, e.getMessage(), e);
                continue;
            }
            log.info("======从企业微信获取组织信息及员工信息 结束======");

            logOrgManSimpleInfo(orgId, wxCpDepartDtoList);

            //4 判断是否需要 同步
            String digestHex = isExecute(isAuto, wxCpDepartDtoList, orgExtEntity.getMd5WxcpData());
            log.info("====== 机构:{}整体digest, old: {}, new: {}=======", orgId, orgExtEntity.getMd5WxcpData(), digestHex);
            if (StrUtil.isBlank(digestHex)) {
                log.info("====== 机构:{} 不需要执行同步=======", orgId);
                continue;
            }
            String qrCodeUrl = getQrCodeUrl(orgEntity.getId());

            //5 开始比对 5张表 数据 user_info employee department department_employee employee_role
            log.info("======开始比对 5张表 数据 ======");
            String corpId = wxCpDefaultConfig.getCorpId();
            WorkDataDto<UserInfoEntity> workUserInfo = userInfoWork(orgEntity.getId(), wxCpDepartDtoList, corpId, qrCodeUrl);
            WorkDataDto<EmployeeEntity> workEmployee = employeeWork(orgEntity.getId(), wxCpDepartDtoList, corpId);
            WorkDataDto<DepartmentEntity> workDepartment = departmentWork(orgEntity.getId(), wxCpDepartDtoList);
            WorkDataDto<DepartmentEmployeeEntity> workDepartmentEmployee = departmentEmployeeWork(orgEntity.getId(), wxCpDepartDtoList, corpId);
            WorkDataDto<EmployeeRoleEntity> workEmployeeRole = employeeRoleWork(orgEntity.getId(), wxCpDepartDtoList, corpId);
            log.info("======结束比对 5张表 数据 ======");

            //6 数据 更新
            orgSyncService.updateData(orgId, workUserInfo, workEmployee, workDepartment, workDepartmentEmployee, workEmployeeRole);

            //7 讲最新的md5值 存至 orgExtEntity 表中
            orgExtEntity.setMd5WxcpData(digestHex);
            orgExtService.updateById(orgExtEntity);
        }

    }

    private void logOrgManSimpleInfo(String orgId, List<WxCpDepartDto> wxCpDepartDtoList) {
        if (CollectionUtils.isEmpty(wxCpDepartDtoList)) {
            log.info("机构{}当前无部门人员信息", orgId);
            return;
        }
        Map<String, Integer> map = new LinkedHashMap<>(wxCpDepartDtoList.size());
        for (WxCpDepartDto departDto : wxCpDepartDtoList) {
            map.put(departDto.getName() + "," + departDto.getEnName() + "," + departDto.getId(), departDto.getMembers());
        }
        log.info("机构{}当前部门数:{}, 人员数概要是: {}", orgId, wxCpDepartDtoList.size(), JsonUtil.toJson(map));
    }

    private String getQrCodeUrl(String orgId) {
        CommonResp<String> commonResp = feignClientForFatools.getQrCodeUrl(orgId);
        if (commonResp.isNotSuccess()) {
            throw new RuntimeException(commonResp.statusCode + ", " + commonResp.getMessage());
        }
        return commonResp.getAttributes();
    }

    /**
     * @description: 整理 员工与角色关联关系 数据
     * @Author: zejia zj wu
     * @date: 2021/5/27 3:08 下午
     */
    private WorkDataDto<EmployeeRoleEntity> employeeRoleWork(String orgId, List<WxCpDepartDto> wxCpDepartDtoList, String corpId) {
        WorkDataDto<EmployeeRoleEntity> workDataDto = new WorkDataDto<>();
        List<EmployeeRoleEntity> insertList = new ArrayList<>();
        List<EmployeeRoleEntity> deleteList = new ArrayList<>();
        List<EmployeeRoleEntity> updateList = new ArrayList<>();
        //获取 数据库 部门员工关系 信息
        List<EmployeeRoleEntity> employeeRoleList = employeeRoleService.findInfoByOrgId(orgId);
        // 获取 role
        Map<String, String> roleMap = roleService.findInfoNoAdmin();
        // 预处理 新数据
        HashMap<String, WxCpUser> hashMap = new HashMap<>();
        for (WxCpDepartDto wxCpDepartDto : wxCpDepartDtoList) {
            List<WxCpUser> wxCpUserList = wxCpDepartDto.getWxCpUserList();
            for (WxCpUser wxCpUser : wxCpUserList) {
                // key employee_id + '&' + role_id
                String type = wxCpUser.getIsLeader() != null && wxCpUser.getIsLeader() == 1 ? RoleTypeEnum.TEAM.code : RoleTypeEnum.IFA.code;
                hashMap.put(corpId + "_" + wxCpUser.getUserId() + "&" + roleMap.get(type), wxCpUser);
            }
        }
        for (EmployeeRoleEntity employeeRole : employeeRoleList) {
            String employeeId = employeeRole.getEmployeeId();
            String roleId = employeeRole.getRoleId();
            String key = employeeId + "&" + roleId;
            WxCpUser wxCpUser = hashMap.get(key);
            //删除
            if (ObjectUtil.isNull(wxCpUser)) {
                // 删除
                deleteList.add(employeeRole);
                continue;
            }
            // 员工 角色关联关系没有 更新
            hashMap.remove(key);
        }
        Map<String, List<EmployeeRoleEntity>> map = employeeRoleList.stream().collect(Collectors.groupingBy(EmployeeRoleEntity::getEmployeeId));
        String adminRoleId = roleMap.get(RoleTypeEnum.ADMIN.code);
        for (String key : hashMap.keySet()) {
            String[] split = key.split("&");
            String employeeId = split[0];
            String roleId = split[1];
            // 如果已经有一个admin的角色，那么就不要插入新的
            List<EmployeeRoleEntity> roleList = map.get(employeeId);
            if (CollectionUtils.isNotEmpty(roleList) && roleList.stream().anyMatch(p -> StringUtils.equals(p.getRoleId(), adminRoleId))) {
                log.info("成员已经有管理员角色了，不需要再插入, userId: {}, orgId:{}", employeeId, orgId);
                continue;
            }
            EmployeeRoleEntity employeeRole = new EmployeeRoleEntity();
            employeeRole.setEmployeeId(employeeId);
            employeeRole.setRoleId(roleId);
            employeeRole.setOrgId(orgId);
            insertList.add(employeeRole);
        }
        workDataDto.setDeleteList(deleteList);
        workDataDto.setInsertList(insertList);
        workDataDto.setUpdateList(updateList);
        return workDataDto;

    }

    /**
     * @description: 整理 部门与员工关联关系 数据
     * @Author: zejia zj wu
     * @date: 2021/5/27 3:08 下午
     */
    private WorkDataDto<DepartmentEmployeeEntity> departmentEmployeeWork(String orgId, List<WxCpDepartDto> wxCpDepartDtoList, String corpId) {
        WorkDataDto<DepartmentEmployeeEntity> workDataDto = new WorkDataDto<>();
        List<DepartmentEmployeeEntity> insertList = new ArrayList<>();
        List<DepartmentEmployeeEntity> deleteList = new ArrayList<>();
        List<DepartmentEmployeeEntity> updateList = new ArrayList<>();
        //获取 数据库 部门员工关系 信息
        List<DepartmentEmployeeEntity> departmentEmployeeList = departmentEmployeeService.findInfoByOrgId(orgId);
        // 预处理 新数据
        HashMap<String, WxCpUser> hashMap = new HashMap<>();
        for (WxCpDepartDto wxCpDepartDto : wxCpDepartDtoList) {
            List<WxCpUser> wxCpUserList = wxCpDepartDto.getWxCpUserList();
            for (WxCpUser wxCpUser : wxCpUserList) {
                // key department_id + '&' + employee_id
                hashMap.put(orgId + "_" + wxCpDepartDto.getId() + "&" + corpId + "_" + wxCpUser.getUserId(), wxCpUser);

            }
        }
        for (DepartmentEmployeeEntity departmentEmployee : departmentEmployeeList) {
            String departmentId = departmentEmployee.getDepartmentId();
            String employeeId = departmentEmployee.getEmployeeId();
            String key = departmentId + "&" + employeeId;
            WxCpUser wxCpUser = hashMap.get(key);
            if (ObjectUtil.isNull(wxCpUser)) {
                // 删除
                deleteList.add(departmentEmployee);
                continue;
            }
            //更新
            String type = wxCpUser.getIsLeader() != null && wxCpUser.getIsLeader() == 1 ? EmployeeDutyEnum.DIRECTOR.code : EmployeeDutyEnum.STAFF.code;
            if (!departmentEmployee.getType().equals(type)) {
                departmentEmployee.setType(type);
                updateList.add(departmentEmployee);
            }
            hashMap.remove(key);
        }
        for (String s : hashMap.keySet()) {
            WxCpUser wxCpUser = hashMap.get(s);
            String type = wxCpUser.getIsLeader() != null && wxCpUser.getIsLeader() == 1 ? EmployeeDutyEnum.DIRECTOR.code : EmployeeDutyEnum.STAFF.code;
            String[] split = s.split("&");
            String departmentId = split[0];
            String employeeId = split[1];
            DepartmentEmployeeEntity departmentEmployee = new DepartmentEmployeeEntity();
            departmentEmployee.setEmployeeId(employeeId);
            departmentEmployee.setDepartmentId(departmentId);
            departmentEmployee.setType(type);
            departmentEmployee.setOrgId(orgId);
            insertList.add(departmentEmployee);
        }
        workDataDto.setDeleteList(deleteList);
        workDataDto.setInsertList(insertList);
        workDataDto.setUpdateList(updateList);
        return workDataDto;
    }

    /**
     * @description: 整理 部门机构 数据
     * @Author: zejia zj wu
     * @date: 2021/5/27 3:09 下午
     */
    private WorkDataDto<DepartmentEntity> departmentWork(String orgId, List<WxCpDepartDto> wxCpDepartDtoList) {
        WorkDataDto<DepartmentEntity> workDataDto = new WorkDataDto<>();
        List<DepartmentEntity> insertList = new ArrayList<>();
        List<DepartmentEntity> deleteList = new ArrayList<>();
        List<DepartmentEntity> updateList = new ArrayList<>();
        //获取 数据库 部门 信息
        List<DepartmentEntity> departmentList = departmentService.findDepartmentByOrgId(orgId);
        // 预处理 新数据
        HashMap<String, WxCpDepartDto> hashMap = new HashMap<>();
        HashMap<Long, WxCpDepartDto> hashMap2 = new HashMap<>();
        for (WxCpDepartDto wxCpDepartDto : wxCpDepartDtoList) {
            hashMap.put(orgId + "_" + wxCpDepartDto.getId(), wxCpDepartDto);
            hashMap2.put(wxCpDepartDto.getId(), wxCpDepartDto);
        }
        for (DepartmentEntity department : departmentList) {
            String departmentId = department.getDepartmentId();
            WxCpDepartDto wxCpDepartDto = hashMap.get(departmentId);
            //删除
            if (ObjectUtil.isNull(wxCpDepartDto)) {
                deleteList.add(department);
                continue;
            }
            //更新
            Long parentId1 = wxCpDepartDto.getParentId();
            String parentId = ObjectUtil.isNull(hashMap2.get(parentId1)) ? "" : orgId + "_" + parentId1;
            Integer level = getLevel(hashMap2, wxCpDepartDto.getId());
            if (!department.getDepartmentName().equals(wxCpDepartDto.getName()) || StrUtil.compareIgnoreCase(department.getParentDepartId(), parentId, false) != 0
                    || !department.getMembers().equals(wxCpDepartDto.getMembers()) || !level.equals(department.getLevel())) {
                department.setDepartmentName(wxCpDepartDto.getName());
                department.setParentDepartId(parentId);
                department.setMembers(wxCpDepartDto.getMembers());
                department.setLevel(level);
                updateList.add(department);
            }
            hashMap.remove(departmentId);
        }
        //修改
        for (String departmentId : hashMap.keySet()) {
            WxCpDepartDto wxCpDepartDto = hashMap.get(departmentId);
            Long parentId1 = wxCpDepartDto.getParentId();
            String parentId = ObjectUtil.isNull(hashMap2.get(parentId1)) ? "" : orgId + "_" + parentId1;
            DepartmentEntity department = new DepartmentEntity();
            department.setDepartmentId(orgId + "_" + wxCpDepartDto.getId());
            department.setParentDepartId(parentId);
            department.setDepartmentName(wxCpDepartDto.getName());
            department.setLevel(getLevel(hashMap2, wxCpDepartDto.getId()));
            department.setMembers(wxCpDepartDto.getMembers());
            department.setOrgId(orgId);
            insertList.add(department);
        }
        workDataDto.setDeleteList(deleteList);
        workDataDto.setInsertList(insertList);
        workDataDto.setUpdateList(updateList);
        return workDataDto;
    }

    /**
     * @description: 获取部门等级
     * @Author: zejia zj wu
     * @date: 2021/5/27 3:09 下午
     */
    private Integer getLevel(HashMap<Long, WxCpDepartDto> hashMap2, Long id) {
        Long parentId = hashMap2.get(id).getParentId();
        if (ObjectUtil.isNull(hashMap2.get(parentId))) {
            return 1;
        }
        return 1 + getLevel(hashMap2, parentId);
    }

    /**
     * @description: 整理 员工 数据
     * @Author: zejia zj wu
     * @date: 2021/5/27 3:09 下午
     */
    private WorkDataDto<EmployeeEntity> employeeWork(String orgId, List<WxCpDepartDto> wxCpDepartDtoList, String corpId) {
        WorkDataDto<EmployeeEntity> workDataDto = new WorkDataDto<>();
        List<EmployeeEntity> insertList = new ArrayList<>();
        List<EmployeeEntity> deleteList = new ArrayList<>();
        List<EmployeeEntity> updateList = new ArrayList<>();
        //获取 数据库 员工 信息
        List<EmployeeEntity> employeeList = employeeService.getEmployeeSListByOrgId(orgId);

        // 预处理 新数据
        HashMap<String, WxCpUser> hashMap = new HashMap<>();
        for (WxCpDepartDto wxCpDepartDto : wxCpDepartDtoList) {
            List<WxCpUser> wxCpUserList = wxCpDepartDto.getWxCpUserList();
            for (WxCpUser wxCpUser : wxCpUserList) {
                hashMap.put(corpId + "_" + wxCpUser.getUserId(), wxCpUser);
            }
        }

        // 计算 变化数据
        for (EmployeeEntity employee : employeeList) {
            String employeeId = employee.getEmployeeId();
            WxCpUser wxCpUser = hashMap.get(employeeId);
            //删除
            if (ObjectUtil.isNull(wxCpUser)) {
                deleteList.add(employee);
                continue;
            }
            //更新
            String status = wxCpUser.getStatus() == 1 ? "on" : "off";
            if (!employee.getName().equals(wxCpUser.getName()) || !employee.getMail().equals(wxCpUser.getEmail()) ||
                    StrUtil.isBlank(employee.getBoundWechat()) || !employee.getStatus().equals(status)) {
                employee.setName(wxCpUser.getName());
                employee.setMail(wxCpUser.getEmail());
                if (StrUtil.isBlankIfStr(employee.getBoundWechat())) {
                    employee.setBoundWechat(orgId + "_" + wxCpUser.getUserId());
                }
                employee.setStatus(status);
                updateList.add(employee);
            }
            hashMap.remove(employeeId);
        }
        //修改
        for (String key : hashMap.keySet()) {
            WxCpUser wxCpUser = hashMap.get(key);
            EmployeeEntity employee = new EmployeeEntity();
            employee.setEmployeeId(corpId + "_" + wxCpUser.getUserId());
            employee.setName(wxCpUser.getName());
            employee.setPhone(wxCpUser.getMobile());
            employee.setMail(wxCpUser.getEmail());
            employee.setNumber(null);
            employee.setOrgId(orgId);
            employee.setBoundWechat(orgId + "_" + wxCpUser.getUserId());
            employee.setStatus(wxCpUser.getStatus() == 1 ? BaseConstant.EmployeeStatus.ON_JOB : BaseConstant.EmployeeStatus.DEPARTED);
            insertList.add(employee);
        }
        workDataDto.setDeleteList(deleteList);
        workDataDto.setInsertList(insertList);
        workDataDto.setUpdateList(updateList);
        return workDataDto;
    }

    /**
     * @description: 整理 用户表 数据
     * @Author: zejia zj wu
     * @date: 2021/5/27 3:10 下午
     */
    private WorkDataDto<UserInfoEntity> userInfoWork(String orgId, List<WxCpDepartDto> wxCpDepartDtoList, String corpId, String qrCodeUrl) {
        WorkDataDto<UserInfoEntity> workDataDto = new WorkDataDto<>();
        List<UserInfoEntity> insertList = new ArrayList<>();
        List<UserInfoEntity> deleteList = new ArrayList<>();
        List<UserInfoEntity> updateList = new ArrayList<>();
        //获取 数据库用户信息
        List<UserInfoEntity> userInfoList = userInfoService.getUserInfoListByOrgIdAll(orgId);

        // 预处理 新数据
        HashMap<String, WxCpUser> hashMap = new HashMap<>();
        for (WxCpDepartDto wxCpDepartDto : wxCpDepartDtoList) {
            List<WxCpUser> wxCpUserList = wxCpDepartDto.getWxCpUserList();
            for (WxCpUser wxCpUser : wxCpUserList) {
                hashMap.put(corpId + "_" + wxCpUser.getUserId(), wxCpUser);
            }
        }


        // 计算 变化数据
        for (UserInfoEntity userInfo : userInfoList) {
            String id = userInfo.getId();
            WxCpUser wxCpUser = hashMap.get(id);
            // 删除
            if (ObjectUtil.isNull(wxCpUser)) {
                deleteList.add(userInfo);
                continue;
            }
            // 更新
            if (!StringUtils.equals(userInfo.getUiNickname(), wxCpUser.getName()) ||
                    !userInfo.getUiUsername().equals(wxCpUser.getName()) || StrUtil.isBlankIfStr(userInfo.getUiHeadimgMp())
                    || !wxCpUser.getUserId().equals(userInfo.getWxcpUid()) || StrUtil.isBlankIfStr(userInfo.getUiWechatXcxQrcode())
                    || !userInfo.getUiShenfen().equals(String.valueOf(wxCpUser.getIsLeader()))
                    || !StringUtils.equals(userInfo.getUiHeadimg(), wxCpUser.getThumbAvatar())) {
                if ((StringUtils.equals(userInfo.getUiHeadimg(), wxCpUser.getThumbAvatar())
                        || StringUtils.isBlank(userInfo.getUiHeadimg()) && StringUtils.isBlank(wxCpUser.getThumbAvatar()))
                        && StringUtils.isNotBlank(userInfo.getUiWechatXcxQrcode())) {
                    log.info("用户头像未变化，无须重新生成qrcode，{}, {}", JsonUtil.toJson(userInfo), JsonUtil.toJson(wxCpUser));
                } else {
                    userInfo.setUiWechatXcxQrcode(orgSyncService.createWechatXcxQrcode(userInfo.getId(), wxCpUser.getThumbAvatar(), qrCodeUrl));
                }
                userInfo.setUiNickname(wxCpUser.getName());
                userInfo.setUiUsername(wxCpUser.getName());
                userInfo.setUiHeadimgMp(wxCpUser.getThumbAvatar());
                userInfo.setUiHeadimg(wxCpUser.getThumbAvatar());
                userInfo.setWxcpUid(wxCpUser.getUserId());
                userInfo.setUiShenfen(String.valueOf(wxCpUser.getIsLeader()));
                updateList.add(userInfo);
            }
            hashMap.remove(id);
        }
        for (String key : hashMap.keySet()) {
            WxCpUser wxCpUser = hashMap.get(key);
            UserInfoEntity userInfo = new UserInfoEntity();
            userInfo.setUiTelphone(wxCpUser.getMobile());
            userInfo.setUiUsername(wxCpUser.getName());
            Gender gender = wxCpUser.getGender();
            String sex = gender.getCode().equals("1") ? BaseConstant.Gender.MAN : BaseConstant.Gender.WOMEN;
            userInfo.setUiSex(sex);
            userInfo.setUiNickname(wxCpUser.getName());
            userInfo.setUiHeadimg(wxCpUser.getThumbAvatar());
            userInfo.setUiHeadimgMp(wxCpUser.getThumbAvatar());
            userInfo.setOrgId(orgId);
            userInfo.setId(corpId + "_" + wxCpUser.getUserId());
            userInfo.setUiMobilephoneMp(wxCpUser.getMobile());
            userInfo.setDeletetag("0");
            userInfo.setUiShenfen(String.valueOf(wxCpUser.getIsLeader()));
            userInfo.setUiEmailMp(wxCpUser.getEmail());
            String nickName = wxCpUser.getName();
            userInfo.setUiUsername(nickName);
            userInfo.setUiUsernameMp(nickName);
            userInfo.setUiRzstatus(1);
            //默认小名片 0：小名片 1：大名片
            userInfo.setUiTypeMp("1");
            userInfo.setLevel(2);
            // 0： 白银  1：黄金  2：钻石
            userInfo.setUiGrade("0");
            userInfo.setUiSource("pc");
            userInfo.setUiRegisterTime(userInfo.getCreatetime());
            userInfo.setUiChannel(null);
            userInfo.setWxcpUid(wxCpUser.getUserId());
            userInfo.setUiWechatXcxQrcode(orgSyncService.createWechatXcxQrcode(userInfo.getId(), userInfo.getUiHeadimgMp(), qrCodeUrl));
            insertList.add(userInfo);
        }
        workDataDto.setDeleteList(deleteList);
        workDataDto.setInsertList(insertList);
        workDataDto.setUpdateList(updateList);
        return workDataDto;
    }


    /**
     * @description: 判断是否需要执行 并返回数据MD5
     * @Author: zejia zj wu
     * @date: 2021/5/27 3:10 下午
     */
    private String isExecute(String isAuto, List<WxCpDepartDto> wxCpDepartDtoList, String md5WxcpData) {
        String digestHex = MD5.create().digestHex(JSONUtil.toJsonStr(wxCpDepartDtoList));
        if (!"Y".equals(isAuto)) {
            return digestHex;
        }
        if (digestHex.equals(md5WxcpData)) {
            return null;
        }
        return digestHex;
    }

    /**
     * @description: 获取 企业微信 用户列表信息
     * @Author: zejia zj wu
     * @date: 2021/5/27 3:11 下午
     */
    private List<WxCpDepartDto> getWxCpUserList(List<WxCpDepart> wxCpDepartList, WxCpDefaultConfigImpl wxCpDefaultConfig) throws Exception {
        WxCpService cpService = new WxCpServiceImpl();
        cpService.setWxCpConfigStorage(wxCpDefaultConfig);
        ArrayList<WxCpDepartDto> wxCpDepartDtoArrayList = new ArrayList<>();
        for (WxCpDepart wxCpDepart : wxCpDepartList) {
            try {
                List<WxCpUser> wxCpUsers = cpService.getUserService().listByDepartment(wxCpDepart.getId(), Boolean.FALSE, 0);
                if (wxCpUsers == null) {
                    wxCpUsers = new ArrayList<>();
                }
                wxCpUsers.stream().filter(p -> p.getIsLeader() == null).forEach(p -> p.setIsLeader(0));
                WxCpDepartDto wxCpDepartDto = new WxCpDepartDto();
                BeanUtil.copyProperties(wxCpDepart, wxCpDepartDto, true);
                wxCpDepartDto.setWxCpUserList(wxCpUsers);
                wxCpDepartDto.setMembers(wxCpUsers.size());
                wxCpDepartDtoArrayList.add(wxCpDepartDto);
            } catch (WxErrorException e) {
                log.error("======根据企业微信key 获取企业微信员工信息调用失败，错误：{}=======", e.getMessage(), e);
                throw new Exception("根据企业微信key 获取企业微信组织结构调用失败");
            }
        }
        return wxCpDepartDtoArrayList;
    }

    /**
     * @description: 获取 企业微信 部门聊表信息
     * @Author: zejia zj wu
     * @date: 2021/5/27 3:11 下午
     */
    private List<WxCpDepart> getWxCpDepartList(WxCpDefaultConfigImpl wxCpDefaultConfig) throws Exception {
        WxCpService cpService = new WxCpServiceImpl();
        cpService.setWxCpConfigStorage(wxCpDefaultConfig);
        List<WxCpDepart> wxCpDeparts;
        try {
            wxCpDeparts = cpService.getDepartmentService().list(null);
        } catch (WxErrorException e) {
            log.error("======根据企业微信key 获取企业微信组织结构调用失败，错误：{}=======", e.getMessage(), e);
            throw new Exception("根据企业微信key 获取企业微信组织结构调用失败");
        }
        return wxCpDeparts;
    }

    public static void main(String[] args) throws Exception {
        OrgSyncByWxcpJob orgSyncByWxcpJob = new OrgSyncByWxcpJob();
        WxCpDefaultConfigImpl wxCpDefaultConfig = JSONUtil.toBean(keyStr, WxCpDefaultConfigImpl.class);

        List<WxCpDepart> wxCpDepartList = orgSyncByWxcpJob.getWxCpDepartList(wxCpDefaultConfig); // 机构信息
        List<WxCpDepartDto> wxCpDepartDtoList = orgSyncByWxcpJob.getWxCpUserList(wxCpDepartList, wxCpDefaultConfig);
        log.info("=========================");
//        log.info(JSONUtil.toJsonStr(wxCpDepartDtoList));

        String digestHex = MD5.create().digestHex(JSONUtil.toJsonStr(wxCpDepartDtoList));
        log.info(digestHex);
    }

}