jnpf-java-boot-v6x/jnpf-permission/jnpf-permission-biz/target/classes/jnpf/permission/service/impl/OrganizeServiceImpl.java

package jnpf.permission.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.dynamic.datasource.annotation.DSTransactional;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import jnpf.base.ActionResult;
import jnpf.base.UserInfo;
import jnpf.base.entity.DictionaryDataEntity;
import jnpf.base.service.DictionaryDataService;
import jnpf.base.service.SuperServiceImpl;
import jnpf.base.service.SysconfigService;
import jnpf.constant.*;
import jnpf.emnus.OrgTypeEnum;
import jnpf.emnus.SysParamEnum;
import jnpf.message.service.SynThirdDingTalkService;
import jnpf.message.service.SynThirdQyService;
import jnpf.message.util.SynThirdConsts;
import jnpf.model.BaseSystemInfo;
import jnpf.permission.entity.*;
import jnpf.permission.mapper.OrganizeMapper;
import jnpf.permission.model.organize.OrganizeConditionModel;
import jnpf.permission.model.organize.OrganizeListVO;
import jnpf.permission.model.organize.OrganizeModel;
import jnpf.permission.model.organize.OrganizePagination;
import jnpf.permission.service.*;
import jnpf.permission.util.PermissionUtil;
import jnpf.util.*;
import jnpf.util.enums.DictionaryDataEnum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

/**
 * 组织机构
 *
 * @author JNPF开发平台组
 * @version V3.1.0
 * @copyright 引迈信息技术有限公司
 * @date 2019年9月26日 上午9:18
 */
@Service
public class OrganizeServiceImpl extends SuperServiceImpl<OrganizeMapper, OrganizeEntity> implements OrganizeService {

    @Autowired
    private PositionService positionService;
    @Autowired
    private CacheKeyUtil cacheKeyUtil;
    @Autowired
    private UserService userService;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private UserRelationService userRelationService;
    @Autowired
    private RoleRelationService roleRelationService;
    @Autowired
    private SynThirdQyService synThirdQyService;
    @Autowired
    private SynThirdDingTalkService synThirdDingTalkService;
    @Autowired
    private OrganizeAdministratorService organizeAdministratorService;
    @Autowired
    private DictionaryDataService dictionaryDataService;
    @Autowired
    private SysconfigService sysconfigApi;
    @Autowired
    private CodeNumService codeNumService;

    @Override
    public List<OrganizeEntity> getList(OrganizePagination pagination) {
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        boolean flag = false;
        //关键词查询
        if (StringUtil.isNotEmpty(pagination.getKeyword())) {
            flag = true;
            queryWrapper.lambda().and(t -> t.like(OrganizeEntity::getFullName, pagination.getKeyword()).or()
                    .like(OrganizeEntity::getEnCode, pagination.getKeyword()));
        }
        //是否查询子组织
        if (StringUtil.isNotEmpty(pagination.getParentId())) {
            if (Objects.equals(pagination.getParentId(), "0")) {
                queryWrapper.lambda().eq(OrganizeEntity::getParentId, "-1");
            } else {
                queryWrapper.lambda().eq(OrganizeEntity::getParentId, pagination.getParentId());
            }
        }
        //是否查询启用禁用
        if (Objects.equals(pagination.getEnabledMark(), 1)) {
            queryWrapper.lambda().eq(OrganizeEntity::getEnabledMark, 1);
        }
        //排序
        queryWrapper.lambda().orderByAsc(OrganizeEntity::getSortCode).orderByAsc(OrganizeEntity::getCreatorTime);
        if (flag) {
            queryWrapper.lambda().orderByDesc(OrganizeEntity::getLastModifyTime);
        }

        //不分页
        if (Objects.equals(pagination.getDataType(), 1)) {
            return list(queryWrapper);
        }
        //分页
        Page<OrganizeEntity> page = new Page<>(pagination.getCurrentPage(), pagination.getPageSize());
        IPage<OrganizeEntity> iPage = this.page(page, queryWrapper);
        return pagination.setData(iPage.getRecords(), iPage.getTotal());
    }

    @Override
    public void create(OrganizeEntity entity) {
        if (StringUtil.isEmpty(entity.getId())) {
            entity.setId(RandomUtil.uuId());
        }
        // 自动生成编码
        if (StringUtil.isEmpty(entity.getEnCode())) {
            entity.setEnCode(codeNumService.getCodeFunction(() -> codeNumService.getCodeOnce(CodeConst.ZZ), code -> this.isExistByEnCode(code, null)));
        }
        // 设置组织树形id和名称
        setOrgTreeIdAndName(entity);

        entity.setCreatorUserId(UserProvider.getUser().getUserId());
        String positionId = RandomUtil.uuId();
        entity.setDutyPosition(positionId);
        entity.setEnabledMark(1);
        this.save(entity);

        //生成默认岗位
        BaseSystemInfo sysInfo = sysconfigApi.getSysInfo();
        PositionEntity positionEntity = new PositionEntity();
        positionEntity.setId(positionId);
        positionEntity.setEnCode(codeNumService.getCodeFunction(() -> codeNumService.getCodeOnce(CodeConst.GW), code -> positionService.isExistByEnCode(code, null)));
        positionEntity.setFullName(sysInfo.getSysPositionName());
        positionEntity.setOrganizeId(entity.getId());
        positionEntity.setDefaultMark(1);
        positionService.create(positionEntity);
        redisUtil.remove(cacheKeyUtil.getOrganizeInfoList());
        redisUtil.remove(cacheKeyUtil.getPositionList());
        redisUtil.remove(TenantHolder.getDatasourceId() + CacheKeyUtil.SYS_ORG_Tree);
        redisUtil.remove(TenantHolder.getDatasourceId() + CacheKeyUtil.SYS_POS);
    }

    @Override
    public boolean update(String id, OrganizeEntity entity) {
        entity.setId(id);
        if (StringUtil.isEmpty(entity.getEnCode())) {
            entity.setEnCode(codeNumService.getCodeFunction(() -> codeNumService.getCodeOnce(CodeConst.ZZ), code -> this.isExistByEnCode(code, id)));
        }
        entity.setLastModifyTime(DateUtil.getNowDate());
        entity.setLastModifyUserId(UserProvider.getUser().getUserId());
        entity.setEnabledMark(1);
        // 设置组织树形id和名称
        setOrgTreeIdAndName(entity);
        boolean updateById = this.updateById(entity);
        redisUtil.remove(cacheKeyUtil.getOrganizeInfoList());
        redisUtil.remove(cacheKeyUtil.getPositionList());
        redisUtil.remove(TenantHolder.getDatasourceId() + CacheKeyUtil.SYS_ORG_Tree);
        redisUtil.remove(TenantHolder.getDatasourceId() + CacheKeyUtil.SYS_POS);
        return updateById;
    }

    @Override
    public OrganizeEntity getInfo(String id) {
        return this.getById(id);
    }

    @Override
    @DSTransactional
    public ActionResult<String> delete(String orgId, Boolean isSyn) {
        OrganizeEntity organizeEntity = this.getInfo(orgId);
        if (organizeEntity == null) {
            return ActionResult.fail(MsgCode.FA003.get());
        }
        List<OrganizeEntity> orgList = getAllChild(orgId);
        Map<Integer,List<OrganizeEntity>> map = new HashMap<>();
        for (OrganizeEntity org : orgList) {
            String organizeIdTree = org.getOrganizeIdTree();
            int length = organizeIdTree.split(",").length;
            List<OrganizeEntity> organizeEntityList = map.get(length)!=null?map.get(length):new ArrayList<>();
            organizeEntityList.add(org);
            map.put(length,organizeEntityList);
        }



        List<String> orgIdS = orgList.stream().map(OrganizeEntity::getId).collect(Collectors.toList());
        List<PositionEntity> posList = positionService.getListByOrgIds(orgIdS);
        List<String> posIds = posList.stream().map(PositionEntity::getId).collect(Collectors.toList());
        List<String> objectIds = new ArrayList<>();
        objectIds.addAll(orgIdS);
        objectIds.addAll(posIds);
        List<UserRelationEntity> userList = userRelationService.getListByObjectIdAll(objectIds);
        if (CollectionUtil.isNotEmpty(userList)) {
            return ActionResult.fail(MsgCode.PS040.get(MsgCode.PS003.get()));
        }

        //删除组织，和岗位
        for (OrganizeEntity item : orgList) {
            this.removeById(item.getId());
            positionService.deleteByOrgId(item.getId());

        }
        List<Integer> collect = map.keySet()
                .stream().sorted(Comparator.comparing(Integer::byteValue).reversed())
                .collect(Collectors.toList());
        List<OrganizeEntity> organizeEntities =new ArrayList<>();
        for (Integer integer : collect) {
             organizeEntities.addAll(map.get(integer));
        }

            if (isSyn) {
                ThreadPoolExecutorUtil.getExecutor().execute(() -> {
                    try {
                        //删除部门后判断是否需要同步到企业微信
                        synThirdQyService.unifyDepartmentSysToQy(false, organizeEntities, "",SynThirdConsts.DELETE_DEP);
                        //删除部门后判断是否需要同步到钉钉
                        synThirdDingTalkService.unifyDepartmentSysToDing(false, organizeEntities, "",SynThirdConsts.DELETE_DEP);
                    } catch (Exception e) {
                        log.error("删除部门后同步失败到企业微信或钉钉失败，异常：" + e.getMessage());
                    }
                });
            }

        //删除关系
        for (UserRelationEntity ure : userList) {
            userRelationService.removeById(ure);
        }
        List<RoleRelationEntity> roleList = roleRelationService.getListByObjectId(objectIds, null);
        for (RoleRelationEntity rre : roleList) {
            roleRelationService.removeById(rre);
        }
        redisUtil.remove(cacheKeyUtil.getOrganizeInfoList());
        redisUtil.remove(cacheKeyUtil.getPositionList());
        redisUtil.remove(TenantHolder.getDatasourceId() + CacheKeyUtil.SYS_ORG_Tree);
        redisUtil.remove(TenantHolder.getDatasourceId() + CacheKeyUtil.SYS_POS);
        return ActionResult.success(MsgCode.SU003.get());
    }

    @Override
    public boolean checkLevel(OrganizeEntity entity) {
        BaseSystemInfo sysInfo = sysconfigApi.getSysInfo();
        Integer orgLevel = sysInfo.getOrgLevel();
        OrganizeEntity pEntity = this.getInfo(entity.getParentId());
        int thisLevel = 1;
        if (pEntity != null) {
            String[] parents = pEntity.getOrganizeIdTree().split(",");
            //创建修改不同判断
            if (StringUtil.isEmpty(entity.getId())) {
                thisLevel += parents.length;
            } else {
                int childMax = 1;
                List<OrganizeEntity> allChild = this.getAllChild(entity.getId());
                for (OrganizeEntity item : allChild) {
                    String[] trees = item.getOrganizeIdTree().split(entity.getId() + ",");
                    if (trees.length >= 2) {
                        String[] childs = trees[1].split(",");
                        int length = childs.length + 1;
                        if (length > childMax) {
                            childMax = length;
                        }
                    }
                }
                thisLevel = parents.length + childMax;
            }
        }
        return thisLevel <= orgLevel;
    }

    @Override
    public boolean checkOrgType(OrganizeEntity entity) {
        List<OrganizeEntity> listChild = this.getListByParentId(entity.getId());
        OrgTypeEnum orgTypeEnum = OrgTypeEnum.get(entity.getCategory());
        //有一个子组织类型不在范围内就false
        for (OrganizeEntity item : listChild) {
            if (!orgTypeEnum.getChildType().contains(item.getCategory())) {
                return false;
            }
        }
        return true;
    }

    @Override
    public Map<String, Object> getAllOrgsTreeName() {
        Map<String, Object> map = new HashMap<>();
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        List<OrganizeEntity> list = this.list(queryWrapper);
        Map<String, String> collect = list.stream().collect(Collectors.toMap(OrganizeEntity::getId, OrganizeEntity::getFullName));
        for (OrganizeEntity org : list) {
            String organizeIdTree = org.getOrganizeIdTree();
            if (StringUtil.isEmpty(organizeIdTree)) {
                organizeIdTree = org.getId();
            }
            String[] split = organizeIdTree.split(",");
            StringJoiner names = new StringJoiner("/");
            for (String id : split) {
                if (collect.get(id) != null) {
                    names.add(collect.get(id));
                }
            }
            map.put(org.getId(), names.toString());
        }
        return map;
    }

    @Override
    public Map<String, String> getAllOrgsTreeName(boolean enabledMark) {
        Map<String, String> map = new HashMap<>();
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        if (enabledMark) {
            queryWrapper.lambda().eq(OrganizeEntity::getEnabledMark, 1);
        }
        List<OrganizeEntity> list = this.list(queryWrapper);
        Map<String, String> collect = list.stream().collect(Collectors.toMap(OrganizeEntity::getId, OrganizeEntity::getFullName));
        for (OrganizeEntity org : list) {
            String organizeIdTree = org.getOrganizeIdTree();
            if (StringUtil.isEmpty(organizeIdTree)) {
                organizeIdTree = org.getId();
            }
            String[] split = organizeIdTree.split(",");
            StringJoiner names = new StringJoiner("/");
            for (String id : split) {
                if (collect.get(id) != null) {
                    names.add(collect.get(id));
                    continue;
                }
                names = new StringJoiner(names.toString().substring(0, names.toString().length() - 1));
            }
            map.put(org.getId(), names.toString());
        }
        return map;
    }

    @Override
    public List<OrganizeEntity> getListAll(List<String> idAll, String keyWord) {
        // 定义变量判断是否需要使用修改时间倒序
        boolean flag = false;
        List<OrganizeEntity> list = new ArrayList<>();
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        if (StringUtil.isNotEmpty(keyWord)) {
            flag = true;
            queryWrapper.lambda().and(t -> t.like(OrganizeEntity::getFullName, keyWord).or().like(OrganizeEntity::getEnCode, keyWord));
        }
        // 排序
        queryWrapper.lambda().orderByAsc(OrganizeEntity::getSortCode).orderByAsc(OrganizeEntity::getCreatorTime);
        if (flag) {
            queryWrapper.lambda().orderByDesc(OrganizeEntity::getLastModifyTime);
        }
        if (idAll.size() > 0) {
            queryWrapper.lambda().in(OrganizeEntity::getId, idAll);
            list = this.list(queryWrapper);
        }
        return list;
    }

    @Override
    public List<OrganizeEntity> getListByIds(List<String> idList) {
        if (CollectionUtil.isEmpty(idList)) return Collections.EMPTY_LIST;
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        List<List<String>> lists = Lists.partition(idList, 1000);
        for (List<String> list : lists) {
            queryWrapper.lambda().in(OrganizeEntity::getId, list);
        }
        return this.list(queryWrapper);
    }


    @Override
    public boolean isExistByFullName(OrganizeEntity entity, boolean isCheck, boolean isFilter) {
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(OrganizeEntity::getFullName, entity.getFullName());
        if (!isCheck) {
            if (isFilter) {
                queryWrapper.lambda().ne(OrganizeEntity::getId, entity.getId());
            }
            List<OrganizeEntity> entityList = this.list(queryWrapper);
            if (entityList.size() > 0) {
                for (OrganizeEntity organizeEntity : entityList) {
                    if (organizeEntity != null && organizeEntity.getParentId().equals(entity.getParentId())) {
                        return true;
                    }
                }
            }
            return false;
        }
        return this.count(queryWrapper) > 0;
    }

    @Override
    public boolean isExistByEnCode(String enCode, String id) {
        if (StringUtil.isEmpty(enCode)) return false;
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(OrganizeEntity::getEnCode, enCode);
        if (!StringUtil.isEmpty(id)) {
            queryWrapper.lambda().ne(OrganizeEntity::getId, id);
        }
        return this.count(queryWrapper) > 0;
    }

    /**
     * 递归获取组织列表
     *
     * @return
     */
    private void recursionOrg(String id, List<OrganizeEntity> list) {
        OrganizeEntity info = getInfo(id);
        if (info != null) {
            list.add(info);
            recursionOrg(info.getParentId(), list);
        }
    }

    @Override
    public List<OrganizeEntity> getParentList(String parentId) {
        List<OrganizeEntity> list = new ArrayList<>();
        if (StringUtil.isNotEmpty(parentId)) {
            recursionOrg(parentId, list);
            // 倒序排放
            Collections.reverse(list);
        }
        return list;
    }

    @Override
    public List<OrganizeEntity> getListByParentIds(List<String> idList) {
        if (CollectionUtil.isEmpty(idList)) return Collections.EMPTY_LIST;
        LambdaQueryWrapper<OrganizeEntity> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(OrganizeEntity::getParentId, idList);
        wrapper.eq(OrganizeEntity::getEnabledMark, 1);
        return this.list(wrapper);
    }

    @Override
    public void setOrgTreeIdAndName(OrganizeEntity entity) {
        StringJoiner orgIdTree = new StringJoiner(",");
        StringJoiner orgNameTree = new StringJoiner("/");
        List<OrganizeEntity> parentList = getParentList(entity.getParentId());
        if (CollectionUtil.isNotEmpty(parentList)) {
            parentList.stream().forEach(t -> {
                orgIdTree.add(t.getId());
                orgNameTree.add(t.getFullName());
            });
        }
        orgIdTree.add(entity.getId());
        orgNameTree.add(entity.getFullName());
        entity.setOrganizeIdTree(orgIdTree.toString());
        entity.setOrgNameTree(orgNameTree.toString());
    }

    @Override
    public List<OrganizeEntity> getDepsByParentId(String id) {
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(OrganizeEntity::getParentId, id);
        queryWrapper.lambda().eq(OrganizeEntity::getCategory, PermissionConst.DEPARTMENT);
        queryWrapper.lambda().orderByAsc(OrganizeEntity::getSortCode).orderByAsc(OrganizeEntity::getCreatorTime);
        List<OrganizeEntity> list = this.list(queryWrapper);
        return list;
    }

    @Override
    public List<OrganizeEntity> getList(boolean filterEnabledMark) {
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        if (filterEnabledMark) {
            queryWrapper.lambda().eq(OrganizeEntity::getEnabledMark, 1);
        }
        queryWrapper.lambda().orderByAsc(OrganizeEntity::getSortCode).orderByAsc(OrganizeEntity::getCreatorTime);
        List<OrganizeEntity> list = this.list(queryWrapper);
        return list;
    }

    @Override
    public OrganizeEntity getInfoByFullName(String fullName) {
        if (StringUtil.isEmpty(fullName)) {
            return null;
        }
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(OrganizeEntity::getFullName, fullName);
        List<OrganizeEntity> list = this.list(queryWrapper);
        return list.size() > 0 ? list.get(0) : null;
    }

    @Override
    public List<OrganizeEntity> getList(String keyword, boolean filterEnabledMark) {
        return new LinkedList<>(getOrgMaps(keyword, filterEnabledMark, null).values());
    }


    /**
     * 获取组织信息
     *
     * @return OrgId, OrgEntity
     */
    @Override
    public Map<String, OrganizeEntity> getOrgMapsAll(SFunction<OrganizeEntity, ?>... columns) {
        return getOrgMaps(null, false, null, columns);
    }

    /**
     * 获取组织信息
     *
     * @param keyword
     * @param filterEnabledMark
     * @param category
     * @return OrgId, OrgEntity
     */
    @Override
    public Map<String, OrganizeEntity> getOrgMaps(String keyword, boolean filterEnabledMark, String category, SFunction<OrganizeEntity, ?>... columns) {
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        if (StringUtil.isNotEmpty(keyword)) {
            queryWrapper.lambda().and(t -> t.like(OrganizeEntity::getFullName, keyword).or().like(OrganizeEntity::getEnCode, keyword.toLowerCase()));
        }
        if (filterEnabledMark) {
            queryWrapper.lambda().eq(OrganizeEntity::getEnabledMark, 1);
        }
        if (StringUtil.isNotEmpty(category)) {
            queryWrapper.lambda().eq(OrganizeEntity::getCategory, category);
        }
        Map<String, OrganizeEntity> orgMaps = getBaseOrgMaps(queryWrapper, ImmutableMap.of(OrganizeEntity::getSortCode, true, OrganizeEntity::getCreatorTime, false), null, false);

        Map<String, OrganizeEntity> entityList = new LinkedHashMap<>();
        if (StringUtil.isNotEmpty(keyword)) {
            getParentOrganize(orgMaps, orgMaps, entityList);
            orgMaps.clear();
            orgMaps = entityList;
        }
        return orgMaps;
    }


    /**
     * 组织基础过滤
     *
     * @param queryWrapper
     * @param orderBy      Map<Column, isAsc>
     * @param groupBy      Column
     * @param columns      query
     * @return
     */
    public Map<String, OrganizeEntity> getBaseOrgMaps(QueryWrapper<OrganizeEntity> queryWrapper, Map<SFunction<OrganizeEntity, ?>, Boolean> orderBy, List<SFunction<OrganizeEntity, ?>> groupBy, boolean bigColumnHas, SFunction<OrganizeEntity, ?>... columns) {
        if (queryWrapper == null) {
            queryWrapper = new QueryWrapper<>();
        }
        LambdaQueryWrapper<OrganizeEntity> lambdaQueryWrapper = queryWrapper.lambda();

        List<SFunction<OrganizeEntity, ?>> columnList;
        List<SFunction<OrganizeEntity, ?>> bigColumnList = null;
        //没有指定查询字段就返回全部字段
        if (columns == null || columns.length == 0) {
            columnList = Arrays.asList(OrganizeEntity::getId, OrganizeEntity::getParentId, OrganizeEntity::getCategory, OrganizeEntity::getEnCode, OrganizeEntity::getFullName, OrganizeEntity::getManagerId, OrganizeEntity::getSortCode, OrganizeEntity::getEnabledMark, OrganizeEntity::getOrganizeIdTree, OrganizeEntity::getCreatorTime, OrganizeEntity::getCreatorUserId, OrganizeEntity::getLastModifyTime, OrganizeEntity::getLastModifyUserId, OrganizeEntity::getDeleteMark, OrganizeEntity::getDeleteTime, OrganizeEntity::getDeleteUserId, OrganizeEntity::getTenantId);
            //把长文本字段分开查询, 默认带有排序， 数据量大的情况长文本字段参与排序速度非常慢
            if (bigColumnHas) {
                bigColumnList = Arrays.asList(OrganizeEntity::getId, OrganizeEntity::getDescription, OrganizeEntity::getPropertyJson);
            }
        } else {
            columnList = new ArrayList<>(Arrays.asList(columns));
            //指定字段中没有ID， 强制添加ID字段
            if (!columnList.contains((SFunction<OrganizeEntity, ?>) OrganizeEntity::getId)) {
                columnList.add(OrganizeEntity::getId);
            }
        }
        lambdaQueryWrapper.select(columnList);
        QueryWrapper<OrganizeEntity> bigColumnQuery = null;
        if (bigColumnList != null) {
            //获取大字段不参与排序
            bigColumnQuery = queryWrapper.clone();
        }
        //排序
        if (orderBy != null && !orderBy.isEmpty()) {
            orderBy.forEach((k, v) -> {
                lambdaQueryWrapper.orderBy(true, v, k);
            });
        }
        //分组
        if (groupBy != null && !groupBy.isEmpty()) {
            lambdaQueryWrapper.groupBy(groupBy);
        }
        List<OrganizeEntity> list = this.list(queryWrapper);

        Map<String, OrganizeEntity> orgMaps = new LinkedHashMap<>(list.size(), 1);
        list.forEach(t -> orgMaps.put(t.getId(), t));

        if (bigColumnList != null) {
            //获取大字段数据
            bigColumnQuery.lambda().select(bigColumnList);
            List<OrganizeEntity> listBigFields = this.list(bigColumnQuery);
            listBigFields.forEach(t -> {
                OrganizeEntity organizeEntity = orgMaps.get(t.getId());
                if (organizeEntity != null) {
                    organizeEntity.setPropertyJson(t.getPropertyJson());
                    organizeEntity.setDescription(t.getDescription());
                }
            });
        }
        return orgMaps;
    }

    /**
     * 获取父级集合
     *
     * @param list       需要遍历的集合
     * @param entityList 结果集
     */
    private void getParentOrganize(Map<String, OrganizeEntity> list, Map<String, OrganizeEntity> searchList, Map<String, OrganizeEntity> entityList) {
        Map<String, OrganizeEntity> list1 = new LinkedHashMap<>();
        searchList.forEach((id, entity) -> {
            entityList.put(id, entity);
            OrganizeEntity info = list.get(id);
            if (info == null) {
                info = getInfo(id);
            }
            if (Objects.nonNull(info)) {
                if (StringUtil.isNotEmpty(info.getParentId()) && !"-1".equals(info.getParentId())) {
                    OrganizeEntity organizeEntity = list.get(info.getParentId());
                    if (organizeEntity == null) {
                        organizeEntity = getInfo(info.getParentId());
                    }
                    if (organizeEntity != null) {
                        list1.put(organizeEntity.getId(), organizeEntity);
                        getParentOrganize(list, list1, entityList);
                    }
                } else if (StringUtil.isNotEmpty(info.getParentId()) && "-1".equals(info.getParentId())) {
                    entityList.put(id, info);
                }
            }
        });
    }

    @Override
    public List<OrganizeEntity> getOrgEntityList(List<String> idList, Boolean enable) {
        if (!idList.isEmpty()) {
            QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().in(OrganizeEntity::getId, idList);
            if (enable) {
                queryWrapper.lambda().eq(OrganizeEntity::getEnabledMark, 1);
            }
//            queryWrapper.lambda().select(OrganizeEntity::getId, OrganizeEntity::getFullName);
            return this.list(queryWrapper);
        }
        return Collections.EMPTY_LIST;
    }

    @Override
    public Map<String, Object> getOrgMap() {
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().select(OrganizeEntity::getId, OrganizeEntity::getFullName);
        List<OrganizeEntity> list = this.list(queryWrapper);
        return list.stream().collect(Collectors.toMap(OrganizeEntity::getId, OrganizeEntity::getFullName));
    }

    @Override
    public Map<String, Object> getOrgEncodeAndName(String category) {
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().select(OrganizeEntity::getId, OrganizeEntity::getFullName, OrganizeEntity::getEnCode);
        if (StringUtil.isNotEmpty(category)) {
            queryWrapper.lambda().eq(OrganizeEntity::getCategory, category);
        }
        List<OrganizeEntity> list = this.list(queryWrapper);
        return list.stream().collect(Collectors.toMap(o -> o.getFullName() + "/" + o.getEnCode(), OrganizeEntity::getId, (v1, v2) -> v2));
    }

    @Override
    public Map<String, Object> getOrgNameAndId(String category) {
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().select(OrganizeEntity::getId, OrganizeEntity::getFullName);
        if (StringUtil.isNotEmpty(category)) {
            queryWrapper.lambda().eq(OrganizeEntity::getCategory, category);
        }
        List<OrganizeEntity> list = this.list(queryWrapper);
        Map<String, Object> allOrgMap = new HashMap<>();
        for (OrganizeEntity entity : list) {
            allOrgMap.put(entity.getFullName(), entity.getId());
        }
        return allOrgMap;
    }


    @Override
    public OrganizeEntity getByFullName(String fullName) {
        OrganizeEntity organizeEntity = new OrganizeEntity();
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(OrganizeEntity::getFullName, fullName);
        queryWrapper.lambda().select(OrganizeEntity::getId);
        List<OrganizeEntity> list = this.list(queryWrapper);
        if (list.size() > 0) {
            organizeEntity = list.get(0);
        }
        return organizeEntity;
    }


    @Override
    public void getOrganizeIdTree(String organizeId, List<String> organizeParentIdList) {
        OrganizeEntity entity = getInfo(organizeId);
        if (entity != null) {
            organizeParentIdList.add(entity.getId());
            if (StringUtil.isNotEmpty(entity.getParentId())) {
                getOrganizeIdTree(entity.getParentId(), organizeParentIdList);
            }
        }
    }

    @Override
    public void getOrganizeId(String organizeId, List<OrganizeEntity> organizeList) {
        OrganizeEntity entity = getInfo(organizeId);
        if (entity != null) {
            organizeList.add(entity);
            if (StringUtil.isNotEmpty(entity.getParentId())) {
                getOrganizeId(entity.getParentId(), organizeList);
            }
        }
    }


    @Override
    @DSTransactional
    public boolean first(String id) {
        boolean isOk = false;
        //获取要上移的那条数据的信息
        OrganizeEntity upEntity = this.getById(id);
        Long upSortCode = upEntity.getSortCode() == null ? 0 : upEntity.getSortCode();
        //查询上几条记录
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().lt(OrganizeEntity::getSortCode, upSortCode).eq(OrganizeEntity::getParentId, upEntity.getParentId()).orderByDesc(OrganizeEntity::getSortCode);
        List<OrganizeEntity> downEntity = this.list(queryWrapper);
        if (downEntity.size() > 0) {
            //交换两条记录的sort值
            Long temp = upEntity.getSortCode();
            upEntity.setSortCode(downEntity.get(0).getSortCode());
            downEntity.get(0).setSortCode(temp);
            this.updateById(downEntity.get(0));
            this.updateById(upEntity);
            isOk = true;
        }
        return isOk;
    }

    @Override
    @DSTransactional
    public boolean next(String id) {
        boolean isOk = false;
        //获取要下移的那条数据的信息
        OrganizeEntity downEntity = this.getById(id);
        Long upSortCode = downEntity.getSortCode() == null ? 0 : downEntity.getSortCode();
        //查询下几条记录
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().gt(OrganizeEntity::getSortCode, upSortCode).eq(OrganizeEntity::getParentId, downEntity.getParentId()).orderByAsc(OrganizeEntity::getSortCode);
        List<OrganizeEntity> upEntity = this.list(queryWrapper);
        if (upEntity.size() > 0) {
            //交换两条记录的sort值
            Long temp = downEntity.getSortCode();
            downEntity.setSortCode(upEntity.get(0).getSortCode());
            upEntity.get(0).setSortCode(temp);
            this.updateById(upEntity.get(0));
            this.updateById(downEntity);
            isOk = true;
        }
        return isOk;
    }

    @Override
    public String allowDelete(String orgId) {
        // 组织底下是否有组织
        List<OrganizeEntity> list = getListByParentId(orgId);
        if (Objects.nonNull(list) && list.size() > 0) {
            return MsgCode.PS003.get();
        }
        // 组织底下是否有岗位
        List<PositionEntity> positonList = positionService.getListByOrganizeId(Collections.singletonList(orgId), false);
        List<String> positonIds = positonList.stream().map(PositionEntity::getId).collect(Collectors.toList());

        // 组织底下是否有用户
        if (userRelationService.existByObj(PermissionConst.ORGANIZE, orgId)) {
            return MsgCode.PS005.get();
        }
        // 组织底下是否有角色
        List<RoleRelationEntity> listByObjectId = roleRelationService.getListByObjectId(positonIds, PermissionConst.POSITION);
        if (listByObjectId.size() > 0) {
            return MsgCode.PS006.get();
        }
        return null;
    }

    @Override
    public List<OrganizeEntity> getOrganizeName(List<String> id) {
        List<OrganizeEntity> list = new ArrayList<>();
        if (id.size() > 0) {
            QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
            List<List<String>> lists = Lists.partition(id, 1000);
            queryWrapper.lambda().and(t->{
                for (List<String> ids : lists) {
                    t.or().in(OrganizeEntity::getId, ids);
                }
            });
            queryWrapper.lambda().orderByAsc(OrganizeEntity::getSortCode).orderByAsc(OrganizeEntity::getCreatorTime);
            list = this.list(queryWrapper);
        }
        return list;
    }

    @Override
    public Map<String, OrganizeEntity> getOrganizeName(List<String> id, String keyword, boolean filterEnabledMark, String category) {
        Map<String, OrganizeEntity> list = Collections.EMPTY_MAP;
        if (id.size() > 0) {
            QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
            List<List<String>> lists = Lists.partition(id, 1000);
            queryWrapper.lambda().and(t->{
                for (List<String> ids : lists) {
                    t.or().in(OrganizeEntity::getId, ids);
                }
            });
            if (StringUtil.isNotEmpty(keyword)) {
                queryWrapper.lambda().and(t -> t.like(OrganizeEntity::getFullName, keyword).or().like(OrganizeEntity::getEnCode, keyword));
            }
            if (StringUtil.isNotEmpty(category)) {
                queryWrapper.lambda().eq(OrganizeEntity::getCategory, category);
            }
            if (filterEnabledMark) {
                queryWrapper.lambda().eq(OrganizeEntity::getEnabledMark, 1);
            }
            list = getBaseOrgMaps(queryWrapper, ImmutableMap.of(OrganizeEntity::getSortCode, true, OrganizeEntity::getCreatorTime, false), null, false);
//            Map<String, OrganizeEntity> orgList = new LinkedHashMap<>(id.size(), 1);
//            orgMaps.values().forEach(t -> {
//                if (StringUtil.isNotEmpty(t.getOrganizeIdTree())) {
//                    String[] split = t.getOrganizeIdTree().split(",");
//                    for (String orgId : split) {
//                        if (id.contains(orgId) && !orgList.containsKey(orgId)) {
//                            OrganizeEntity entity = orgMaps.get(orgId);
//                            if(entity == null){
//                                entity = getInfo(orgId);
//                            }
//                            if (entity != null) {
//                                orgList.put(orgId, entity);
//                            }
//                        }
//                    }
//                }
//            });
//            list = orgList;
        }
        return list;
    }


    @Override
    public List<String> getUnderOrganizations(String organizeId, boolean filterEnabledMark) {
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        if (filterEnabledMark) {
            queryWrapper.lambda().eq(OrganizeEntity::getEnabledMark, 1);
        }
        queryWrapper.lambda().ne(OrganizeEntity::getId, organizeId);
        queryWrapper.lambda().like(OrganizeEntity::getOrganizeIdTree, organizeId);
        queryWrapper.lambda().select(OrganizeEntity::getId);
        return this.list(queryWrapper).stream().map(OrganizeEntity::getId).collect(Collectors.toList());
    }

    @Override
    public List<String> getUnderOrganizationss(String organizeId) {
        List<String> totalIds = this.getUnderOrganizations(organizeId, false);
        if (!UserProvider.getUser().getIsAdministrator()) {
            // 得到有权限的组织
            List<String> collect = organizeAdministratorService.getListByAuthorize().stream().map(OrganizeEntity::getId).collect(Collectors.toList());
            totalIds = totalIds.stream().filter(t -> collect.contains(t)).collect(Collectors.toList());
        }
        return totalIds;
    }

    @Override
    public List<OrganizeEntity> getListByParentId(String id) {
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(OrganizeEntity::getParentId, id);
        queryWrapper.lambda().eq(OrganizeEntity::getEnabledMark, 1);
        return this.list(queryWrapper);
    }

    @Override
    public List<OrganizeEntity> getAllOrgByUserId(String userId) {
        List<String> ids = new ArrayList<>();
        userRelationService.getAllOrgRelationByUserId(userId).forEach(r -> {
            ids.add(r.getObjectId());
        });
        return this.listByIds(ids);
    }

    @Override
    public String getFullNameByOrgIdTree(Map<String, String> idNameMaps, String orgIdTree, String regex) {
        if (idNameMaps == null || idNameMaps.isEmpty()) {
            idNameMaps = this.getInfoList();
        }
        String fullName = "";
        if (StringUtil.isNotEmpty(orgIdTree)) {
            String[] split = orgIdTree.split(",");
            StringBuilder orgName = new StringBuilder();
            String tmpName;
            for (String orgId : split) {
                if (StringUtil.isEmpty(orgIdTree)) {
                    continue;
                }
                if ((tmpName = idNameMaps.get(orgId)) != null) {
                    orgName.append(regex).append(tmpName);
                }
            }
            if (orgName.length() > 0) {
                fullName = orgName.toString().replaceFirst(regex, "");
            }
        }
        return fullName;
    }

    @Override
    public String getOrganizeIdTree(OrganizeEntity entity) {
        List<String> list = new ArrayList<>();
        this.getOrganizeIdTree(entity.getParentId(), list);
        // 倒序排放
        Collections.reverse(list);
        StringBuilder organizeIdTree = new StringBuilder();
        for (String organizeParentId : list) {
            organizeIdTree.append("," + organizeParentId);
        }
        String organizeParentIdTree = organizeIdTree.toString();
        if (StringUtil.isNotEmpty(organizeParentIdTree)) {
            organizeParentIdTree = organizeParentIdTree.replaceFirst(",", "");
        }
        return organizeParentIdTree;
    }

    @Override
    public List<OrganizeEntity> getOrganizeByParentId(String parentId) {
        QueryWrapper<OrganizeEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(OrganizeEntity::getParentId, parentId);
        return this.list(queryWrapper);
    }

    @Override
    public List<OrganizeEntity> getAllChild(String id) {
        QueryWrapper<OrganizeEntity> wrapper = new QueryWrapper<>();
        wrapper.lambda().eq(OrganizeEntity::getEnabledMark, 1).like(OrganizeEntity::getOrganizeIdTree, id);
        return this.list(wrapper);
    }

    @Override
    public List<OrganizeEntity> getDepartmentAll(String organizeId) {
        OrganizeEntity organizeCompany = getOrganizeCompany(organizeId);
        if (null == organizeCompany) {
            return new ArrayList<>();
        }
        String id = organizeCompany.getId();
        List<OrganizeEntity> organizeList = new ArrayList<>();
        organizeList.add(organizeCompany);
        List<OrganizeEntity> organizeEntityList = getListByParentId(id).stream().filter(t -> PermissionConst.DEPARTMENT.equals(t.getCategory())).collect(Collectors.toList());
        for (OrganizeEntity entity : organizeEntityList) {
            QueryWrapper<OrganizeEntity> wrapper = new QueryWrapper<>();
            wrapper.lambda().eq(OrganizeEntity::getEnabledMark, 1).like(OrganizeEntity::getOrganizeIdTree, entity.getId());
            organizeList.addAll(this.list(wrapper));
        }
        return organizeList;
    }

    @Override
    public OrganizeEntity getOrganizeCompany(String organizeId) {
        OrganizeEntity entity = getInfo(organizeId);
        if (entity == null) {
            return null;
        }
        List<String> categoryList = ImmutableList.of("group", "company", "subsidiary", "unit");
        if (categoryList.contains(entity.getCategory())) {
            return entity;
        } else {
            return PermissionConst.DEPARTMENT.equals(entity.getCategory()) ? getOrganizeCompany(entity.getParentId()) : null;
        }
    }

    @Override
    public void getOrganizeDepartmentAll(String organizeId, List<OrganizeEntity> organizeList) {
        List<OrganizeEntity> organizeEntityList = getListByParentId(organizeId);
        for (OrganizeEntity entity : organizeEntityList) {
            if (!PermissionConst.COMPANY.equals(entity.getCategory())) {
                organizeList.add(entity);
                getOrganizeDepartmentAll(entity.getId(), organizeList);
            }
        }
    }

    @Override
    public List<String> getOrgIdTree(OrganizeEntity entity) {
        List<String> orgIds = new ArrayList<>();
        if (entity != null) {
            String organizeIdTree = entity.getOrganizeIdTree();
            if (StringUtil.isNotEmpty(organizeIdTree)) {
                String[] split = organizeIdTree.split(",");
                for (String orgId : split) {
                    orgIds.add(orgId);
                }
            }
        }
        return orgIds;
    }

    @Override
    public List<String> upWardRecursion(List<String> orgIDs, String orgID) {
        this.getOrgIDs(orgIDs, orgID);
        return orgIDs;
    }

    @Override
    public Map<String, String> getInfoList() {
        if (redisUtil.exists(cacheKeyUtil.getOrganizeInfoList())) {
            return new HashMap<>(redisUtil.getMap(cacheKeyUtil.getOrganizeInfoList()));
        } else {
            Map<String, OrganizeEntity> orgs = getOrgMaps(null, false, null, OrganizeEntity::getFullName);
            Map<String, String> infoMap = new LinkedHashMap<>(orgs.size(), 1);
            orgs.forEach((k, v) -> infoMap.put(k, v.getFullName()));
            redisUtil.insert(cacheKeyUtil.getOrganizeInfoList(), infoMap);
            return infoMap;
        }
    }

    private void getOrgIDs(List<String> orgIDs, String orgID) {
        OrganizeEntity info = this.getInfo(orgID);
        if (info != null) {
            this.getOrgIDs(orgIDs, info.getParentId());
            orgIDs.add(info.getId());
        }
    }

    @Override
    public List<String> getOrgIds(List<String> departIds, String type) {
        List<String> idList = new ArrayList<>(16);
        // 获取所有组织
        if (departIds.size() > 0) {
            List<String> collect = departIds.stream().filter(JnpfConst.SYSTEM_PARAM.keySet()::contains).collect(Collectors.toList());
            String organizeId = UserProvider.getUser().getOrganizeId();
            collect.forEach(t -> {
                if (JnpfConst.CURRENT_ORG.equals(t) || JnpfConst.CURRENT_ORG_TYPE.equals(t)) {
                    idList.add(organizeId + "--" + jnpf.constant.PermissionConst.COMPANY);
                    idList.add(organizeId);
                } else if (JnpfConst.CURRENT_ORG_SUB.equals(t) || JnpfConst.CURRENT_ORG_SUB_TYPE.equals(t)) {
                    List<String> underOrganizations = this.getUnderOrganizations(organizeId, true);
                    underOrganizations.add(organizeId);
                    underOrganizations.forEach(orgId -> {
                        idList.add(orgId + "--" + jnpf.constant.PermissionConst.COMPANY);
                        idList.add(orgId);
                    });
                } else if (JnpfConst.CURRENT_GRADE.equals(t) || JnpfConst.CURRENT_GRADE_TYPE.equals(t)) {
                    List<String> organizeUserList = organizeAdministratorService.getOrganizeUserList(JnpfConst.CURRENT_ORG_SUB);
                    organizeUserList.forEach(orgId -> {
                        idList.add(orgId + "--" + jnpf.constant.PermissionConst.COMPANY);
                        idList.add(orgId);
                    });
                }
            });
            departIds.removeAll(collect);
            idList.addAll(departIds);
            for (String departId : departIds) {
                String[] split = departId.split("--");
                if (split.length == 1 || split.length == 0) {
                    continue;
                }
                if (split.length > 1) {
                    if (jnpf.constant.PermissionConst.ORGANIZE.equals(split[1])) {
                        departId = split[0];
                    }
                    if (jnpf.constant.PermissionConst.DEPARTMENT.equals(split[1])) {
                        departId = split[0];
                    }
                }
                if (!jnpf.constant.PermissionConst.ROLE.equals(type)) {
                    List<String> underOrganizations = this.getUnderOrganizations(departId, true);
                    if (underOrganizations.size() > 0) {
                        idList.addAll(underOrganizations);
                        idList.add(organizeId);
                    }
                }
            }
        }
        return idList.stream().distinct().collect(Collectors.toList());
    }

    @Override
    public List<OrganizeModel> getOrgIdsList(OrganizeConditionModel organizeConditionModel) {
        List<String> ids = new ArrayList<>();
        List<String> orgIds = getOrgIds(organizeConditionModel.getDepartIds(), null);
        Map<String, String> orgIdNameMaps = Optional.ofNullable(organizeConditionModel.getOrgIdNameMaps()).orElse(this.getInfoList());
        orgIds.forEach(t -> ids.add(t.split("--")[0]));
        List<OrganizeEntity> listAll = this.getListAll(ids, organizeConditionModel.getKeyword());
        List<OrganizeModel> organizeList = JsonUtil.getJsonToList(listAll, OrganizeModel.class);
        organizeList.forEach(t -> {
            t.setIcon("department".equals(t.getCategory()) ? PermissionConst.DEPARTMENT_ICON : PermissionConst.COMPANY_ICON);
            t.setLastFullName(t.getFullName());
            if (StringUtil.isNotEmpty(t.getOrganizeIdTree())) {
                t.setOrganizeIds(Arrays.asList(t.getOrganizeIdTree().split(",")));
                t.setOrganize(this.getFullNameByOrgIdTree(orgIdNameMaps, t.getOrganizeIdTree(), "/"));
                String[] split = t.getOrganizeIdTree().split(",");
                List<String> list = Arrays.asList(split);
                Collections.reverse(list);
                for (int i = 1; i < list.size(); i++) {
                    String orgId = list.get(i);
                    List<OrganizeModel> collect1 = organizeList.stream().filter(tt -> orgId.equals(tt.getId())).collect(Collectors.toList());
                    if (collect1.size() > 0) {
                        String[] split1 = StringUtil.isNotEmpty(t.getOrganizeIdTree()) ? t.getOrganizeIdTree().split(orgId) : new String[0];
                        if (split1.length > 0) {
                            t.setFullName(this.getFullNameByOrgIdTree(orgIdNameMaps, split1[1], "/"));
                        }
                        t.setOrganize(this.getFullNameByOrgIdTree(orgIdNameMaps, t.getOrganizeIdTree(), "/"));
                        t.setParentId(orgId);
                        break;
                    }
                }
            }
        });
        return organizeList;
    }

    @Override
    public List<OrganizeListVO> selectedList(List<String> idStrList) {
        if (CollectionUtil.isEmpty(idStrList)) return Collections.EMPTY_LIST;
        List<String> idList = new ArrayList<>();

        for (String idStr : idStrList) {
            String[] split = idStr.split("--");
            idList.add(split[0]);
        }
        List<OrganizeEntity> listByIds = this.getListByIds(idList);
        List<OrganizeListVO> listVo = new ArrayList<>();
        for (String idStr : idStrList) {
            String[] split = idStr.split("--");
            String id = split[0];
            String type = split.length > 1 ? split[1] : "";
            SysParamEnum sysParamEnum = SysParamEnum.get(type);
            String suffix = sysParamEnum != null ? sysParamEnum.getSuffix() : "";
            OrganizeEntity organizeEntity = listByIds.stream().filter(t -> t.getId().equals(id)).findFirst().orElse(null);
            if (organizeEntity != null) {
                OrganizeListVO vo = JsonUtil.getJsonToBean(organizeEntity, OrganizeListVO.class);
                vo.setId(idStr);
                vo.setOrgNameTree(organizeEntity.getOrgNameTree() + suffix);
                listVo.add(vo);
            }
        }
        return listVo;
    }

    @Override
    public List<OrganizeEntity> OrganizeCondition(List<String> idStrList) {
        if (CollectionUtil.isEmpty(idStrList)) return Collections.EMPTY_LIST;

        List<String> idList = new ArrayList<>();
        List<String> parenList = new ArrayList<>();//用于查子组织
        List<String> ancestorsList = new ArrayList<>();//用于查孙子组织

        UserInfo userInfo = UserProvider.getUser();
        List<String> currentOrgIds = userInfo.getOrganizeIds();

        for (String idStr : idStrList) {
            if (DataInterfaceVarConst.ORG.equals(idStr)) {
                idList.addAll(currentOrgIds);
            } else if (DataInterfaceVarConst.ORGANDSUB.equals(idStr)) {
                idList.addAll(currentOrgIds);
                parenList.addAll(currentOrgIds);
            } else if (DataInterfaceVarConst.ORGANIZEANDPROGENY.equals(idStr)) {
                ancestorsList.addAll(currentOrgIds);
            } else {
                String[] split = idStr.split("--");
                idList.add(split[0]);
                if (split.length > 1) {
                    if (SysParamEnum.SUBORG.getCode().equalsIgnoreCase(split[1])) {
                        parenList.add(split[0]);
                    }
                    if (SysParamEnum.PROGENYORG.getCode().equalsIgnoreCase(split[1])) {
                        ancestorsList.add(split[0]);
                    }
                }
            }
        }
        if (CollectionUtil.isEmpty(idList) && CollectionUtil.isEmpty(parenList) && CollectionUtil.isEmpty(ancestorsList)) {
            return Collections.EMPTY_LIST;
        }
        QueryWrapper<OrganizeEntity> query = new QueryWrapper<>();

        query.lambda().eq(OrganizeEntity::getEnabledMark, 1);
        query.lambda().and(t -> {
            if (CollectionUtil.isNotEmpty(idList)) {
                List<List<String>> lists = Lists.partition(idList, 1000);
                for (List<String> thisList : lists) {
                    t.in(OrganizeEntity::getId, thisList).or();
                }
            }
            if (CollectionUtil.isNotEmpty(parenList)) {
                List<List<String>> lists = Lists.partition(parenList, 1000);
                for (List<String> thisList : lists) {
                    t.in(OrganizeEntity::getParentId, thisList).or();
                }
            }
            if (CollectionUtil.isNotEmpty(ancestorsList)) {
                for (String thisId : ancestorsList) {
                    t.like(OrganizeEntity::getOrganizeIdTree, thisId).or();
                }
            }
        });
        query.lambda().orderByAsc(OrganizeEntity::getSortCode).orderByAsc(OrganizeEntity::getCreatorTime);
        return this.list(query);
    }

    @Override
    public String getNameByIdStr(String idStr) {
        StringJoiner sj = new StringJoiner(",");
        if (StringUtil.isNotEmpty(idStr)) {
            try {
                List<String> ids = JsonUtil.getJsonToList(idStr, String.class);
                List<OrganizeEntity> listByIds = this.getListByIds(ids);
                for (OrganizeEntity item : listByIds) {
                    sj.add(item.getOrgNameTree());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return sj.toString();
    }

    @Override
    public List<OrganizeEntity> getProgeny(List<String> idList, Integer enabledMark) {
        if (CollectionUtil.isEmpty(idList)) return Collections.EMPTY_LIST;
        QueryWrapper<OrganizeEntity> query = new QueryWrapper<>();
        if (enabledMark != null) {
            query.lambda().eq(OrganizeEntity::getEnabledMark, enabledMark);
        }
        query.lambda().and(t -> {
            for (String thisId : idList) {
                t.like(OrganizeEntity::getOrganizeIdTree, thisId).or();
            }
        });
        query.lambda().orderByAsc(OrganizeEntity::getSortCode).orderByAsc(OrganizeEntity::getCreatorTime);
        return this.list(query);
    }
}