package com.product.org.admin.service;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.NumberUtil;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.product.admin.service.OrganizationCacheService;
import com.product.common.lang.StringUtils;
import com.product.core.cache.DataPoolCacheImpl;
import com.product.core.cache.util.RedisUtil;
import com.product.core.entity.DataTableEntity;
import com.product.core.entity.FieldSetEntity;
import com.product.core.exception.BaseException;
import com.product.core.spring.context.SpringMVCContextHolder;
import com.product.module.sys.entity.SystemUser;
import com.product.org.admin.config.CmnConst;
import com.product.org.admin.entity.OrganizationEntity;
import com.product.org.admin.service.idel.IOrganizationService;
import com.product.util.BaseUtil;
import org.springframework.stereotype.Service;

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


/**
 * @Author cheng
 * @Date 2022/3/29 14:02
 * @Desc 组织机构
 */
@Service
public class OrganizationServiceV2 extends OrganizationCacheService implements IOrganizationService {


    public void cacheOrganization() {
        this.cacheOrganization(null);
    }


    public void cachePost() {
        this.cachePost(null);
    }


    public void cacheStaff() {
        this.cacheStaff(null);
    }

    /**
     * 分解多种类型的值
     *
     * @param values 多种类型的值 多个逗号分隔 列： [xxx~uuid],(xxx~user_id),{xxx_post_uuid}
     * @return 返回二维数组
     * 第一个维度：固定长度 4 ，下标0 代表公司 下标1 代表部门 下标 2 代表岗位 下标 3 代表 用户 ，可能为空
     * 第二个维度： 长度未知，返回一维数组中对应含义的 值,可能为空
     * @auth cheng
     * @date 2022年4月20日18:21:09
     */
    public String[][] decomposesMultipleTypeValues(String values) {
        String[][] typeValues = new String[3][];
        if (StringUtils.isEmpty(values)) {
            return typeValues;
        }
        String[] value = values.split(",");
        for (String val : value) {
            if (val.length() <= 2) {
                continue;
            }

            String actualValue = val.substring(1, val.length() - 1);
            int index = -1;
            if (val.startsWith("[") && val.endsWith("]")) {
                //机构
                Map<String, Object> orgCacheByUuid = this.getOrgCacheByUuid(actualValue);
                if (orgCacheByUuid != null) {
                    Object org_level_type = orgCacheByUuid.get(CmnConst.ORG_LEVEL_TYPE);
                    if (org_level_type != null) {
                        index = NumberUtil.parseInt(org_level_type.toString());
                    }
                }
            } else if (val.startsWith("{") && val.endsWith("}")) {
                //岗位
                index = 2;
            } else if (val.startsWith("(") && val.endsWith(")")) {
                //人员
                index = 3;
            } else {
                continue;
            }
            if (index == -1) {
                continue;
            }
            if (typeValues[index] == null) {
                typeValues[index] = new String[1];
            } else {
                Arrays.copyOf(typeValues[index], typeValues[index].length + 1);
            }
            typeValues[index][typeValues[index].length - 1] = actualValue;
        }
        return typeValues;
    }

    public static void main(String[] args) {
        String[] a = new String[1];
        System.out.println(a.length);
    }

    /**
     * 获取所有的人员
     *
     * @param organizationArr 组织架构信息，数据来源为decomposesMultipleTypeValues方法的返回
     * @return
     */
    public Set<String> getAllUsers(String[][] organizationArr) {
        Set<String> userSet = Sets.newHashSet();

        // 单位
        DataTableEntity dte;
        FieldSetEntity fse;
        String[] unitArr = organizationArr[0];
        if (unitArr != null) {
            StringBuilder sql = new StringBuilder(128);
            sql.append("select user_id from product_sys_staffs s");
            sql.append("\ninner join product_sys_org_levels o on s.tricode like concat(o.org_level_code,'%')");
            sql.append("\nwhere ").append(BaseUtil.buildQuestionMarkFilter("o.uuid", unitArr.length, true));
            dte = getBaseDao().listTable(sql.toString(), unitArr);
            for (int i = 0; i < dte.getRows(); i++) {
                fse = dte.getFieldSetEntity(i);
                userSet.add(fse.getString("user_id"));
            }
        }

        // 岗位
        String[] postArr = organizationArr[1];
        if (postArr != null) {
            for (String uuid : postArr) {
                dte = getUserDataByPost(uuid);
                for (int i = 0; i < dte.getRows(); i++) {
                    fse = dte.getFieldSetEntity(i);
                    userSet.add(fse.getString("user_id"));
                }
            }
        }

        // 人员
        String[] userArr = organizationArr[2];
        if (userArr != null) {
            userSet.addAll(Arrays.asList(userArr));
        }

        return userSet;
    }

    /**
     * 根据输入的值 搜索可以选择的类型
     *
     * @param fse
     * @param allowDept
     * @param allowPost
     * @param userIds
     * @return
     */
    protected Object getSearchValueResult(FieldSetEntity fse, String[] allowDept, String[] allowPost, String[] userIds) {
        String searchValue = fse.getString("~search_value~");
        String allowType = fse.getString("~allow_type~");
        if (StringUtils.isEmpty(searchValue) || StringUtils.isEmpty(allowType)) {
            return null;
        }
        String[] allowTypes = allowType.split(",");
        StringBuilder sql = new StringBuilder();
        List<Object> params = new ArrayList<>();
        for (String type : allowTypes) {
            if (sql.length() > 0) {
                sql.append("\n union all ");
            }
            if ("1".equals(type) || "2".equals(type)) {
                sql.append("\n select uuid `value`,org_level_name label,org_level_type+1 type from product_sys_org_levels where  ");
                sql.append("\n org_level_status=0 and org_level_name like concat('%',?,'%') ");
                sql.append("\n and org_level_type=? ");
                if ("2".equals(type) && allowDept != null && allowDept.length > 0) {
                    sql.append(" and ").append(BaseUtil.buildQuestionMarkFilter("uuid", allowDept, true));
                }
                //搜索岗位名称
                params.add(searchValue);
                params.add(Integer.valueOf(type) - 1);
            } else if ("3".equals(type)) {
                sql.append("\n select uuid `value`,job_post_name label,3 type from product_sys_job_posts where job_post_name like concat('%',?,'%') and is_used=1 ");
                //搜索岗位名称
                params.add(searchValue);
                if (!ArrayUtil.isAllEmpty(allowDept, allowDept)) {
                    sql.append(" and ( ");
                    if (!ArrayUtil.isEmpty(allowPost)) {
                        sql.append("  ").append(BaseUtil.buildQuestionMarkFilter("uuid", allowPost, true));
                    }
                    if (!ArrayUtil.isEmpty(allowDept)) {
                        sql.append(ArrayUtil.isEmpty(allowPost) ? "" : " or ").append(BaseUtil.buildQuestionMarkFilter("dept_uuid", allowDept, true));
                    }
                    sql.append(" ) ");
                }

            } else if ("4".equals(type)) {
                sql.append("\n select staff.user_id `value`,show_name label,4 type from product_sys_staffs staff  ");
                sql.append("\n join product_sys_users users on users.`status`=1 and users.user_id=staff.user_id and  ");
                sql.append("\n  (staff_code like concat('%',?,'%') or show_name like concat('%',?,'%')) ");
                if (!ArrayUtil.isAllEmpty(userIds, allowDept, allowPost)) {
                    sql.append(" and ( ");
                    boolean or = false;
                    if (userIds != null && userIds.length > 0) {
                        sql.append("  ").append(BaseUtil.buildQuestionMarkFilter("users.user_id", userIds, true));
                        or = true;
                    }
                    if (!ArrayUtil.isEmpty(allowDept)) {
                        sql.append(or ? " or " : "").append(BaseUtil.buildQuestionMarkFilter("dept_uuid", allowDept, true));
                        or = true;
                    }
                    if (!ArrayUtil.isEmpty(allowPost)) {
                        sql.append(or ? " or " : "").append(BaseUtil.buildQuestionMarkFilter("job_post_uuid", allowPost, true));
                    }
                    sql.append(" ) ");
                }
                //搜索编码和用户名称
                params.add(searchValue);
                params.add(searchValue);
            }
        }
        if (sql.length() == 0) {
            return null;
        }
        DataTableEntity dt = getBaseDao().listTable(sql.toString(), params.toArray());
        return dt;
    }

    /**
     * 获取选中值的label
     *
     * @param value
     * @return
     * @throws BaseException
     */
    protected Object getSelectedValueLabel(String value) throws BaseException {
        String[] values = value.split(",");
        Map<String, String> result = new HashMap<>();
        if (values != null && values.length > 0) {
            for (String val : values) {
                if (val.length() < 2) {
                    continue;
                }
                //实际值
                String actualValue = val.substring(1, val.length() - 1);
                String label = null;
                String bracket = val.substring(0, 1) + "*" + val.substring(val.length() - 1);
                if (StringUtils.equals("[*]", bracket)) {
                    //公司  | 部门
                    Map<String, Object> o = (HashMap<String, Object>) RedisUtil.get(this.ORG_UUID_CACHE_KEY + actualValue);
                    if (o != null && !o.isEmpty()) {
                        label = (String) o.get(CmnConst.ORG_LEVEL_NAME);
                    }
                } else if (StringUtils.equals("{*}", bracket)) {
                    //岗位
                    Object o = RedisUtil.get(this.POST_UUID_CACHE_KEY + actualValue);
                    if (o != null) {
                        Object[] o1 = (Object[]) o;
                        if (o1 != null && o1.length == 2) {
                            label = (String) o1[0];
                        }
                    }
                } else if (StringUtils.equals("(*)", bracket)) {
                    //人员
                    FieldSetEntity user = BaseUtil.getSingleInfoByCache("用户缓存", new String[]{actualValue});
                    if (!FieldSetEntity.isEmpty(user) && !user.getBoolean("isManager")) {
                        label = user.getString(CmnConst.USER_NAME);
                    }
                }
                if (!StringUtils.isEmpty(label)) {
                    result.put(val, label);
                }
            }
        }
        return result;
    }


    private Set<String>[] getOrganizationFilter(String[] dept_uuid, String[] post_uuid, String[] userIds, int type) {
        Set<String> allowDeptCode = null;
        Set<String> allowPostUuid = null;
        Set<String> retainOrgCode = dept_uuid != null ? Sets.newHashSet(Arrays.asList(dept_uuid)) : null;
        Set<String> retainDPost = post_uuid != null ? Sets.newHashSet(Arrays.asList(post_uuid)) : null;

        if (type >= 4 && userIds != null && userIds.length > 0) {
            for (String userId : userIds) {
                FieldSetEntity user = BaseUtil.getSingleInfoByCache("用户缓存", new String[]{userId});
                if (!FieldSetEntity.isEmpty(user)) {
                    String dept = user.getString(CmnConst.DEPT_UUID);
                    if (retainOrgCode == null) {
                        retainOrgCode = Sets.newHashSet();
                    }
                    retainOrgCode.add(dept);
//                    if (retainDPost == null) {
//                        retainDPost = Sets.newHashSet();
//                    }
//                    retainDPost.add(user.getString("job_post_uuid"));
                } else {
                    continue;
                }
                if (type != 3 && type != 4) {
                    continue;
                }
                String post = user.getString("job_post_uuid");
                if (!StringUtils.isEmpty(post)) {
                    if (retainDPost == null) {
                        retainDPost = Sets.newHashSet();
                    }
                    retainDPost.add(post);
                }
            }
        }

        if (retainDPost != null && retainDPost.size() > 0) {
            for (String post : retainDPost) {
                if (StringUtils.isEmpty(post)) {
                    continue;
                }
                Object o = RedisUtil.get(this.POST_UUID_CACHE_KEY + post);
                if (o != null) {
                    Object[] o1 = (Object[]) o;
                    if (o1 != null && o1.length == 2) {
                        if (allowPostUuid == null) {
                            allowPostUuid = Sets.newHashSet();
                        }
                        allowPostUuid.add(post);
                        String value = (String) o1[1];
                        if (retainOrgCode == null) {
                            retainOrgCode = Sets.newHashSet();
                        }
                        if (!retainOrgCode.contains(value)) {
                            retainOrgCode.add(value);
                        }
                    }
                }
            }
        }

        if (retainOrgCode != null && retainOrgCode.size() > 0) {
            for (String dept : retainOrgCode) {
                if (StringUtils.isEmpty(dept)) {
                    continue;
                }
                Map<String, Object> o = (HashMap<String, Object>) RedisUtil.get(this.ORG_UUID_CACHE_KEY + dept);
                if (o != null && !o.isEmpty()) {
                    String org_level_code = (String) o.get(CmnConst.ORG_LEVEL_CODE);
                    if (!StringUtils.isEmpty(org_level_code)) {
                        String[] codes = org_level_code.split("-");
                        for (int i = codes.length - 1; i >= 0; i--) {
                            String code = "";
                            for (int j = 0; j <= i; j++) {
                                if (code.length() > 0) {
                                    code += '-';
                                }
                                code += codes[j];
                            }
                            if (code.length() > 0) {
                                if (allowDeptCode == null) {
                                    allowDeptCode = new HashSet<>();
                                }
                                allowDeptCode.add(code);
                            }
                        }
                    }
                }
            }
        }

        return new Set[]{allowDeptCode, allowPostUuid};
    }

    @Override
    public Object getOrganization(FieldSetEntity fse) throws BaseException {
        if (!StringUtils.isEmpty(fse.getString("~values~"))) {
            return getSelectedValueLabel(fse.getString("~values~"));
        }
        // 前端点击的类型 参考 组织机构类型 如果为空  0 = 客户下的公司（顶级） -1 返回所有
        String current_type = BaseUtil.ifNull(fse.getString("current_type"), "-1");
        //组织机构类型 1-公司，2-公司 - 部门，3-公司 - 部门 - 岗位，4-公司 - 部门 - 岗位 - 人员，5-公司 - 部门 - 人员
        String organization_type = fse.getString("organization_type");
        String[] post_uuids = null;
        if (!StringUtils.isEmpty(fse.getString("post_uuids"))) {
            post_uuids = fse.getString("post_uuids").split(",");
        }
        String[] dept_uuids = null;
        if (!StringUtils.isEmpty(fse.getString("dept_uuids"))) {
            dept_uuids = fse.getString("dept_uuids").split(",");
        }
        String[] user_ids = null;
        if (!StringUtils.isEmpty(fse.getString("user_ids"))) {
            user_ids = fse.getString("user_ids").split(",");
        }
        //当搜索值不为空时
        if (!StringUtils.isEmpty(fse.getString("~search_value~"))) {
            return getSearchValueResult(fse, dept_uuids, post_uuids, user_ids);
        }

        SystemUser currentUser = SpringMVCContextHolder.getCurrentUser();
        //用户类型 0 = 普通用户 1 = 超级管理员 2 单位管理员
        int userType = currentUser.getUserType();
        //所在客户
        String clientUid = currentUser.getClientUuid();

        List<FieldSetEntity> orgCache = getOrgCache(clientUid);

        if (orgCache == null) {
            return null;
        }
        FieldSetEntity topCompanyInfo = orgCache.get(0);
        topCompanyInfo.setValue(CmnConst.VALUE, topCompanyInfo.getString(CmnConst.UUID));
        OrganizationService organizationService = new OrganizationService(topCompanyInfo, organization_type, post_uuids, dept_uuids, user_ids, userType, clientUid, currentUser, current_type);
        return organizationService.getOrganizationData();
    }

    class OrganizationService {
        private FieldSetEntity topCompanyInfo;

        private String[] post_uuids;

        private String[] dept_uuids;

        private String[] user_ids;

        private int userType;

        private String currentType;

        private String organizationType;

        private String clientUid;

        private SystemUser currentUser;

        public OrganizationService(FieldSetEntity topCompanyInfo, String organizationType, String[] post_uuids, String[] dept_uuids, String[] user_ids, int userType, String clientUid, SystemUser currentUser, String currentType) {
            this.topCompanyInfo = topCompanyInfo;
            this.post_uuids = post_uuids;
            this.dept_uuids = dept_uuids;
            this.user_ids = user_ids;
            this.userType = userType;
            this.clientUid = clientUid;
            this.currentUser = currentUser;
            this.currentType = currentType;
            this.organizationType = organizationType;
        }

        public List<OrganizationEntity> getOrganizationData() {
            if (topCompanyInfo == null) {
                return null;
            }
            List<FieldSetEntity> orgData = getOrgData(this.topCompanyInfo.getString(CmnConst.ORG_LEVEL_CODE));
            OrganizationEntity topEntity = this.orgToEntity(this.topCompanyInfo);
            if (CollectionUtil.isEmpty(orgData)) {
                return Lists.newArrayList(topEntity);
            }
            getChildren(topEntity);
            return Lists.newArrayList(topEntity);
        }


        private void getChildren(OrganizationEntity entity) {
            String code = entity.getCode();
            // 1 公司 2 部门 3 岗位 4 人员
            String type = entity.getType();
            if (StringUtils.equalsAny(type, "1", "2")) {
                //公司、部门
                List<FieldSetEntity> orgCache = getOrgData(code);
                if (CollectionUtil.isNotEmpty(orgCache)) {
                    for (FieldSetEntity orgDatum : orgCache) {
                        String t = orgDatum.getString("type");
                        if ("1".equals(this.organizationType) && !"1".equals(t)) {
                            continue;
                        }
                        if (("1".equals(t) && !companyPermission(orgDatum.getString(CmnConst.UUID)))
                                || ("2".equals(t) && !deptPermission(orgDatum.getString(CmnConst.UUID)))) {
                            continue;
                        }
                        OrganizationEntity organizationEntity = orgToEntity(orgDatum);
                        entity.addChildren(organizationEntity);
                        this.getChildren(organizationEntity);
                        if (organizationEntity.getChildren() != null && organizationEntity.getChildren().size() > 0) {
                            organizationEntity.setChild(true);
                        }

                    }
                }
            }
            if ("2".equals(type) && StringUtils.equalsAny(this.organizationType, "3", "4")) {
                //岗位
                DataTableEntity postDataByDept = getPostDataByDept(entity.getValue());
                if (DataTableEntity.isEmpty(postDataByDept)) {
                    return;
                }
                sort(postDataByDept.getData());
                for (FieldSetEntity datum : postDataByDept.getData()) {
                    if (!postPermission(datum.getString(CmnConst.UUID))) {
                        continue;
                    }
                    OrganizationEntity organizationEntity = postToEntity(datum);
                    entity.addChildren(organizationEntity);
                    this.getChildren(organizationEntity);
                    if (organizationEntity.getChildren() != null && organizationEntity.getChildren().size() > 0) {
                        organizationEntity.setChild(true);
                    }
                }
            } else if ("5".equals(this.organizationType) && "2".equals(type)) {
                //部门下的人员
                List<FieldSetEntity> staffCacheByDept = getStaffCacheByDept(entity.getValue());
                if (CollectionUtil.isEmpty(staffCacheByDept)) {
                    return;
                }
                sort(staffCacheByDept);
                for (FieldSetEntity datum : staffCacheByDept) {
                    if (!userPermission(datum.getString("user_id"))) {
                        continue;
                    }
                    OrganizationEntity organizationEntity = staffToEntity(datum);
                    entity.addChildren(organizationEntity);
                    this.getChildren(organizationEntity);
                    if (organizationEntity.getChildren() != null && organizationEntity.getChildren().size() > 0) {
                        organizationEntity.setChild(true);
                    }
                }
            } else if ("4".equals(this.organizationType) && "3".equals(type)) {
                List<FieldSetEntity> staffCacheByPost = getStaffCacheByPost(entity.getValue());
                if (CollectionUtil.isEmpty(staffCacheByPost)) {
                    return;
                }
                sort(staffCacheByPost);
                for (FieldSetEntity datum : staffCacheByPost) {
                    if (!userPermission(datum.getString("user_id"))) {
                        continue;
                    }
                    OrganizationEntity organizationEntity = staffToEntity(datum);
                    entity.addChildren(organizationEntity);
                    this.getChildren(organizationEntity);
                    if (organizationEntity.getChildren() != null && organizationEntity.getChildren().size() > 0) {
                        organizationEntity.setChild(true);
                    }
                }
            }
        }

        private boolean userPermission(String userId) {
            if (!ArrayUtil.isEmpty(this.user_ids)) {
                for (String user : this.user_ids) {
                    if (userId.equals(user)) {
                        return true;
                    }
                }
            }
            FieldSetEntity staffCacheByUserId = null;
            if ("4".equals(this.organizationType) && !ArrayUtil.isEmpty(this.post_uuids)) {
                String jobPostUuid = BaseUtil.ifNull(staffCacheByUserId, getStaffCacheByUserId(userId)).getString("job_post_uuid");
                if (!StringUtils.isEmpty(jobPostUuid) && ArrayUtil.contains(this.post_uuids, jobPostUuid)) {
                    return true;
                }
            }
            if (!ArrayUtil.isEmpty(this.dept_uuids)) {
                String deptUuid = BaseUtil.ifNull(staffCacheByUserId, getStaffCacheByUserId(userId)).getString("dept_uuid");
                if (!StringUtils.isEmpty(deptUuid) && ArrayUtil.contains(this.dept_uuids, deptUuid)) {
                    return true;
                }
            }
            if (ArrayUtil.isEmpty(this.post_uuids) && ArrayUtil.isEmpty(this.user_ids) && ArrayUtil.isEmpty(this.dept_uuids)) {
                return true;
            }

            return false;
        }

        private boolean postPermission(String postUid) {
            if (!ArrayUtil.isEmpty(this.post_uuids)) {
                for (String postUuid : this.post_uuids) {
                    if (postUid.equals(postUuid)) {
                        return true;
                    }
                }
            }
            if (StringUtils.equalsAny(this.organizationType, "4") && !ArrayUtil.isEmpty(this.user_ids)) {
                for (String userId : this.user_ids) {
                    FieldSetEntity staffCacheByUserId = getStaffCacheByUserId(userId);
                    if (staffCacheByUserId != null && postUid.equals(staffCacheByUserId.getString("job_post_uuid"))) {
                        return true;
                    }
                }
            }
            if (!ArrayUtil.isEmpty(this.dept_uuids)) {
                for (String deptUuid : this.dept_uuids) {
                    DataTableEntity postDataByDept = getPostDataByDept(deptUuid);
                    if (postDataByDept != null) {
                        for (int i = 0; i < postDataByDept.getRows(); i++) {
                            String uuid = postDataByDept.getString(i, CmnConst.UUID);
                            if (postUid.equals(uuid)) {
                                return true;
                            }
                        }
                    }
                }
            }
            if (ArrayUtil.isEmpty(this.post_uuids) && ArrayUtil.isEmpty(this.user_ids) && ArrayUtil.isEmpty(this.dept_uuids)) {
                return true;
            }
            return false;
        }

        private boolean deptPermission(String deptUid) {
            String uuid;
            if (!ArrayUtil.isEmpty(this.dept_uuids)) {
                for (String deptUuid : this.dept_uuids) {
                    uuid = deptUuid;
                    if (findDept(uuid, deptUid)) {
                        return true;
                    }
                }
            }
            if (StringUtils.equalsAny(this.organizationType, "3", "4") && !ArrayUtil.isEmpty(this.post_uuids)) {
                for (String postUuid : this.post_uuids) {
                    Object[] postCacheByUUID = getPostCacheByUUID(postUuid);
                    if (ArrayUtil.isEmpty(postCacheByUUID)) {
                        continue;
                    }
                    String deptUuid = (String) postCacheByUUID[1];
                    uuid = deptUuid;
                    if (findDept(uuid, deptUid)) {
                        return true;
                    }
                }
            }
            if (StringUtils.equalsAny(this.organizationType, "4", "5") && !ArrayUtil.isEmpty(this.user_ids)) {
                for (String userId : this.user_ids) {
                    FieldSetEntity staffCacheByUserId = getStaffCacheByUserId(userId);
                    if (staffCacheByUserId != null) {
                        uuid = staffCacheByUserId.getString(CmnConst.DEPT_UUID);
                        if (findDept(uuid, deptUid)) {
                            return true;
                        }
                    }
                }
            }
            if (ArrayUtil.isEmpty(this.dept_uuids) && ArrayUtil.isEmpty(this.post_uuids) && ArrayUtil.isEmpty(this.user_ids)) {
                return true;
            }
            return false;
        }

        /**
         * 公司权限
         *
         * @param companyUid
         * @return
         */
        private boolean companyPermission(String companyUid) {
            String uuid;
            if ("1".equals(this.organizationType)) {
                return true;
            }
            if (!ArrayUtil.isEmpty(this.dept_uuids)) {
                for (String deptUuid : this.dept_uuids) {
                    uuid = deptUuid;
                    if (findCompany(uuid, companyUid)) {
                        return true;
                    }
                }
            }
            if (StringUtils.equalsAny(this.organizationType, "3", "4") && !ArrayUtil.isEmpty(this.post_uuids)) {
                for (String postUuid : this.post_uuids) {
                    Object[] postCacheByUUID = getPostCacheByUUID(postUuid);
                    if (ArrayUtil.isEmpty(postCacheByUUID)) {
                        continue;
                    }
                    String deptUuid = (String) postCacheByUUID[1];
                    uuid = deptUuid;
                    if (findCompany(uuid, companyUid)) {
                        return true;
                    }
                }
            }
            if (StringUtils.equalsAny(this.organizationType, "4", "5") && !ArrayUtil.isEmpty(this.user_ids)) {
                for (String userId : this.user_ids) {
                    FieldSetEntity staffCacheByUserId = getStaffCacheByUserId(userId);
                    if (staffCacheByUserId != null) {
                        uuid = staffCacheByUserId.getString(CmnConst.ORG_LEVEL_UUID);
                        if (findCompany(uuid, companyUid)) {
                            return true;
                        }
                    }
                }
            }
            if (ArrayUtil.isEmpty(this.dept_uuids) && ArrayUtil.isEmpty(this.post_uuids) && ArrayUtil.isEmpty(this.user_ids)) {
                return true;
            }
            return false;
        }

        private boolean findDept(String startUid, String targetUid) {
            if (startUid.equals(targetUid)) {
                return true;
            }
            do {
                Map<String, Object> orgCacheByUuid = getOrgCacheByUuid(startUid);
                if (orgCacheByUuid != null) {
                    String parentUuid = (String) orgCacheByUuid.get("parent_uuid");
                    String parentType = (String) orgCacheByUuid.get("parent_type");
                    if ("1".equals(parentType)) {
                        return false;
                    }
                    if (targetUid.equals(parentUuid)) {
                        return true;
                    }
                    startUid = parentUuid;
                } else {
                    return false;
                }
            } while (true);
        }

        private boolean findCompany(String startUid, String targetUid) {
            do {
                Map<String, Object> orgCacheByUuid = getOrgCacheByUuid(startUid);
                if (orgCacheByUuid != null) {
                    String parentUuid = (String) orgCacheByUuid.get("parent_uuid");
                    if (targetUid.equals(parentUuid)) {
                        return true;
                    }
                    startUid = parentUuid;
                } else {
                    return false;
                }
            } while (true);
        }

        /**
         * 获取组织机构数据
         *
         * @param parentCode
         * @return
         */
        private List<FieldSetEntity> getOrgData(String parentCode) {
            List<FieldSetEntity> orgCache = getOrgCache(parentCode);
            if (CollectionUtil.isNotEmpty(orgCache)) {
                List<FieldSetEntity> result = new ArrayList<>();

                sort(orgCache);
                for (int i = 0; i < orgCache.size(); i++) {
                    String type = orgCache.get(i).getString("type");
                    if (!"1".equals(type)) {
                        result.add(orgCache.get(i));
                        orgCache.remove(i);
                        i--;
                    }
                }
                result.addAll(orgCache);
                return result;
            }
            return Collections.emptyList();
        }

        private void sort(List<FieldSetEntity> data) {
            if (CollectionUtil.isEmpty(data)) {
                return;
            }
            data.sort(Comparator.comparing(a -> Optional.ofNullable(a.getInteger("sequence")).orElse(Integer.MAX_VALUE)));
        }

        private OrganizationEntity orgToEntity(FieldSetEntity fse) {
            OrganizationEntity entity = new OrganizationEntity();
            entity.setValue(fse.getString(CmnConst.UUID));
            entity.setName(fse.getString(CmnConst.ORG_LEVEL_NAME));
            entity.setCode(fse.getString(CmnConst.ORG_LEVEL_CODE));
            entity.setParentCode(fse.getString(CmnConst.ORG_LEVEL_CODE_PARENT));
            entity.setOrganizationFullName(fse.getString("parent_org_level_all"));
//            entity.setSequence(fse.getInteger(CmnConst.SEQUENCE));
            entity.setType(fse.getString("type"));
            entity.setChild(isChild(fse));
            return entity;
        }

        private OrganizationEntity staffToEntity(FieldSetEntity fse) {
            OrganizationEntity entity = new OrganizationEntity();
            entity.setValue(fse.getString(CmnConst.USER_ID));
            entity.setName(fse.getString(CmnConst.USER_NAME));
            entity.setOrganizationFullName(fse.getString(CmnConst.ORG_LEVEL_ALL));
//            entity.setCode(fse.getString(CmnConst.ORG_LEVEL_CODE));
//            entity.setParentCode(fse.getString(CmnConst.UUID));
//            entity.setSequence(fse.getInteger(CmnConst.SEQUENCE));
            entity.setType(fse.getString("type"));
            entity.setSex(fse.getString("sex"));
            entity.setChild(false);
            return entity;
        }

        private OrganizationEntity postToEntity(FieldSetEntity fse) {
            OrganizationEntity entity = new OrganizationEntity();
            entity.setValue(fse.getString(CmnConst.UUID));
            entity.setOrganizationFullName(fse.getString(CmnConst.ORG_LEVEL_ALL));
            entity.setName(fse.getString("job_post_name"));
//            entity.setCode(fse.getString(CmnConst.ORG_LEVEL_CODE));
//            entity.setParentCode(fse.getString(CmnConst.UUID));
//            entity.setSequence(fse.getInteger(CmnConst.SEQUENCE));
            entity.setType(fse.getString("type"));
            entity.setChild(isChild(fse));
            return entity;
        }

        private boolean isChild(FieldSetEntity fse) {
            String type = fse.getString("type");

            if (StringUtils.equalsAny(type, "1", "2")) {
                if (("1".equals(fse.getString("childrenCompany"))
                        || "1".equals(fse.getString("childrenDept")))) {
                    return true;
                }
                if ("2".equals(type)) {
                    if (StringUtils.equalsAny(this.organizationType, "3", "4") && "1".equals(fse.getString("childrenPost"))) {
                        return true;
                    }
                }
                return false;
            }
            if (("3".equals(type) || "4".equals(type)) && "1".equals(fse.getString("childrenStaff"))) {
                return true;
            }

            return false;
        }

    }


//    /**
//     * 组织机构入口方法
//     *
//     * @param fse
//     * @return
//     * @throws BaseException
//     */
//    @Override
//    public Object getOrganization(FieldSetEntity fse) throws BaseException {
//
//        if (!StringUtils.isEmpty(fse.getString("~values~"))) {
//            return getSelectedValueLabel(fse.getString("~values~"));
//        }
//        // 前端点击的类型 参考 组织机构类型 如果为空 默认赋值 0 = 客户下的公司（顶级）
//        String current_type = fse.getString("current_type");
//        //组织机构类型 1-公司，2-公司 - 部门，3-公司 - 部门 - 岗位，4-公司 - 部门 - 岗位 - 人员，5-公司 - 部门 - 人员
//        String organization_type = fse.getString("organization_type");
//        //当前位置 todo
////        String showCurrentLocation = fse.getString("showCurrentLocation");
//        String[] post_uuids = null;
//        if (!StringUtils.isEmpty(fse.getString("post_uuids"))) {
//            post_uuids = fse.getString("post_uuids").split(",");
//        }
//        String[] dept_uuids = null;
//        if (!StringUtils.isEmpty(fse.getString("dept_uuids"))) {
//            dept_uuids = fse.getString("dept_uuids").split(",");
//        }
//        String[] user_ids = null;
//        if (!StringUtils.isEmpty(fse.getString("user_ids"))) {
//            user_ids = fse.getString("user_ids").split(",");
//        }
//
//        //当搜索值不为空时
//        if (!StringUtils.isEmpty(fse.getString("~search_value~"))) {
//            return getSearchValueResult(fse, dept_uuids, post_uuids, user_ids);
//        }
//
//        DataTableEntity result = new DataTableEntity();
//        // 前端点击的value
//        String current_value = fse.getString("current_value");
//
//        SystemUser currentUser = SpringMVCContextHolder.getCurrentUser();
//        //查看集团
////        String is_group = fse.getString("is_group");
////        if (StringUtils.isEmpty(is_group)) {
////            //设置默认值
////            is_group = "1";
////
////            //todo
////        }
//        //上级value
//        Object[] parentValues = null;
//        String[] retainUuids = null;
//
//        //用户类型
//        int userType = currentUser.getUserType();
//        FieldSetEntity currentManager = currentUser.getCurrentManager();
//        if ((1 == userType || 4 == userType) && FieldSetEntity.isEmpty(currentManager)) {
//            return result;
//        }
//        //获取客户作为上级values
//        if ("0".equals(current_type) && StringUtils.isEmpty(current_value)) {
//            if (0 == userType) {
//                //普通用户
//                parentValues = new Object[]{currentUser.getClientUuid()};
//            } else if (1 == userType || 3 == userType) {
//                //超级管理员 或 隐藏管理员
//                DataTableEntity dt = DataPoolCacheImpl.getInstance().getCacheData("客户信息");
//                if (DataTableEntity.isEmpty(dt)) {
//                    return result;
//                }
//                parentValues = dt.getUuids();
//            } else if (2 == userType) {
//                //管理的所在的客户
//                String client_uuids = currentManager.getString("clients_uuid");
//                //管理员所管理的公司
////                String org_level_uuid = currentManager.getString("org_level_uuid");
////                if (StringUtils.isEmpty(client_uuids) || StringUtils.isEmpty(org_level_uuid)) {
////                    return result;
////                }
////                retainUuids = org_level_uuid.split(",");
//                parentValues = new Object[]{client_uuids};
//            } else if (4 == userType) {
//                //平台管理员
//                //管理的所有客户uuid
//                String client_uuids = currentManager.getString("clients_uuid");
//                if (StringUtils.isEmpty(client_uuids)) {
//                    return result;
//                }
//                parentValues = Arrays.stream(client_uuids.split(",")).toArray();
//            }
//
//        } else {
//            if (StringUtils.isEmpty(current_value)) {
//                return result;
//            }
//            parentValues = new Object[]{current_value};
//            //公司
//            if ("1".equals(current_type)) {
//                if (2 == userType) {
//                    //管理的所在的客户
//                    String client_uuids = currentManager.getString("clients_uuid");
//                    //管理员所管理的公司
////                    String org_level_uuid = currentManager.getString("org_level_uuid");
////                    if (StringUtils.isEmpty(client_uuids) || StringUtils.isEmpty(org_level_uuid)) {
////                        return result;
////                    }
////                    retainUuids = org_level_uuid.split(",");
//                }
//
//            }
//        }
//        List<FieldSetEntity> resultList = new ArrayList<>();
//        if (parentValues != null && parentValues.length > 0) {
//            // 类型为空获取客户下的公司（顶级）
//            if (StringUtils.isEmpty(current_type)) {
//                current_type = "0";
//            }
//            //组织机构选择类型
//            int orgType = Integer.parseInt(organization_type);
//            OrganizationFilter filter = getFilter(current_type, orgType, dept_uuids, post_uuids, user_ids);
//            // 获取公司 / 部门
//            if ("0".equals(current_type) || "1".equals(current_type) || "2".equals(current_type)) {
//                List<FieldSetEntity> orgLevelData = getOrgLevelData(parentValues, filter);
//                orgLevelData.sort(Comparator.comparing(a -> a.getInteger("sequence")));
//                resultList.addAll(orgLevelData);
//            }
//            // 获取岗位
//            if ("2".equals(current_type) && ("3".equals(organization_type) || "4".equals(organization_type))) {
//                List<FieldSetEntity> postDataByDept = getPostDataByDept(fse.getUUID(), filter);
//                if (postDataByDept != null) {
//                    postDataByDept.sort(Comparator.comparing(a -> a.getInteger("sequence")));
//                    resultList.addAll(postDataByDept);
//                }
//            }
//            // 获取人员
//            if ("3".equals(current_type) || ("5".equals(organization_type) && "2".equals(current_type))) {
//                List<FieldSetEntity> userData = getUserData(orgType, fse.getUUID(), filter);
//                if (userData != null) {
//                    userData.sort(Comparator.comparing(a -> a.getInteger("sequence")));
//                    resultList.addAll(userData);
//                }
//            }
//        }
//
//        result.setData(resultList);
//        return result;
//    }

    /**
     * @param organizationType 组织机构类型
     * @param parentValue
     * @param filter
     * @return
     * @throws BaseException
     */
    private List<FieldSetEntity> getUserData(int organizationType, String parentValue, OrganizationFilter filter) throws BaseException {
        List<FieldSetEntity> fieldSetEntityList = null;
        if (5 == organizationType) {
            fieldSetEntityList = getStaffCacheByDept(parentValue);
        } else if (4 == organizationType) {
            fieldSetEntityList = getStaffCacheByPost(parentValue);
        }

        if (fieldSetEntityList != null && fieldSetEntityList.size() > 0) {
            for (int i = 0; i < fieldSetEntityList.size(); i++) {
                FieldSetEntity ff = fieldSetEntityList.get(i);
                if (FieldSetEntity.isEmpty(ff)) {
                    fieldSetEntityList.remove(i);
                    i--;
                    continue;
                }

                String userId = ff.getString("user_id");
                String deptUuid = ff.getString("dept_uuid");
                String postUuid = ff.getString("job_post_uuid");
                if (!filter.allowUser(userId, deptUuid, postUuid)) {
                    fieldSetEntityList.remove(i);
                    i--;
                    continue;
                }
                ff.setValue("type", 4);
                ff.setValue("label", ff.getString(CmnConst.USER_NAME));
                ff.setValue("value", ff.getString(CmnConst.USER_ID));
                ff.setValue("sid", ff.getUUID());
            }

        }

        return fieldSetEntityList;
    }

    private List<FieldSetEntity> getPostDataByDept(String deptUuid, OrganizationFilter filter) throws BaseException {
        if (StringUtils.isEmpty(deptUuid)) {
            return null;
        }
        List<FieldSetEntity> fieldSetEntityList = getPostCache(deptUuid);
        if (fieldSetEntityList == null || fieldSetEntityList.size() == 0) {
            return null;
        }
        for (int i = 0; i < fieldSetEntityList.size(); i++) {
            FieldSetEntity ff = fieldSetEntityList.get(i);

            if (FieldSetEntity.isEmpty(ff)) {
                fieldSetEntityList.remove(i);
                i--;
                continue;
            }
            String uuid = ff.getUUID();
            if (!filter.allowPost(uuid, deptUuid)) {
                fieldSetEntityList.remove(i);
                i--;
                continue;
            }
            if (isChildren(3, uuid, filter)) {
                ff.setValue("childrenStaff", 1);
            }
            ff.setValue("label", ff.getString("job_post_name"));
            ff.setValue("value", ff.getUUID());
            ff.setValue("sid", ff.getUUID());


        }
        return fieldSetEntityList;
    }


    private List<FieldSetEntity> getOrgLevelData(Object[] parentValues, OrganizationFilter filter) throws BaseException {
        List<FieldSetEntity> resultList = new ArrayList<>();
        List<FieldSetEntity> fieldSetEntityList = null;
        for (Object parentValue : parentValues) {
            if (StringUtils.isEmpty(parentValue)) {
                continue;
            }
            //格局上级value 获取 机构数据
            fieldSetEntityList = getOrgCache((String) parentValue);
            for (int i = 0; fieldSetEntityList != null && i < fieldSetEntityList.size(); i++) {
                FieldSetEntity ff = fieldSetEntityList.get(i);
                if (!FieldSetEntity.isEmpty(ff)) {
                    String type = ff.getString("type");


                    //是否为公司
                    boolean isCompany = "1".equals(type);
                    String uuid = ff.getUUID();
                    if ((!isCompany && !filter.allowDept(uuid)) || (isCompany && !filter.isAllowCompany(ff.getString(CmnConst.ORG_LEVEL_CODE)))) {
                        fieldSetEntityList.remove(i);
                        i--;
                        continue;
                    }
                    if (isChildren(Integer.parseInt(type), ff.getUUID(), filter)) {
                        ff.setValue("childrenCompany", 1);
                    }
                    ff.setValue("label", ff.getString(CmnConst.ORG_LEVEL_NAME));
                    ff.setValue("value", ff.getUUID());
                    ff.setValue("sid", ff.getString(CmnConst.ORG_LEVEL_CODE));
                }
            }
            if (!CollectionUtil.isEmpty(fieldSetEntityList)) {
                resultList.addAll(fieldSetEntityList);
            }
        }
        return resultList;

    }

    private boolean isChildren(int currentType, String currentValue, OrganizationFilter filter) {
        int orgType = filter.getType();
        switch (currentType) {
            case 1:
                if (orgType != 1) {
                    return isChildrenOrg(filter, currentValue, "1");
                } else {
                    return isChildrenOrg(filter, currentValue, "1") || isChildrenOrg(filter, currentValue, "2");
                }
            case 2:
                return isChildrenOrg(filter, currentValue, "2")
                        || ((orgType == 3 || orgType == 4) && isChildrenPost(filter, currentValue))
                        || (orgType == 5 && isChildrenUser(filter, currentValue, currentType));
            case 3:
                return orgType == 4 && isChildrenUser(filter, currentValue, currentType);
            default:
                return false;
        }
    }

    private boolean isChildrenOrg(OrganizationFilter filter, String value, String type) {
        Map<String, Object> orgCacheByUuid = this.getOrgCacheByUuid(value);
        if (orgCacheByUuid == null) {
            return false;
        }
        List<FieldSetEntity> orgCache = this.getOrgCache((String) orgCacheByUuid.get(CmnConst.ORG_LEVEL_CODE));
        return !CollectionUtil.isEmpty(orgCache) && orgCache.stream().filter(item -> item != null &&
                type.equals(item.getString(CmnConst.ORG_LEVEL_TYPE))
                && (("2".equals(type) && filter.allowDept(item.getUUID()))
                || "1".equals(type))).count() > 0;
    }

    private boolean isChildrenPost(OrganizationFilter filter, String value) {
        List<FieldSetEntity> postCache = this.getPostCache(value);
        return !CollectionUtil.isEmpty(postCache) && postCache.stream().filter(item -> item != null
                        && filter.allowPost(item.getUUID(), item.getString("dept_uuid")))
                .count() > 0;
    }

    private boolean isChildrenUser(OrganizationFilter filter, String value, int parentType) {
        List<FieldSetEntity> data = null;
        if (parentType == 2) {
            data = this.getStaffCacheByDept(value);
        } else if (parentType == 3) {
            data = this.getStaffCacheByPost(value);
        }
        return !CollectionUtil.isEmpty(data) && data.stream().filter(item -> item != null && filter.allowUser(item.getString(CmnConst.USER_ID),
                item.getString(CmnConst.DEPT_UUID),
                parentType == 2 ? item.getString("job_post_uuid") : null)).count() > 0;
    }


    /**
     * @param currentType      当前获取数据的类型
     * @param organizationType 机构选择类型
     * @param dept_uuid
     * @param post_uuid
     * @param userIds
     * @return
     */
    private OrganizationFilter getFilter(String currentType, int organizationType, String[]
            dept_uuid, String[] post_uuid, String[] userIds) {
        OrganizationFilter organizationFilter = new OrganizationFilter(organizationType);
        if ("0".equals(currentType)) {
            return organizationFilter;
        }
        if (4 == organizationType || 5 == organizationType) {
            organizationFilter.addAllowUser(userIds);
            Set<String> userTheirPost = getUserTheirPost(userIds);
            organizationFilter.addPostNotAll(userTheirPost);
            if (userTheirPost != null) {
                Set<String> postTheirDept = getPostTheirDept(userTheirPost.toArray(new String[userTheirPost.size()]));
                organizationFilter.addDeptNotAll(postTheirDept);
            }
        }
        if (1 != organizationType) {
            organizationFilter.addAllowDept(dept_uuid);
        }
        if (3 == organizationType || 4 == organizationType) {
            organizationFilter.addAllowPost(post_uuid);
            Set<String> postTheirDept = getPostTheirDept(post_uuid);
            organizationFilter.addDeptNotAll(postTheirDept);
        }


        return organizationFilter;
    }

    private Set<String> getPostTheirDept(String[] postUuid) {
        if (ArrayUtil.isEmpty(postUuid)) {
            return null;
        }
        Set<String> resultSet = new HashSet<>();
        for (String post : postUuid) {
            Object[] postCache = getPostCacheByUUID(post);
            if (!ArrayUtil.isEmpty(postCache) && !StringUtils.isEmpty(postCache[1])) {
                resultSet.add((String) postCache[1]);
            }
        }
        return resultSet;
    }

    private Set<String> getUserTheirPost(String[] userIds) {
        if (ArrayUtil.isEmpty(userIds)) {
            return null;
        }
        Set<String> resultSet = new HashSet<>();
        for (String userId : userIds) {
            FieldSetEntity user = BaseUtil.getSingleInfoByCache("用户缓存", new String[]{userId});
            if (!FieldSetEntity.isEmpty(user) && !StringUtils.isEmpty(user.getString("job_post_uuid"))) {
                resultSet.add(user.getString("job_post_uuid"));
            }
        }
        return resultSet;
    }


    /**
     * 获取人员
     *
     * @param parentValue
     * @param type
     * @param retainUserId
     * @return
     */
    private List<FieldSetEntity> getStaffs(String parentValue, int type, String[] retainUserId, Set<String>[]
            organizationFilter) {

        List<String> retainUserIdList = new ArrayList<>();
        if (retainUserId != null && retainUserId.length > 0) {
            retainUserIdList.addAll(Arrays.asList(retainUserId));
        }
        if (StringUtils.isEmpty(parentValue)) {
            return null;
        }
        List<FieldSetEntity> fieldSetEntityList = null;
        if (5 == type) {
            fieldSetEntityList = getStaffCacheByDept(parentValue);
        } else if (4 == type) {
            fieldSetEntityList = getStaffCacheByPost(parentValue);
        }
        for (int i = 0; fieldSetEntityList != null && i < fieldSetEntityList.size(); i++) {
            FieldSetEntity ff = fieldSetEntityList.get(i);
            if (!FieldSetEntity.isEmpty(ff)) {
                boolean allow_dept = false;
                boolean allow_post = false;
                if (organizationFilter != null) {
                    if (organizationFilter[0] != null && organizationFilter[0].contains(ff.getString("dept_uuid"))) {
                        allow_dept = true;
                    } else if (organizationFilter[1] != null && organizationFilter[1].contains(ff.getString("job_post_uuid"))) {
                        allow_post = true;
                    }
                }
                if (retainUserIdList.size() > 0 && !allow_dept && !allow_post) {
                    if (!retainUserIdList.contains(ff.getString(CmnConst.USER_ID))) {
                        // 不允许选择的
                        fieldSetEntityList.remove(i);
                        i--;
                        continue;
                    }
                }
                ff.setValue("~allow_select~", true);
                ff.setValue("type", 4);
                ff.setValue("label", ff.getString(CmnConst.USER_NAME));
                ff.setValue("value", ff.getString(CmnConst.USER_ID));
                ff.setValue("sid", ff.getUUID());

            } else {
                fieldSetEntityList.remove(i);
                i--;
            }
        }
        return fieldSetEntityList;
    }

    /**
     * 获取岗位
     *
     * @param parentValue 上级部门uuid
     * @param retainUuids
     * @return
     */
    private List<FieldSetEntity> getPosts(String parentValue, String[] retainUuids, String[] dept_uuid, String[]
            user_ids, int type, Set<String>[] organizationFilter) {
        List<String> retainUudList = new ArrayList<>();
        if (retainUuids != null && retainUuids.length > 0) {
            retainUudList.addAll(Arrays.asList(retainUuids));
        }
        if (StringUtils.isEmpty(parentValue)) {
            return null;
        }
        List<FieldSetEntity> fieldSetEntityList = getPostCache(parentValue);
        for (int i = 0; fieldSetEntityList != null && i < fieldSetEntityList.size(); i++) {
            FieldSetEntity ff = fieldSetEntityList.get(i);
            if (!FieldSetEntity.isEmpty(ff)) {
                boolean allow_post = false;
                if (user_ids != null && user_ids.length > 0 && (type == 4 || type == 5)) {
                    for (String user_id : user_ids) {

                        FieldSetEntity fff = BaseUtil.getSingleInfoByCache("用户缓存", new String[]{user_id});
                        if (FieldSetEntity.isEmpty(fff)) {
                            continue;
                        }
                        String job_post_uuid = fff.getString("job_post_uuid");
                        if (StringUtils.equals(job_post_uuid, ff.getUUID())) {
                            allow_post = true;
                            break;
                        }
                    }
                }
                if (retainUudList.size() > 0 && !allow_post) {
                    if (!retainUudList.contains(ff.getUUID())) {
                        // 不允许选择的
                        fieldSetEntityList.remove(i);
                        i--;
                        continue;
                    }
                }
                if (dept_uuid != null && dept_uuid.length > 0 && !allow_post) {
                    if (!ArrayUtil.contains(dept_uuid, ff.getString(CmnConst.DEPT_UUID))) {
                        // 不允许选择的
                        fieldSetEntityList.remove(i);
                        i--;
                        continue;
                    }
                }
                if (!allow_post && organizationFilter != null && organizationFilter.length == 2 && organizationFilter[1] != null && organizationFilter[1].size() > 0) {
                    if (!organizationFilter[1].contains(ff.getUUID())) {
                        // 不允许选择的
                        fieldSetEntityList.remove(i);
                        i--;
                        continue;
                    }
                }
                //不选人员
                if (4 != type) {
                    ff.setValue("childrenStaff", 0);
                }
                ff.setValue("~allow_select~", true);
                ff.setValue("type", 3);
                ff.setValue("label", ff.getString("job_post_name"));
                ff.setValue("value", ff.getUUID());
                ff.setValue("sid", ff.getUUID());

            } else {
                fieldSetEntityList.remove(i);
                i--;
            }
        }
        return fieldSetEntityList;
    }

    /**
     * 获取机构
     *
     * @param parentValues 上级编码
     * @param retainUuids  保留的uuid 如果为空则保留所有
     * @return`
     */
    private List<FieldSetEntity> getOrgLevels(Object[] parentValues, String[] retainUuids, String[]
            retainDeptUuids, String[] post_uuids, String[] user_ids,
                                              int type, Set<String>[] organizationFilter) {
        List<String> retainUudList = new ArrayList<>();
        if (retainUuids != null && retainUuids.length > 0) {
            retainUudList.addAll(Arrays.asList(retainUuids));
        }
        List<String> retainDeptUudList = new ArrayList<>();
        if (retainDeptUuids != null && retainDeptUuids.length > 0) {
            retainDeptUudList.addAll(Arrays.asList(retainDeptUuids));
        }
        List<FieldSetEntity> fieldSetEntityList = null;
        for (Object parentValue : parentValues) {
            if (StringUtils.isEmpty(parentValue)) {
                continue;
            }
            fieldSetEntityList = getOrgCache((String) parentValue);
            for (int i = 0; fieldSetEntityList != null && i < fieldSetEntityList.size(); i++) {
                FieldSetEntity ff = fieldSetEntityList.get(i);
                if (!FieldSetEntity.isEmpty(ff)) {
                    ff.setValue("~allow_select~", true);
                    ff.setValue("label", ff.getString(CmnConst.ORG_LEVEL_NAME));
                    ff.setValue("value", ff.getUUID());
                    ff.setValue("sid", ff.getString(CmnConst.ORG_LEVEL_CODE));
                    boolean allow_dept = false;
                    // 不选岗位
                    if (3 != type && 4 != type) {
                        ff.setValue("childrenPost", 0);
                    } else if (!ArrayUtil.isEmpty(post_uuids)) {
                        for (String post_uuid : post_uuids) {
                            Object[] postCache = getPostCacheByUUID(post_uuid);
                            if (!ArrayUtil.isEmpty(postCache) && StringUtils.equals(ff.getUUID(), (String) postCache[1])) {
                                allow_dept = true;
                                break;
                            }
                        }
                    }
                    // 只选公司
                    if (1 == type) {
                        if ("2".equals(ff.getString("type"))) {
                            fieldSetEntityList.remove(i);
                            i--;
                            continue;
                        }
                        ff.setValue("childrenDept", 0);
                    }
                    // 不选人员
                    if (5 != type && 4 != type) {
                        ff.setValue("childrenStaff", 0);
                    } else if (!allow_dept) {
                        if (user_ids != null && user_ids.length > 0) {
                            for (String user_id : user_ids) {
                                FieldSetEntity fff = BaseUtil.getSingleInfoByCache("用户缓存", new String[]{user_id});
                                if (FieldSetEntity.isEmpty(fff)) {
                                    continue;
                                }
                                String dept_uuid = fff.getString("dept_uuid");
                                if (StringUtils.equals(dept_uuid, ff.getUUID())) {
                                    allow_dept = true;
                                    break;
                                }
                            }
                        }
                    }
                    if (!allow_dept && organizationFilter != null && organizationFilter[0] != null && organizationFilter[0].size() > 0) {
                        if (!organizationFilter[0].contains(ff.getString(CmnConst.ORG_LEVEL_CODE))) {
                            // 不允许选择的
                            fieldSetEntityList.remove(i);
                            i--;
                            continue;
                        }
                    }
                } else {
                    fieldSetEntityList.remove(i);
                    i--;
                }
            }

        }
        return fieldSetEntityList;
    }


    class OrganizationFilter {
        private int type;

        private Set<String> allowCompany;

        private Set<String> allowDept;

        private Set<String> allowPost;

        private Set<String> allowUser;

        private Set<String> deptNotAll;

        private Set<String> postNotAll;

        private boolean isEmpty(Collection collection) {
            return collection == null || collection.size() <= 0;
        }

        private boolean isEmpty(Collection... collection) {
            return collection != null && collection.length > 0 && Arrays.stream(collection).filter(item -> !isEmpty(item)).count() <= 0;
        }

        private boolean contains(Collection collection, Object val) {

            return val != null && !this.isEmpty(collection) && collection.contains(val);
        }

        public boolean allowDept(String uuid) {
            // 允许的部门为空 且 允许部门下的部分为空
            if (this.isEmpty(this.allowDept) && this.isEmpty(this.deptNotAll)) {
                return true;
            }
            // 允许的部门中是否有当前传入的部门
            if (this.contains(this.allowDept, uuid)) {
                return true;
            }
            // 允许展示部分的部门中是否有当前传入的部门
            if (this.contains(this.deptNotAll, uuid)) {
                return true;
            }

            return false;
        }

        public boolean allowParentDept(String uuid) {
            if (this.isEmpty(this.allowDept, this.deptNotAll)) {
                return false;
            }
            Map<String, Object> orgCacheByUuid = getOrgCacheByUuid(uuid);
            String type = (String) orgCacheByUuid.get("parent_type");
            if ("1".equals(type)) {

            }
            return false;
        }

        public boolean allowPost(String uuid, String deptUuid) {
            //允许的部门中是否有当前传入的部门
            if (this.contains(this.allowDept, deptUuid)) {
                return true;
            }
            //允许展示部分部门中包含当前传入的部门
            if (this.contains(this.deptNotAll, deptUuid)) {
                //传入的岗位是否在允许的岗位中
                if (this.contains(this.allowPost, uuid)) {
                    return true;
                }
                //传入的岗位是否在允许的部分岗位中
                if (this.contains(this.postNotAll, uuid)) {
                    return true;
                }
            }
            if (this.contains(this.allowPost, uuid) || this.contains(this.postNotAll, uuid)) {
                return true;
            }
            if (this.isEmpty(this.allowPost, this.deptNotAll, this.allowPost, this.postNotAll)) {
                return true;
            }
            return false;
        }

        public boolean allowUser(String userId, String deptUuid, String postUuid) {
            if (this.contains(this.allowUser, userId)
                    || this.contains(this.allowDept, deptUuid)
                    || (StringUtils.isEmpty(deptUuid) || this.contains(this.allowPost, postUuid))
            ) {
                return true;
            }

            return this.isEmpty(this.allowPost, this.allowDept, this.allowUser);
        }


        public OrganizationFilter(int type) {
            this.type = type;
        }

        public int getType() {
            return type;
        }

        public Set<String> getDeptNotAll() {
            return deptNotAll;
        }

        public boolean isDeptNotAll(String val) {
            if (deptNotAll == null || deptNotAll.size() == 0) {
                return false;
            }
            return deptNotAll.contains(val);
        }

        public boolean isPostNotAll(String val) {
            if (postNotAll == null || postNotAll.size() == 0) {
                return false;
            }
            return postNotAll.contains(val);
        }

        public void addDeptNotAll(Collection<String> collection) {
            if (collection == null || collection.size() == 0) {
                return;
            }
            if (deptNotAll == null) {
                deptNotAll = new HashSet<>();
            }
            deptNotAll.addAll(collection);
            addDeptNotAll(getParentUuid(collection.toArray(new String[collection.size()])));
        }

        public Set<String> getPostNotAll() {
            return postNotAll;
        }

        public void addPostNotAll(Collection<String> collection) {
            if (collection == null || collection.size() == 0) {
                return;
            }
            if (postNotAll == null) {
                postNotAll = new HashSet<>();
            }
            postNotAll.addAll(collection);
        }

        public void addAllowCompany(String... uuid) {
            if (ArrayUtil.isEmpty(uuid)) {
                return;
            }
            if (allowCompany == null) {
                allowCompany = new HashSet<>();
            }
            allowCompany.addAll(CollectionUtil.toList(uuid));
        }

        public boolean isAllowCompany(String code) {
            if (this.isEmpty(deptNotAll, allowDept)) {
                return true;
            } else if (!StringUtils.isEmpty(code)) {
                Set<String> deptSet = new HashSet<>();
                if (!this.isEmpty(deptNotAll)) {
                    deptSet.addAll(deptNotAll);
                }
                if (!this.isEmpty(allowDept)) {
                    deptSet.addAll(allowDept);
                }
                for (String uuid : deptSet) {
                    Map<String, Object> orgCacheByUuid = getOrgCacheByUuid(uuid);
                    if (orgCacheByUuid != null && StringUtils.startsWith((String) orgCacheByUuid.get(CmnConst.ORG_LEVEL_CODE), code)) {
                        return true;
                    }
                    continue;
                }
            }
            return false;
        }

        public void addAllowDept(String... uuid) {
            if (ArrayUtil.isEmpty(uuid)) {
                return;
            }
            if (allowDept == null) {
                allowDept = new HashSet<>();
            }
            allowDept.addAll(CollectionUtil.toList(uuid));
        }

        public boolean isAllowDept(String val) {
            if (allowDept == null || allowDept.size() == 0) {
                return true;
            } else {
                return allowDept.contains(val);
            }
        }

        public void addAllowPost(String... uuid) {
            if (ArrayUtil.isEmpty(uuid)) {
                return;
            }
            if (allowPost == null) {
                allowPost = new HashSet<>();
            }
            allowPost.addAll(CollectionUtil.toList(uuid));
            addDeptNotAll(getParentUuid(uuid));
        }


        public Collection<String> getParentUuid(String[] uuids) {
            Set<String> parentDept = new HashSet<>();
            if (uuids != null && uuids.length > 0) {
                for (String uuid : uuids) {
                    if (StringUtils.isEmpty(uuid)) continue;
                    Map<String, Object> orgCacheByUuid = getOrgCacheByUuid(uuid);
                    if (orgCacheByUuid != null) {
                        String parent_uuid = (String) orgCacheByUuid.get("parent_uuid");
                        if ("2".equals(orgCacheByUuid.get("parent_type"))) {
                            parentDept.add(parent_uuid);
                        }
                    }
                }
            }
            return parentDept;
        }

        public boolean isAllowPost(String val) {
            if (allowPost == null || allowPost.size() == 0) {
                if (isPostNotAll(val)) {

                }
                return true;
            } else {
                return allowPost.contains(val);
            }
        }


        public void addAllowUser(String... ids) {
            if (ArrayUtil.isEmpty(ids)) {
                return;
            }
            if (allowUser == null) {
                allowUser = new HashSet<>();
            }
            allowUser.addAll(CollectionUtil.toList(ids));
        }

        public boolean isAllowUser(String val) {
            if (allowUser == null || allowUser.size() == 0) {
                return true;
            } else {
                return allowUser.contains(val);
            }
        }
    }

}