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

package jnpf.permission.service.impl;

import cn.hutool.core.collection.CollectionUtil;
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.extension.plugins.pagination.Page;
import com.google.common.collect.Lists;
import jnpf.base.Pagination;
import jnpf.base.UserInfo;
import jnpf.base.service.SuperServiceImpl;
import jnpf.base.service.SysconfigService;
import jnpf.constant.CodeConst;
import jnpf.constant.DataInterfaceVarConst;
import jnpf.constant.PermissionConst;
import jnpf.emnus.SysParamEnum;
import jnpf.model.BaseSystemInfo;
import jnpf.permission.entity.*;
import jnpf.permission.mapper.PositionMapper;
import jnpf.permission.model.permission.PermissionModel;
import jnpf.permission.model.position.PaginationPosition;
import jnpf.permission.model.position.PosConModel;
import jnpf.permission.model.position.PositionListVO;
import jnpf.permission.model.position.PositionPagination;
import jnpf.permission.service.*;
import jnpf.util.*;
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 PositionServiceImpl extends SuperServiceImpl<PositionMapper, PositionEntity> implements PositionService {

    @Autowired
    private AuthorizeService authorizeService;
    @Autowired
    private UserRelationService userRelationService;
    @Autowired
    private RoleRelationService roleRelationService;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private CacheKeyUtil cacheKeyUtil;
    @Autowired
    private OrganizeService organizeService;
    @Autowired
    private OrganizeAdministratorService organizeAdministratorService;
    @Autowired
    private CodeNumService codeNumService;
    @Autowired
    private SysconfigService sysconfigApi;

    @Override
    public List<PositionEntity> getList(PositionPagination pagination) {
        QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
        boolean flag = false;
        if (StringUtil.isNotEmpty(pagination.getKeyword())) {
            flag = true;
            queryWrapper.lambda().and(
                    t -> t.like(PositionEntity::getFullName, pagination.getKeyword())
                            .or().like(PositionEntity::getEnCode, pagination.getKeyword())
            );
        }
        if (StringUtil.isNotEmpty(pagination.getOrganizeId())) {
            queryWrapper.lambda().eq(PositionEntity::getOrganizeId, pagination.getOrganizeId());
        }
        if (pagination.getEnabledMark() != null) {
            queryWrapper.lambda().eq(PositionEntity::getEnabledMark, pagination.getEnabledMark());
        }
        if (pagination.getDefaultMark() != null) {
            if (Objects.equals(pagination.getDefaultMark(), 0)) {
                queryWrapper.lambda().and(t -> t.eq(PositionEntity::getDefaultMark, 0)
                        .or().isNull(PositionEntity::getDefaultMark));
            } else {
                queryWrapper.lambda().eq(PositionEntity::getDefaultMark, pagination.getDefaultMark());
            }
        }
        //排序
        queryWrapper.lambda().orderByAsc(PositionEntity::getSortCode).orderByAsc(PositionEntity::getCreatorTime);
        if (flag) {
            queryWrapper.lambda().orderByDesc(PositionEntity::getLastModifyTime);
        }

        if (Objects.equals(pagination.getDataType(), 1)) {
            List<PositionEntity> list = list(queryWrapper);
            PositionEntity positionEntity = list.stream().filter(t -> Objects.equals(t.getDefaultMark(), 1)).findFirst().orElse(null);
            if (positionEntity != null) {
                list.remove(positionEntity);
                list.add(0, positionEntity);
            }
            return list;
        }

        long count = this.count(queryWrapper);
        Page<PositionEntity> page = new Page<>(pagination.getCurrentPage(), pagination.getPageSize(), count, false);
        page.setOptimizeCountSql(false);
        IPage<PositionEntity> iPage = this.page(page, queryWrapper);
        return pagination.setData(iPage.getRecords(), page.getTotal());
    }


    @Override
    public boolean isExistByFullName(PositionEntity entity, boolean isFilter) {
        QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
        if (entity != null) {
            queryWrapper.lambda().eq(PositionEntity::getFullName, entity.getFullName());
        }
        //是否需要过滤
        if (isFilter) {
            queryWrapper.lambda().ne(PositionEntity::getId, entity.getId());
        }
        List<PositionEntity> entityList = this.list(queryWrapper);
        for (PositionEntity positionEntity : entityList) {
            //如果组织id相同则代表已存在
            if (entity != null && entity.getOrganizeId().equals(positionEntity.getOrganizeId())) {
                return true;
            }
        }
        return false;
    }

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

    @Override
    public void create(PositionEntity entity) {
        if (StringUtil.isEmpty(entity.getId())) {
            entity.setId(RandomUtil.uuId());
        }
        if (StringUtil.isEmpty(entity.getEnCode())) {
            entity.setEnCode(codeNumService.getCodeFunction(() -> codeNumService.getCodeOnce(CodeConst.GW), code -> this.isExistByEnCode(code, null)));
        }
        setTreeAtt(entity);
        entity.setEnabledMark(1);
        if (entity.getSortCode() == null) {
            entity.setSortCode(0l);
        }
        this.save(entity);
        redisUtil.remove(cacheKeyUtil.getPositionList());
        redisUtil.remove(TenantHolder.getDatasourceId() + CacheKeyUtil.SYS_POS);
    }

    @Override
    public boolean update(String id, PositionEntity entity) {
        entity.setId(id);
        if (StringUtil.isEmpty(entity.getEnCode())) {
            entity.setEnCode(codeNumService.getCodeFunction(() -> codeNumService.getCodeOnce(CodeConst.GW), code -> this.isExistByEnCode(code, id)));
        }
        setTreeAtt(entity);
        entity.setLastModifyTime(DateUtil.getNowDate());
        entity.setLastModifyUserId(UserProvider.getUser().getUserId());
        entity.setEnabledMark(1);
        redisUtil.remove(cacheKeyUtil.getPositionList());
        redisUtil.remove(TenantHolder.getDatasourceId() + CacheKeyUtil.SYS_POS);
        return this.updateById(entity);
    }

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

    @Override
    @DSTransactional
    public void delete(PositionEntity entity) {
        this.removeById(entity.getId());
        QueryWrapper<UserRelationEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(UserRelationEntity::getObjectId, entity.getId());
        userRelationService.remove(queryWrapper);
        QueryWrapper<AuthorizeEntity> wrapper = new QueryWrapper<>();
        wrapper.lambda().eq(AuthorizeEntity::getObjectId, entity.getId());
        authorizeService.remove(wrapper);
        QueryWrapper<RoleRelationEntity> roleWrapper = new QueryWrapper<>();
        roleWrapper.lambda().eq(RoleRelationEntity::getObjectId, entity.getId());
        roleRelationService.remove(roleWrapper);
        redisUtil.remove(cacheKeyUtil.getPositionList());
        redisUtil.remove(TenantHolder.getDatasourceId() + CacheKeyUtil.SYS_POS);
    }

    @Override
    public void deleteByOrgId(String orgId) {
        QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().select(PositionEntity::getId);
        queryWrapper.lambda().eq(PositionEntity::getOrganizeId, orgId);
        this.removeByIds(list(queryWrapper));
    }

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

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

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

    @Override
    public List<PositionEntity> getByParentId(String parentId) {
        if (StringUtil.isEmpty(parentId)) return null;
        QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(PositionEntity::getParentId, parentId);
        return this.list(queryWrapper);
    }

    /**
     * 设置树形属性
     *
     * @param entity
     */
    private void setTreeAtt(PositionEntity entity) {
        String treeIds = entity.getId();
        if (StringUtil.isNotEmpty(entity.getParentId())) {
            StringJoiner postJ = new StringJoiner(",");
            List<PositionEntity> parentList = getParentList(entity.getParentId());
            parentList.stream().forEach(t -> postJ.add(t.getId()));
            postJ.add(entity.getId());
            treeIds = postJ.toString();
        }
        entity.setPositionIdTree(treeIds);
    }

    @Override
    public List<PositionEntity> getListByOrgIds(List<String> orgIds) {
        if (CollectionUtil.isEmpty(orgIds)) {
            return Collections.EMPTY_LIST;
        }
        QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().in(PositionEntity::getOrganizeId, orgIds);
        queryWrapper.lambda().eq(PositionEntity::getEnabledMark, 1);
        return list(queryWrapper);
    }

    @Override
    public List<PositionEntity> getListByOrgIdOneLevel(List<String> orgIds) {
        if (CollectionUtil.isEmpty(orgIds)) {
            return Collections.EMPTY_LIST;
        }
        QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().in(PositionEntity::getOrganizeId, orgIds);
        queryWrapper.lambda().and(t -> t.isNull(PositionEntity::getParentId).or().eq(PositionEntity::getParentId, "-1"));
        queryWrapper.lambda().eq(PositionEntity::getEnabledMark, 1);
        return list(queryWrapper);
    }

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

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

    @Override
    public List<PositionEntity> getPosList(List<String> idList) {
        if (!idList.isEmpty()) {
            QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().in(PositionEntity::getId, idList)
                    .select(PositionEntity::getId, PositionEntity::getFullName, PositionEntity::getEnabledMark);
            return this.list(queryWrapper);
        }
        return new ArrayList<>();
    }

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

    @Override
    public List<PositionEntity> getListByIds(Pagination pagination, List<String> idList) {
        if (CollectionUtil.isEmpty(idList)) return Collections.EMPTY_LIST;
        QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().select(PositionEntity::getId, PositionEntity::getOrganizeId, PositionEntity::getFullName,
                PositionEntity::getEnCode, PositionEntity::getDescription);
        List<List<String>> lists = Lists.partition(idList, 1000);
        for (List<String> list : lists) {
            queryWrapper.lambda().in(PositionEntity::getId, list);
        }
        if (StringUtil.isNotEmpty(pagination.getKeyword())) {
            queryWrapper.lambda().and(
                    t -> t.like(PositionEntity::getFullName, pagination.getKeyword())
                            .or().like(PositionEntity::getEnCode, pagination.getKeyword())
            );
        }
        Page<PositionEntity> page = new Page<>(pagination.getCurrentPage(), pagination.getPageSize());
        IPage<PositionEntity> iPage = this.page(page, queryWrapper);
        return pagination.setData(iPage.getRecords(), page.getTotal());
    }

    @Override
    public Map<String, String> getPosMap() {
        QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().select(PositionEntity::getId, PositionEntity::getFullName);
        return this.list(queryWrapper).stream().collect(Collectors.toMap(PositionEntity::getId, PositionEntity::getFullName, (p1, p2) -> p1));
    }

    @Override
    public Map<String, String> getPosFullNameMap() {
        if (redisUtil.exists(cacheKeyUtil.getPositionList())) {
            return new HashMap<>(redisUtil.getMap(cacheKeyUtil.getPositionList()));
        } else {
            QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().select(PositionEntity::getId, PositionEntity::getFullName, PositionEntity::getOrganizeId);
            List<PositionEntity> list = this.list(queryWrapper);
            Map<String, String> infoMap = new HashMap<>(list.size());
            Map<String, Object> allOrgsTreeName = organizeService.getAllOrgsTreeName();
            for (PositionEntity t : list) {
                String fullName = t.getFullName();
                if (Objects.nonNull(allOrgsTreeName.get(t.getOrganizeId()))) {
                    fullName = allOrgsTreeName.get(t.getOrganizeId()) + "/" + t.getFullName();
                }
                infoMap.put(t.getId(), fullName);
            }
            redisUtil.insert(cacheKeyUtil.getPositionList(), infoMap);
            return infoMap;
        }
    }


    @Override
    public Map<String, Object> getPosEncodeAndName() {
        return getPosEncodeAndName(false);
    }

    @Override
    public Map<String, Object> getPosEncodeAndName(boolean enabledMark) {
        QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
        if (enabledMark) {
            queryWrapper.lambda().eq(PositionEntity::getEnabledMark, 1);
        }
        queryWrapper.lambda().select(PositionEntity::getId, PositionEntity::getFullName, PositionEntity::getEnCode);
        return this.list(queryWrapper).stream().collect(Collectors.toMap(p -> p.getFullName() + "/" + p.getEnCode(), PositionEntity::getId, (p1, p2) -> p1));
    }


    @Override
    public List<PositionEntity> getList(PaginationPosition paginationPosition) {
        // 需要查询哪些组织
        List<String> orgIds = new ArrayList<>();
        // 所有有权限的组织
        Set<String> orgId = new HashSet<>(16);
        if (!UserProvider.getUser().getIsAdministrator()) {
            // 通过权限转树
            List<OrganizeAdministratorEntity> listss = organizeAdministratorService.getOrganizeAdministratorEntity(UserProvider.getUser().getUserId());
            // 判断自己是哪些组织的管理员
            listss.forEach(t -> {
                if (t != null) {
                    if (t.getThisLayerSelect() != null && t.getThisLayerSelect() == 1) {
                        orgId.add(t.getOrganizeId());
                    }
                    if (t.getSubLayerSelect() != null && t.getSubLayerSelect() == 1) {
                        List<String> underOrganizations = organizeService.getUnderOrganizations(t.getOrganizeId(), false);
                        orgId.addAll(underOrganizations);
                    }
                }
            });
        } else {
            orgId.addAll(organizeService.getOrgMapsAll(OrganizeEntity::getId).keySet());
        }
        if (orgId.isEmpty()) {
            return new ArrayList<>();
        }
        QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
        if (StringUtil.isNotEmpty(paginationPosition.getKeyword())) {
            queryWrapper.lambda().and(
                    t -> t.like(PositionEntity::getFullName, paginationPosition.getKeyword())
                            .or().like(PositionEntity::getEnCode, paginationPosition.getKeyword())
            );
        }
        if (paginationPosition.getEnabledMark() != null) {
            queryWrapper.lambda().eq(PositionEntity::getEnabledMark, paginationPosition.getEnabledMark());
        }
        if (StringUtil.isNotEmpty(paginationPosition.getOrganizeId())) {
            List<String> underOrganizations = organizeService.getUnderOrganizations(paginationPosition.getOrganizeId(), false);
            // 判断哪些组织时有权限的
            List<String> collect = underOrganizations.stream().filter(orgId::contains).collect(Collectors.toList());
            orgIds.add(paginationPosition.getOrganizeId());
            orgIds.addAll(collect);
            orgIds.add(paginationPosition.getOrganizeId());
            List<List<String>> lists = Lists.partition(new ArrayList<>(orgIds), 1000);
            queryWrapper.lambda().and(t -> {
                for (List<String> id : lists) {
                    t.in(PositionEntity::getOrganizeId, id).or();
                }
            });
        } else {
            List<List<String>> lists = Lists.partition(new ArrayList<>(orgId), 1000);
            queryWrapper.lambda().and(t -> {
                for (List<String> id : lists) {
                    t.in(PositionEntity::getOrganizeId, id).or();
                }
            });
        }
        long count = this.count(queryWrapper);
        queryWrapper.lambda().select(PositionEntity::getId, PositionEntity::getEnCode, PositionEntity::getCreatorTime,
                PositionEntity::getOrganizeId, PositionEntity::getEnabledMark, PositionEntity::getFullName,
                PositionEntity::getSortCode, PositionEntity::getType, PositionEntity::getDescription);
        queryWrapper.lambda().orderByAsc(PositionEntity::getSortCode).orderByAsc(PositionEntity::getCreatorTime);

        if (Objects.equals(paginationPosition.getDataType(), 1)) {
            return list(queryWrapper);
        }
        Page<PositionEntity> page = new Page<>(paginationPosition.getCurrentPage(), paginationPosition.getPageSize(), count, false);
        page.setOptimizeCountSql(false);
        IPage<PositionEntity> iPage = this.page(page, queryWrapper);
        return paginationPosition.setData(iPage.getRecords(), page.getTotal());
    }

    @Override
    public List<PositionEntity> getListByUserId(String userId) {
        QueryWrapper<PositionEntity> query = new QueryWrapper<>();
        List<String> ids = new ArrayList<>();
        userRelationService.getListByObjectType(userId, PermissionConst.POSITION).forEach(r -> {
            ids.add(r.getObjectId());
        });
        if (!ids.isEmpty()) {
            query.lambda().in(PositionEntity::getId, ids);
            return this.list(query);
        } else {
            return new ArrayList<>();
        }
    }

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

    @Override
    @DSTransactional
    public boolean first(String id) {
        boolean isOk = false;
        //获取要上移的那条数据的信息
        PositionEntity upEntity = this.getById(id);
        Long upSortCode = upEntity.getSortCode() == null ? 0 : upEntity.getSortCode();
        //查询上几条记录
        QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda()
                .lt(PositionEntity::getSortCode, upSortCode)
                .eq(PositionEntity::getOrganizeId, upEntity.getOrganizeId())
                .orderByDesc(PositionEntity::getSortCode);
        List<PositionEntity> downEntity = this.list(queryWrapper);
        if (!downEntity.isEmpty()) {
            //交换两条记录的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;
        //获取要下移的那条数据的信息
        PositionEntity downEntity = this.getById(id);
        Long upSortCode = downEntity.getSortCode() == null ? 0 : downEntity.getSortCode();
        //查询下几条记录
        QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda()
                .gt(PositionEntity::getSortCode, upSortCode)
                .eq(PositionEntity::getOrganizeId, downEntity.getOrganizeId())
                .orderByAsc(PositionEntity::getSortCode);
        List<PositionEntity> upEntity = this.list(queryWrapper);
        if (!upEntity.isEmpty()) {
            //交换两条记录的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 List<PositionEntity> getPositionName(List<String> id, boolean filterEnabledMark) {
        List<PositionEntity> roleList = new ArrayList<>();
        if (!id.isEmpty()) {
            QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().in(PositionEntity::getId, id);
            roleList = this.list(queryWrapper);
        }
        return roleList;
    }

    @Override
    public List<PositionEntity> getPositionName(List<String> id, String keyword) {
        List<PositionEntity> roleList = new ArrayList<>();
        if (!id.isEmpty()) {
            QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().in(PositionEntity::getId, id);
            //关键字（名称、编码）
            if (!StringUtil.isEmpty(keyword)) {
                queryWrapper.lambda().and(
                        t -> t.like(PositionEntity::getFullName, keyword)
                                .or().like(PositionEntity::getEnCode, keyword)
                );
            }
            roleList = this.list(queryWrapper);
        }
        return roleList;
    }

    @Override
    public List<PositionEntity> getListByOrganizeId(List<String> organizeIds, boolean enabledMark) {
        if (organizeIds.isEmpty()) {
            return new ArrayList<>();
        }
        QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().in(PositionEntity::getOrganizeId, organizeIds);
        if (enabledMark) {
            queryWrapper.lambda().eq(PositionEntity::getEnabledMark, 1);
        }
        queryWrapper.lambda().orderByAsc(PositionEntity::getSortCode).orderByAsc(PositionEntity::getCreatorTime);
//        queryWrapper.lambda().select(PositionEntity::getId, PositionEntity::getFullName);
        return this.list(queryWrapper);
    }

    @Override
    public List<PositionEntity> getListByOrgIdAndUserId(String organizeId, String userId) {
        // 用户绑定的所有岗位
        List<String> positionIds = userRelationService.getListByUserIdAndObjType(userId, PermissionConst.POSITION).stream()
                .map(UserRelationEntity::getObjectId).collect(Collectors.toList());
        if (!positionIds.isEmpty()) {
            List<PositionEntity> positionEntities = this.listByIds(positionIds);
            return positionEntities.stream().filter(p -> p.getOrganizeId().equals(organizeId)).collect(Collectors.toList());
        } else {
            return new ArrayList<>();
        }
    }

    @Override
    public List<PositionEntity> getListByFullName(String fullName, String enCode) {
        QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(PositionEntity::getFullName, fullName).eq(PositionEntity::getEnCode, enCode);
        return this.list(queryWrapper);
    }

    @Override
    public List<PermissionModel> getListByOrganizeIds(List<String> organizeIds, boolean needCode, boolean enabledMark) {
        List<PermissionModel> permissionList = new LinkedList<>();
        for (String organizeId : organizeIds) {
            OrganizeEntity info = organizeService.getInfo(organizeId);
            if (info != null) {
                PermissionModel parentModel = new PermissionModel();
                List<PositionEntity> list = this.getListByOrganizeId(Collections.singletonList(organizeId), enabledMark);
                list.forEach(t -> {
                    if (needCode) {
                        t.setFullName(t.getFullName() + "/" + t.getEnCode());
                    }
                });
                List<PermissionModel> positionModels = JsonUtil.getJsonToList(list, PermissionModel.class);
                parentModel.setChildren(positionModels);
                parentModel.setHasChildren(true);
                parentModel.setFullName(info.getFullName());
                parentModel.setId(info.getId());
                permissionList.add(parentModel);
            }
        }
        return permissionList;
    }


    //todo
    @Override
    public List<PositionListVO> 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]);
        }
        Map<String, Object> allOrgsTreeName = organizeService.getAllOrgsTreeName();

        List<PositionEntity> listByIds = this.getListByIds(idList);
        List<PositionListVO> 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() : "";
            PositionEntity positionEntity = listByIds.stream().filter(t -> t.getId().equals(id)).findFirst().orElse(null);
            if (positionEntity != null) {
                PositionListVO vo = JsonUtil.getJsonToBean(positionEntity, PositionListVO.class);
                vo.setId(idStr);
                vo.setOrgNameTree(allOrgsTreeName.get(positionEntity.getOrganizeId()) + "/" + positionEntity.getFullName() + suffix);
                listVo.add(vo);
            }
        }
        return listVo;
    }

    @Override
    public List<PositionEntity> positionCondition(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> currentPosIds = userInfo.getPositionIds();

        for (String idStr : idStrList) {
            if (DataInterfaceVarConst.POSITIONID.equals(idStr)) {
                idList.addAll(currentPosIds);
            } else if (DataInterfaceVarConst.POSITIONANDSUB.equals(idStr)) {
                idList.addAll(currentPosIds);
                parenList.addAll(currentPosIds);
            } else if (DataInterfaceVarConst.POSITIONANDPROGENY.equals(idStr)) {
                ancestorsList.addAll(currentPosIds);
            } else {
                String[] split = idStr.split("--");
                idList.add(split[0]);
                if (split.length > 1) {
                    if (SysParamEnum.SUBPOS.getCode().equalsIgnoreCase(split[1])) {
                        parenList.add(split[0]);
                    }
                    if (SysParamEnum.PROGENYPOS.getCode().equalsIgnoreCase(split[1])) {
                        ancestorsList.add(split[0]);
                    }
                }
            }
        }
        if (CollectionUtil.isEmpty(idList) && CollectionUtil.isEmpty(parenList) && CollectionUtil.isEmpty(ancestorsList)) {
            return Collections.EMPTY_LIST;
        }
        QueryWrapper<PositionEntity> query = new QueryWrapper<>();

        query.lambda().eq(PositionEntity::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(PositionEntity::getId, thisList).or();
                }
            }
            if (CollectionUtil.isNotEmpty(parenList)) {
                List<List<String>> lists = Lists.partition(parenList, 1000);
                for (List<String> thisList : lists) {
                    t.in(PositionEntity::getParentId, thisList).or();
                }
            }
            if (CollectionUtil.isNotEmpty(ancestorsList)) {
                for (String thisId : ancestorsList) {
                    t.like(PositionEntity::getPositionIdTree, thisId).or();
                }
            }
        });
        query.lambda().orderByAsc(PositionEntity::getSortCode).orderByAsc(PositionEntity::getCreatorTime);
        return this.list(query);
    }

    @Override
    public List<PositionEntity> getListByDutyUser(String userId) {
        LambdaQueryWrapper<PositionEntity> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(PositionEntity::getDutyUser, userId);
        wrapper.eq(PositionEntity::getEnabledMark, "1");
        return this.list(wrapper);
    }

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

    @Override
    public void linkUpdate(String id, PosConModel posConModel) {
        //联动修改互斥对象
        List<String> muEList = new ArrayList<>();
        if (posConModel.getMutualExclusionFlag()) {
            muEList.addAll(posConModel.getMutualExclusion());
        }
        //muEList 互斥对象。除了这个列表外其他角色里不能包含该互斥
        QueryWrapper<PositionEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().like(PositionEntity::getConditionJson, id);
        if (CollectionUtil.isNotEmpty(muEList)) {
            queryWrapper.lambda().or().in(PositionEntity::getId, muEList);
        }

        List<PositionEntity> list = this.list(queryWrapper);
        for (PositionEntity item : list) {
            if (muEList.contains(item.getId())) {
                //添加
                item.setIsCondition(1);
                PosConModel psModel = StringUtil.isEmpty(item.getConditionJson()) ? new PosConModel() : JsonUtil.getJsonToBean(item.getConditionJson(), PosConModel.class);
                List<Integer> constraintType = psModel.getConstraintType() == null ? new ArrayList<>() : psModel.getConstraintType();
                if (!constraintType.contains(0)) {
                    constraintType.add(0);
                    psModel.setConstraintType(constraintType);
                }
                List<String> mutualExclusion = psModel.getMutualExclusion() == null ? new ArrayList<>() : psModel.getMutualExclusion();
                if (!mutualExclusion.contains(id)) {
                    mutualExclusion.add(id);
                    psModel.setMutualExclusion(mutualExclusion);
                    item.setConditionJson(JsonUtil.getObjectToString(psModel));
                }
                this.update(item.getId(), item);
            } else {
                //移除
                if (Objects.equals(item.getIsCondition(), 1)) {
                    PosConModel psModel = JsonUtil.getJsonToBean(item.getConditionJson(), PosConModel.class);
                    psModel.init();
                    if (psModel.getMutualExclusionFlag()) {
                        List<String> mutualExclusion = psModel.getMutualExclusion();
                        if (mutualExclusion.contains(id)) {
                            mutualExclusion.remove(id);
                            if (mutualExclusion.isEmpty()) {
                                List<Integer> constraintType = psModel.getConstraintType();
                                constraintType.remove(Integer.valueOf(0));
                                psModel.setConstraintType(constraintType);
                                if (constraintType.isEmpty()) {
                                    item.setIsCondition(0);
                                }
                            }
                            item.setConditionJson(JsonUtil.getObjectToString(psModel));
                            this.update(item.getId(), item);
                        }
                    }
                }
            }
        }
    }

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

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