jnpf-java-boot-v6x/jnpf-message/jnpf-message-biz/target/classes/jnpf/message/service/impl/SynThirdInfoServiceImpl.java

package jnpf.message.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.toolkit.JoinWrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import jnpf.base.entity.SuperBaseEntity;
import jnpf.base.entity.SuperExtendEntity;
import jnpf.base.entity.SysConfigEntity;
import jnpf.base.model.synThirdInfo.PaginationSynThirdInfo;
import jnpf.base.service.SuperServiceImpl;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.dingtalk.api.response.OapiV2DepartmentGetResponse;
import jnpf.base.service.SysconfigService;
import jnpf.base.service.SystemConfigApi;
import jnpf.flowable.entity.CommentEntity;
import jnpf.flowable.model.task.TaskVo;
import jnpf.message.entity.SynThirdInfoEntity;
import jnpf.message.mapper.SynThirdInfoMapper;
import jnpf.message.model.SynThirdInfoVo;
import jnpf.message.model.message.DingTalkDeptModel;
import jnpf.message.model.message.OrganizeListVO;
import jnpf.message.service.SynThirdDingTalkService;
import jnpf.message.service.SynThirdInfoService;
import jnpf.base.util.SynDingTalkUtil;
import jnpf.message.util.SynThirdConsts;
import jnpf.message.util.SynThirdTotal;
import jnpf.model.SocialsSysConfig;
import jnpf.permission.entity.OrganizeEntity;
import jnpf.permission.entity.UserEntity;
import jnpf.permission.model.organize.OrganizeModel;
import jnpf.permission.service.OrganizeService;
import jnpf.permission.service.UserService;
import jnpf.util.*;
import jnpf.util.treeutil.SumTree;
import jnpf.util.treeutil.newtreeutil.TreeDotUtils;
import org.jetbrains.annotations.NotNull;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 第三方工具的公司-部门-用户同步表模型
 *
 * @版本： V3.1.0
 * @版权： 引迈信息技术有限公司（https://www.jnpfsoft.com）
 * @作者： JNPF开发平台组
 * @日期： 2021/4/23 17:33
 */
@Service
public class SynThirdInfoServiceImpl extends SuperServiceImpl<SynThirdInfoMapper, SynThirdInfoEntity> implements SynThirdInfoService {
    @Autowired
    private SynThirdInfoService synThirdInfoService;
    @Autowired
    private UserService userApi;
    @Autowired
    private SynThirdDingTalkService synThirdDingTalkService;
    @Autowired
    private SysconfigService sysconfigService;
    @Autowired
    private OrganizeService organizeService;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private CacheKeyUtil cacheKeyUtil;
    public static final String SOCIALS_CONFIG = "SocialsConfig";
    public static final String QYH_DEPARTMENT = "qyhDepartment";
    public static final String DING_DEPARTMENT = "dingDepartment";

    @Override
    public List<SynThirdInfoEntity> getList(String thirdType, String dataType) {
        QueryWrapper<SynThirdInfoEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().and(t -> t.eq(SynThirdInfoEntity::getThirdType, Integer.valueOf(thirdType)));
        queryWrapper.lambda().and(t -> t.eq(SynThirdInfoEntity::getDataType, Integer.valueOf(dataType)));
        queryWrapper.lambda().orderByAsc(SynThirdInfoEntity::getCreatorTime);
        return this.list(queryWrapper);
    }

    @Override
    public List<SynThirdInfoEntity> getList(String thirdType, String dataType, String enableMark) {
        QueryWrapper<SynThirdInfoEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().and(t -> t.eq(SynThirdInfoEntity::getThirdType, Integer.valueOf(thirdType)));
        queryWrapper.lambda().and(t -> t.eq(SynThirdInfoEntity::getDataType, Integer.valueOf(dataType)));
        queryWrapper.lambda().and(t -> t.eq(SynThirdInfoEntity::getEnabledMark, Integer.valueOf(enableMark)));
        queryWrapper.lambda().orderByAsc(SynThirdInfoEntity::getCreatorTime);
        return this.list(queryWrapper);
    }

    @Override
    public SynThirdInfoEntity getInfo(String id) {
        QueryWrapper<SynThirdInfoEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(SynThirdInfoEntity::getId, id);
        return this.getOne(queryWrapper);
    }

    @Override
    public void create(SynThirdInfoEntity entity) {
        String sysObjId = entity.getSysObjId();
        Integer thirdType = entity.getThirdType();
        Integer dataType = entity.getDataType();
        LambdaQueryWrapper<SynThirdInfoEntity> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SynThirdInfoEntity::getSysObjId, sysObjId);
        wrapper.eq(SynThirdInfoEntity::getThirdType, thirdType);
        wrapper.eq(SynThirdInfoEntity::getDataType, dataType);
        SynThirdInfoEntity one = this.getOne(wrapper);
        if (BeanUtil.isNotEmpty(one)) {
            BeanUtil.copyProperties(entity, one,"id");
            this.updateById(one);
            return;
        }
        this.save(entity);
    }

    @Override
    public boolean update(String id, SynThirdInfoEntity entity) {
        entity.setId(id);
        return this.updateById(entity);
    }

    @Override
    public void delete(SynThirdInfoEntity entity) {
        if (entity != null) {
            this.removeById(entity.getId());
        }
    }

    @Override
    public SynThirdInfoEntity getInfoBySysObjId(String thirdType, String dataType, String id) {
        QueryWrapper<SynThirdInfoEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().and(t -> t.eq(SynThirdInfoEntity::getThirdType, thirdType));
        queryWrapper.lambda().and(t -> t.eq(SynThirdInfoEntity::getDataType, dataType));
        queryWrapper.lambda().and(t -> t.eq(SynThirdInfoEntity::getSysObjId, id));
        return this.getOne(queryWrapper);
    }

    public @NotNull List<OrganizeEntity> getOrganizeEntitiesBind(String dingDepartment) {
        // 获取同步表、部门表的信息
        Map<String, OrganizeEntity> organizeList = organizeService.getOrgMapsAll();

        // 部门进行树结构化,固化上下层级序列化
        List<OrganizeModel> organizeModelList = JsonUtil.getJsonToList(organizeList.values(), OrganizeModel.class);
        List<SumTree<OrganizeModel>> trees = TreeDotUtils.convertListToTreeDot(organizeModelList);
        List<SumTree<OrganizeModel>> collect = trees
                .stream().filter(t -> t.getId().equals(dingDepartment)).collect(Collectors.toList());
        List<OrganizeListVO> listVO = JsonUtil.getJsonToList(collect, OrganizeListVO.class);

        // 转化成为按上下层级顺序排序的列表数据
        List<OrganizeEntity> listByOrder = new ArrayList<>();
        for (OrganizeListVO organizeVo : listVO) {
            OrganizeEntity entity = organizeList.get(organizeVo.getId());
            listByOrder.add(entity);
            SynDingTalkUtil.getOrganizeTreeToList(organizeVo, organizeList, listByOrder);
        }
        return listByOrder;
    }

    @Override
    public List<SynThirdInfoVo> getListJoin(PaginationSynThirdInfo paginationSynThirdInfo) {
        MPJLambdaWrapper<SynThirdInfoEntity> wrapper = JoinWrappers.lambda(SynThirdInfoEntity.class);
        wrapper.and(t -> t.eq(SynThirdInfoEntity::getThirdType
                , Integer.valueOf(paginationSynThirdInfo.getThirdType())));
        wrapper.and(t -> t.eq(SynThirdInfoEntity::getDataType
                , Integer.valueOf(paginationSynThirdInfo.getType())));
        wrapper.and(t -> t.eq(SynThirdInfoEntity::getEnabledMark
                , Integer.valueOf(paginationSynThirdInfo.getResultType())));
        if (StringUtil.isNotEmpty(paginationSynThirdInfo.getKeyword())) {
            String keyword = paginationSynThirdInfo.getKeyword();
            wrapper.and(t -> {
                t.like(SynThirdInfoEntity::getDescription, keyword);
                t.or().like(SynThirdInfoEntity::getThirdName, keyword);
                if (paginationSynThirdInfo.getType().equals(SynThirdConsts.DATA_TYPE_ORG)) {
                    t.or().like(OrganizeEntity::getFullName, keyword);
                }
            });

        }
        wrapper.selectAs(SynThirdInfoEntity::getId, SynThirdInfoVo::getId)
                .selectAs(SynThirdInfoEntity::getDataType, SynThirdInfoVo::getDataType)
                .selectAs(SynThirdInfoEntity::getEnabledMark, SynThirdInfoVo::getEnabledMark)
                .selectAs(SynThirdInfoEntity::getCreatorTime, SynThirdInfoVo::getCreatorTime)
                .selectAs(SynThirdInfoEntity::getLastModifyTime, SynThirdInfoVo::getLastModifyTime)
                .selectAs(SynThirdInfoEntity::getThirdType, SynThirdInfoVo::getThirdType)
                .selectAs(SynThirdInfoEntity::getThirdName, SynThirdInfoVo::getThirdName)
                .selectAs(SynThirdInfoEntity::getDescription, SynThirdInfoVo::getDescription)
                .selectAs(SynThirdInfoEntity::getSysObjId, SynThirdInfoVo::getSysObjId);


        if (paginationSynThirdInfo.getType().equals(SynThirdConsts.DATA_TYPE_ORG)) {
            wrapper.leftJoin(OrganizeEntity.class, OrganizeEntity::getId, SynThirdInfoEntity::getSysObjId);
            wrapper.selectAs(OrganizeEntity::getFullName, SynThirdInfoVo::getSystemObjectName);
        } else {
            wrapper.leftJoin(UserEntity.class, UserEntity::getId, SynThirdInfoEntity::getSysObjId);
            wrapper.selectAs(UserEntity::getRealName, SynThirdInfoVo::getSystemObjectName);
        }
        Page<SynThirdInfoVo> page = new Page<>(paginationSynThirdInfo.getCurrentPage(), paginationSynThirdInfo.getPageSize());
        Page<SynThirdInfoVo> synThirdInfoVoPage = this.selectJoinListPage(page, SynThirdInfoVo.class, wrapper);
        return paginationSynThirdInfo.setData(synThirdInfoVoPage.getRecords(), page.getTotal());
    }

    @Override
    public List<SynThirdInfoEntity> getListByDepartment(String thirdTypeDing, String dataTypeOrg, String dingDepartment) {
        List<OrganizeEntity> organizeEntitiesBind = getOrganizeEntitiesBind(dingDepartment);
        LambdaQueryWrapper<SynThirdInfoEntity> synThirdInfoEntityLambdaQueryWrapper = new LambdaQueryWrapper<>();
        synThirdInfoEntityLambdaQueryWrapper.eq(SynThirdInfoEntity::getThirdType, Integer.valueOf(thirdTypeDing));
        synThirdInfoEntityLambdaQueryWrapper.eq(SynThirdInfoEntity::getDataType, Integer.valueOf(dataTypeOrg));
        synThirdInfoEntityLambdaQueryWrapper.eq(SynThirdInfoEntity::getEnabledMark, 1);
        synThirdInfoEntityLambdaQueryWrapper.in(SynThirdInfoEntity::getSysObjId, organizeEntitiesBind
                .stream().map(SuperBaseEntity.SuperIBaseEntity::getId).collect(Collectors.toList()));
        return this.list(synThirdInfoEntityLambdaQueryWrapper);
    }

    @Override
    public SynThirdTotal getSynTotal(String thirdType, String dataType) {
        SocialsSysConfig socialsConfig = sysconfigService.getSocialsConfig();
        String department = "";
        if (thirdType.equals(SynThirdConsts.THIRD_TYPE_DING)) {
            department = socialsConfig.getDingDepartment();
        } else {
            department = socialsConfig.getQyhDepartment();
        }

        List<OrganizeEntity> organizeEntitiesBind = this.getOrganizeEntitiesBind(department);
        List<String> ids = new ArrayList<>();
        if (dataType.equals(SynThirdConsts.DATA_TYPE_ORG)) {
            ids = organizeEntitiesBind.stream()
                    .map(SuperBaseEntity.SuperIBaseEntity::getId)
                    .distinct()
                    .collect(Collectors.toList());
        } else {
            List<UserEntity> userEntities = userApi.getList(organizeEntitiesBind.stream()
                    .map(SuperBaseEntity.SuperIBaseEntity::getId)
                    .collect(Collectors.toList()), "");
            ids = userEntities.stream().map(UserEntity::getId).collect(Collectors.toList());

        }

        String synType = dataType.equals(SynThirdConsts.DATA_TYPE_ORG) ? "组织" : "用户";
        int recordTotal = 0;
        long synSuccessCount = 0L;
        long synFailCount = 0L;
        long unSynCount = 0L;
        Date synDate = null;

        // 获取列表数据
        List<SynThirdInfoEntity> synList = getList(thirdType, dataType).stream().filter(t -> t.getLastModifyTime() != null).collect(Collectors.toList());
        List<String> finalIds = ids;
//        List<SynThirdInfoEntity> collect = synList.stream()
//                .filter(t -> finalIds.contains(t.getSysObjId())).collect(Collectors.toList());
        if (!synList.isEmpty()) {
            synSuccessCount = synList.stream().filter(t -> t.getEnabledMark().equals(SynThirdConsts.SYN_STATE_OK)).count();
            synFailCount = synList.stream().filter(t -> t.getEnabledMark().equals(SynThirdConsts.SYN_STATE_FAIL)).count();
            unSynCount = synList.stream().filter(t -> t.getEnabledMark().equals(SynThirdConsts.SYN_STATE_NO)).count();
            synDate = synList.stream()
                    .max(Comparator.comparing(SuperBaseEntity.SuperCUBaseEntity::getLastModifyTime))
                    .isPresent() ? synList.stream().max(Comparator.comparing(SuperBaseEntity.SuperCUBaseEntity::getLastModifyTime))
                    .get().getLastModifyTime() : null;
        }

        // 获取本系统的组织、用户表的记录数
        if (dataType.equals(SynThirdConsts.DATA_TYPE_ORG)) {
            // 获取组织(公司和部门)的记录数
            recordTotal = synList.size();
        } else {
            // 获取用户的记录数
            recordTotal = synList.size();
        }

        // 写入同步统计模型对象
        SynThirdTotal synThirdTotal = new SynThirdTotal();
        synThirdTotal.setSynType(synType);
        synThirdTotal.setRecordTotal(recordTotal);
        synThirdTotal.setSynSuccessCount(synSuccessCount);
        synThirdTotal.setSynFailCount(synFailCount);
        synThirdTotal.setUnSynCount(unSynCount);
        synThirdTotal.setSynDate(synDate);

        return synThirdTotal;
    }

    @Override
    public List<SynThirdInfoEntity> syncThirdInfoByType(String thirdToSysType, String dataTypeOrg, String SysToThirdType) {

        HashMap<String, String> typeMap = new HashMap<>();
        typeMap.put(SysToThirdType, thirdToSysType);
        typeMap.put(thirdToSysType, SysToThirdType);

        List<SynThirdInfoEntity> synThirdInfoList = this.getList(thirdToSysType, dataTypeOrg);
        List<SynThirdInfoEntity> synThirdInfoDingList = this.getList(typeMap.get(thirdToSysType), dataTypeOrg);


        List<String> collectSource = synThirdInfoList.stream().filter(t -> StringUtil.isBlank(t.getThirdObjId()) || StringUtil.isBlank(t.getSysObjId())).map(SuperBaseEntity.SuperIBaseEntity::getId).collect(Collectors.toList());
        List<String> collectTarget = synThirdInfoDingList.stream().filter(t -> StringUtil.isBlank(t.getThirdObjId()) || StringUtil.isBlank(t.getSysObjId())).map(SuperBaseEntity.SuperIBaseEntity::getId).collect(Collectors.toList());
        List<String> deleteList = new ArrayList<>();
        deleteList.addAll(collectSource);
        deleteList.addAll(collectTarget);
//        List<String> fails = this.selectAllFail();
//        deleteList.addAll(fails);
//        if (!deleteList.isEmpty()) {
//
//            this.getBaseMapper().deleteByIds(deleteList);
//        }


        synThirdInfoList = this.getList(thirdToSysType, dataTypeOrg);
        synThirdInfoDingList = this.getList(typeMap.get(thirdToSysType), dataTypeOrg);
        // 记录已经存在的组合
        HashMap<String, Boolean> existingMap = new HashMap<>();
        synThirdInfoList.forEach(k -> {
            String tag = k.getThirdType() + "-" + k.getDataType() + "-" + k.getSysObjId() + "-" + k.getThirdObjId();
            existingMap.put(tag, true);
        });
        synThirdInfoDingList.forEach(k -> {
            String tag = k.getThirdType() + "-" + k.getDataType() + "-" + k.getSysObjId() + "-" + k.getThirdObjId();
            existingMap.put(tag, true);
        });


        HashMap<String, SynThirdInfoEntity> mapSource = new HashMap<>();
        HashMap<String, SynThirdInfoEntity> mapTarget = new HashMap<>();
        String tag = "";
        for (SynThirdInfoEntity entity : synThirdInfoList) {
//            if(collectSource.size()>0 && !collectSource.contains(entity.getId())){
            tag = entity.getSysObjId() + "-" + entity.getThirdObjId();
            mapSource.put(tag, entity);
//            }
        }
        for (SynThirdInfoEntity entity : synThirdInfoDingList) {
//            if(collectTarget.size()>0 && !collectTarget.contains(entity.getId())){
            tag = entity.getSysObjId() + "-" + entity.getThirdObjId();
            mapTarget.put(tag, entity);
//            }
        }

        // 同步记录
        List<SynThirdInfoEntity> synThirdInfoAddList = new ArrayList<>();
        SynThirdInfoEntity addEntity = null;
        if (mapSource.size() == 0 && mapTarget.size() == 0) {
            return new ArrayList<>();
        } else if (mapSource.size() > 0 && mapTarget.size() == 0) {
            for (String key : mapSource.keySet()) {
                SynThirdInfoEntity synThirdInfoEntity = mapSource.get(key);
                addEntity = JsonUtil.getJsonToBean(synThirdInfoEntity, SynThirdInfoEntity.class);
                addEntity.setId(RandomUtil.uuId());
                addEntity.setThirdType(Integer.valueOf(typeMap.get(thirdToSysType)));
                synThirdInfoAddList.add(addEntity);
            }

        } else if (mapSource.size() == 0 && mapTarget.size() > 0) {
            for (String key : mapTarget.keySet()) {
                SynThirdInfoEntity synThirdInfoEntity = mapTarget.get(key);
                addEntity = JsonUtil.getJsonToBean(synThirdInfoEntity, SynThirdInfoEntity.class);
                addEntity.setId(RandomUtil.uuId());
                addEntity.setThirdType(Integer.valueOf(thirdToSysType));
                synThirdInfoAddList.add(addEntity);
            }
        } else {
            for (String key : mapSource.keySet()) {
                if (!mapTarget.containsKey(key)) {
                    SynThirdInfoEntity synThirdInfoEntity = mapSource.get(key);
                    addEntity = JsonUtil.getJsonToBean(synThirdInfoEntity, SynThirdInfoEntity.class);
                    addEntity.setId(RandomUtil.uuId());
                    addEntity.setThirdType(Integer.valueOf(typeMap.get(thirdToSysType)));
                    synThirdInfoAddList.add(addEntity);
                }
            }
            for (String key : mapTarget.keySet()) {
                if (!mapSource.containsKey(key)) {
                    SynThirdInfoEntity synThirdInfoEntity = mapTarget.get(key);
                    addEntity = JsonUtil.getJsonToBean(synThirdInfoEntity, SynThirdInfoEntity.class);
                    addEntity.setId(RandomUtil.uuId());
                    addEntity.setThirdType(Integer.valueOf(thirdToSysType));
                    synThirdInfoAddList.add(addEntity);
                }
            }

        }

        ArrayList<SynThirdInfoEntity> addList = new ArrayList<>();
        if (synThirdInfoAddList.size() > 0) {
            // 过滤
            synThirdInfoAddList.forEach(k -> {
                String addTag = k.getThirdType() + "-" + k.getDataType() + "-" + k.getSysObjId() + "-" + k.getThirdObjId();
                if (existingMap.get(addTag) == null) {
                    addList.add(k);
                }
            });
            this.saveBatch(addList);
        }
        // 查找对应的数据
        synThirdInfoList = this.getList(thirdToSysType, dataTypeOrg);
        return synThirdInfoList;
    }

    private List<String> selectAllFail() {
        QueryWrapper<SynThirdInfoEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().and(t -> t.eq(SynThirdInfoEntity::getEnabledMark, "2"));
        List<SynThirdInfoEntity> lists = this.getBaseMapper().selectList(queryWrapper);
        return lists.stream().map(t -> t.getId()).collect(Collectors.toList());
    }

    @Override
    public void initBaseDept(Long dingRootDeptId, String access_token, String thirdType) {
        final String sysByThird = this.getSysByThird("1", Integer.valueOf(thirdType));
        // 判断是否在中间表存在
        JSONObject retMsg = new JSONObject();

        if (StringUtil.isBlank(sysByThird)) {
            if ("2".equals(thirdType)) {
                retMsg = SynDingTalkUtil.getDepartmentInfo(SynThirdConsts.DING_ROOT_DEPT_ID, access_token);
                OapiV2DepartmentGetResponse.DeptGetResponse departmentInfo = (OapiV2DepartmentGetResponse.DeptGetResponse) retMsg.get("departmentInfo");
                DingTalkDeptModel model = JsonUtil.getJsonToBean(departmentInfo, DingTalkDeptModel.class);
                retMsg = synThirdDingTalkService.createDepartmentDingToSys(true, model, access_token);
            }
//            if("11".equals(thirdType)){
//                retMsg = SynDingTalkUtil.getDepartmentInfo(SynThirdConsts.QY_ROOT_DEPT_ID, access_token);
//                OapiV2DepartmentGetResponse.DeptGetResponse departmentInfo = (OapiV2DepartmentGetResponse.DeptGetResponse) retMsg.get("departmentInfo");
//                DingTalkDeptModel model = JsonUtil.getJsonToBean(departmentInfo, DingTalkDeptModel.class);
//                retMsg = synThirdDingTalkService.createDepartmentDingToSys(true, model, access_token);
//            }
        }
    }

    @Override
    public boolean getBySysObjId(String id,String thirdType) {
        QueryWrapper<SynThirdInfoEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(SynThirdInfoEntity::getEnabledMark, "1");
        queryWrapper.lambda().eq(SynThirdInfoEntity::getThirdType, Integer.valueOf(thirdType));
        queryWrapper.lambda().eq(SynThirdInfoEntity::getSysObjId, id);
        List<SynThirdInfoEntity> list = this.getBaseMapper().selectList(queryWrapper);
        if (list != null && !list.isEmpty()) {
            return true;
        } else {
            return false;
        }
    }

    @Override
    public String getSysByThird(String valueOf) {
        QueryWrapper<SynThirdInfoEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().isNotNull(SynThirdInfoEntity::getSysObjId);
        queryWrapper.lambda().eq(SynThirdInfoEntity::getThirdObjId, valueOf);
        List<SynThirdInfoEntity> list = this.getBaseMapper().selectList(queryWrapper);
        if (list != null && !list.isEmpty()) {
            return list.get(0).getSysObjId();
        }
        return null;
    }

    @Override
    public String getSysByThird(String valueOf, Integer type) {

        QueryWrapper<SynThirdInfoEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().isNotNull(SynThirdInfoEntity::getSysObjId);
        queryWrapper.lambda().eq(SynThirdInfoEntity::getThirdType, type);
        queryWrapper.lambda().eq(SynThirdInfoEntity::getThirdObjId, valueOf);
        List<SynThirdInfoEntity> list = this.getBaseMapper().selectList(queryWrapper);
        if (list != null && !list.isEmpty()) {
            return list.get(0).getSysObjId();
        }
        return null;
    }

    @Override
    public SynThirdInfoEntity getInfoByThirdObjId(String thirdType, String dataType, String thirdObjId) {
        QueryWrapper<SynThirdInfoEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().and(t -> t.eq(SynThirdInfoEntity::getThirdType, thirdType));
        queryWrapper.lambda().and(t -> t.eq(SynThirdInfoEntity::getDataType, dataType));
        queryWrapper.lambda().and(t -> t.eq(SynThirdInfoEntity::getThirdObjId, thirdObjId));
        return this.getOne(queryWrapper);
    }

    @Override
    public void clearAllSyn(Integer type) {
        QueryWrapper<SynThirdInfoEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(SynThirdInfoEntity::getThirdType, type);
        this.remove(queryWrapper);

        LambdaQueryWrapper<SysConfigEntity> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysConfigEntity::getCategory, SOCIALS_CONFIG);




        //把最高级组织删掉
        if (type.toString().equals(SynThirdConsts.THIRD_TYPE_QY)){
            wrapper.eq(SysConfigEntity::getFkey, QYH_DEPARTMENT);
        }else {
            wrapper.eq(SysConfigEntity::getFkey, DING_DEPARTMENT);
        }
        List<SysConfigEntity> list = sysconfigService.list(wrapper);
        SysConfigEntity configEntity = list.get(0);
        configEntity.setValue("");
        sysconfigService.updateById(configEntity);
        String cacheKey = cacheKeyUtil.getSocialsConfig();
        redisUtil.remove(cacheKey);
    }

}