weaver-hrm-organization/src/com/engine/organization/service/impl/DepartmentServiceImpl.java

package com.engine.organization.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.api.browser.bean.SearchConditionGroup;
import com.api.browser.bean.SearchConditionItem;
import com.api.browser.bean.SearchConditionOption;
import com.cloudstore.eccom.pc.table.WeaTableColumn;
import com.cloudstore.eccom.result.WeaResultMsg;
import com.engine.common.util.ServiceUtil;
import com.engine.core.impl.Service;
import com.engine.hrm.entity.RuleCodeType;
import com.engine.organization.component.OrganizationWeaTable;
import com.engine.organization.entity.DeleteParam;
import com.engine.organization.entity.codesetting.po.CodeRulePO;
import com.engine.organization.entity.commom.RecordInfo;
import com.engine.organization.entity.company.bo.CompBO;
import com.engine.organization.entity.company.po.CompPO;
import com.engine.organization.entity.department.bo.DepartmentBO;
import com.engine.organization.entity.department.dto.DepartmentListDTO;
import com.engine.organization.entity.department.param.*;
import com.engine.organization.entity.department.po.DepartmentPO;
import com.engine.organization.entity.department.vo.SingleDeptTreeVO;
import com.engine.organization.entity.extend.po.ExtendTitlePO;
import com.engine.organization.entity.job.bo.JobBO;
import com.engine.organization.entity.job.po.JobPO;
import com.engine.organization.entity.job.vo.SingleJobTreeVO;
import com.engine.organization.entity.searchtree.SearchTree;
import com.engine.organization.entity.searchtree.SearchTreeParams;
import com.engine.organization.enums.LogModuleNameEnum;
import com.engine.organization.enums.OperateTypeEnum;
import com.engine.organization.mapper.codesetting.CodeRuleMapper;
import com.engine.organization.mapper.comp.CompMapper;
import com.engine.organization.mapper.department.DepartmentMapper;
import com.engine.organization.mapper.extend.ExtDTMapper;
import com.engine.organization.mapper.extend.ExtMapper;
import com.engine.organization.mapper.extend.ExtendTitleMapper;
import com.engine.organization.mapper.hrmresource.SystemDataMapper;
import com.engine.organization.mapper.job.JobMapper;
import com.engine.organization.service.DepartmentService;
import com.engine.organization.service.ExtService;
import com.engine.organization.thread.DepartmentTriggerRunnable;
import com.engine.organization.thread.HrmResourceTriggerRunnable;
import com.engine.organization.thread.JobTriggerRunnable;
import com.engine.organization.thread.OrganizationSyncEc;
import com.engine.organization.util.*;
import com.engine.organization.util.coderule.CodeRuleUtil;
import com.engine.organization.util.db.MapperProxyFactory;
import com.engine.organization.util.page.Column;
import com.engine.organization.util.page.PageInfo;
import com.engine.organization.util.page.PageUtil;
import com.engine.organization.util.relation.EcHrmRelationUtil;
import com.engine.organization.util.tree.SearchTreeUtil;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import weaver.conn.RecordSet;
import weaver.general.StringUtil;
import weaver.general.Util;
import weaver.hrm.User;

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

/**
 * @Author weaver_cl
 * @description:
 * @Date 2022/5/20
 * @Version V1.0
 **/
public class DepartmentServiceImpl extends Service implements DepartmentService {

    /**
     * 分组类型
     * 1：分部
     * 2：部门
     * 3：岗位
     */
    private static final String EXTEND_TYPE = "2";
    /**
     * 主表
     */
    private static final String JCL_ORG_DEPT = "JCL_ORG_DEPT";
    /**
     * 主表拓展表
     */
    private static final String JCL_ORG_DEPTEXT = "JCL_ORG_DEPTEXT";
    /**
     * 明细表拓展表
     */
    private static final String JCL_ORG_DEPTEXT_DT1 = "JCL_ORG_DEPTEXT_DT1";

    private static final String RIGHT_NAME = "Department:All";

    /**
     * 部门主表title指定ID
     */
    private static final Long GROUP_ID = 2L;

    private static final String HRM_DEPARTMENT = "hrmdepartment";


    private static DepartmentMapper getDepartmentMapper() {
        return MapperProxyFactory.getProxy(DepartmentMapper.class);
    }

    private static JobMapper getJobMapper() {
        return MapperProxyFactory.getProxy(JobMapper.class);
    }

    private CompMapper getCompMapper() {
        return MapperProxyFactory.getProxy(CompMapper.class);
    }

    private ExtendTitleMapper getExtendTitleMapper() {
        return MapperProxyFactory.getProxy(ExtendTitleMapper.class);
    }

    private SystemDataMapper getSystemDataMapper() {
        return MapperProxyFactory.getProxy(SystemDataMapper.class);
    }

    private ExtService getExtService(User user) {
        return ServiceUtil.getService(ExtServiceImpl.class, user);
    }


    @Override
    public PageInfo<SingleDeptTreeVO> getDeptListByPid(QuerySingleDeptListParam param) {
        //1.查询分部下所有部门
        //PageUtil.start(param.getCurrent(), param.getPageSize());
        List<DepartmentPO> departmentPOS = MapperProxyFactory.getProxy(DepartmentMapper.class).list("show_order");
        PageInfo<DepartmentPO> pageInfo = new PageInfo<>(departmentPOS);
        List<SingleDeptTreeVO> singleDeptTreeVOS = DepartmentBO.buildSingleDeptTreeVOS(departmentPOS, param.getParentComp());
        PageInfo<SingleDeptTreeVO> pageInfos = new PageInfo<>(singleDeptTreeVOS, SingleDeptTreeVO.class);
        pageInfos.setTotal(pageInfo.getTotal());
        pageInfos.setPageNum(param.getCurrent());
        pageInfos.setPageSize(param.getPageSize());

        return pageInfos;
    }

    @Override
    public PageInfo<SingleJobTreeVO> getJobListByPid(QuerySingleDeptListParam param) {
        List<JobPO> jobPOS = MapperProxyFactory.getProxy(JobMapper.class).listAll();
        PageInfo<JobPO> pageInfo = new PageInfo<>(jobPOS);
        List<SingleJobTreeVO> singleDeptTreeVOS = JobBO.buildSingleJobTreeVOS(jobPOS, param.getParentDept());
        PageInfo<SingleJobTreeVO> pageInfos = new PageInfo<>(singleDeptTreeVOS, SingleJobTreeVO.class);
        pageInfos.setTotal(pageInfo.getTotal());
        pageInfos.setPageNum(param.getCurrent());
        pageInfos.setPageSize(param.getPageSize());
        return pageInfos;
    }


    @Override
    public Map<String, Object> getSearchTree(SearchTreeParams params) {
        String keyword = params.getKeyword();
        String id = params.getId();
        String type = Util.null2String(params.getType());
        List<SearchTree> treeList = getFilterCompany(id, keyword);
        return SearchTreeUtil.getSearchTree(type, treeList);
    }

    @Override
    public Map<String, Object> listPage(DeptSearchParam param) {
        Map<String, Object> datas = new HashMap<>();
        boolean hasRight = HasRightUtil.hasRight(user, RIGHT_NAME, true);
        datas.put("hasRight", hasRight);
        if (!hasRight) {
            return datas;
        }
        DepartmentPO departmentPO = DepartmentBO.convertParamsToPO(param, user.getUID());
        boolean filter = isFilter(departmentPO);
        PageInfo<DepartmentListDTO> pageInfos;
        String orderSql = PageInfoSortUtil.getSortSql(param.getSortParams());
        List<DepartmentPO> allList = getDepartmentMapper().list(orderSql);
        // 通过子级遍历父级元素
        if (filter) {
            // 根据条件获取元素
            List<DepartmentPO> filterDeptPOs = getDepartmentMapper().listByFilter(departmentPO, orderSql);
            // 添加父级元素
            List<DepartmentListDTO> compListDTOS = DepartmentBO.buildDeptDTOList(allList, filterDeptPOs);
            List<DepartmentListDTO> subList = PageUtil.subList(param.getCurrent(), param.getPageSize(), compListDTOS);
            pageInfos = new PageInfo<>(subList, DepartmentListDTO.class);
            pageInfos.setTotal(compListDTOS.size());
        } else {
            // 组合list
            List<DepartmentListDTO> compListDTOS = DepartmentBO.buildDeptDTOList(allList);
            List<DepartmentListDTO> subList = PageUtil.subList(param.getCurrent(), param.getPageSize(), compListDTOS);
            pageInfos = new PageInfo<>(subList, DepartmentListDTO.class);
            pageInfos.setTotal(compListDTOS.size());
        }

        pageInfos.setPageNum(param.getCurrent());
        pageInfos.setPageSize(param.getPageSize());

        OrganizationWeaTable<DepartmentListDTO> table = new OrganizationWeaTable<>(user, DepartmentListDTO.class);
        List<Column> columns = pageInfos.getColumns();
        List<WeaTableColumn> weaTableColumn = columns.stream().map(v -> new WeaTableColumn("100", v.getTitle(), v.getKey())).collect(Collectors.toList());

        table.setColumns(weaTableColumn);

        WeaResultMsg result = new WeaResultMsg(false);
        result.putAll(table.makeDataResult());
        result.success();

        datas.put("pageInfo", pageInfos);
        datas.put("dataKey", result.getResultMap());
        return datas;
    }

    @Override
    public Long saveBaseForm(Map<String, Object> params) {
        HasRightUtil.hasRight(user, RIGHT_NAME, false);
        String deptNo = (String) params.get("dept_no");
        // 判断是否开启自动编号
        deptNo = repeatDetermine(deptNo);
        params.put("dept_no", deptNo);
        if (StringUtils.isBlank(Util.null2String(params.get("show_order")))) {
            Integer maxShowOrder = getDepartmentMapper().getMaxShowOrder();
            if (null == maxShowOrder) {
                maxShowOrder = 0;
            }
            params.put("show_order", maxShowOrder + 1);
        }
        // 上级分部
        String ecCompany = Util.null2String(params.get("ec_company"));
        if (StringUtils.isNotBlank(ecCompany)) {
            CompPO jclCompanyId = EcHrmRelationUtil.getJclCompanyId(ecCompany);
            if (null != jclCompanyId) {
                params.put("parent_comp", jclCompanyId.getId());
            }
        }
        // 上级部门
        String ecDepartment = Util.null2String(params.get("ec_department"));
        if (StringUtils.isNotBlank(ecDepartment)) {
            DepartmentPO jclDepartmentId = EcHrmRelationUtil.getJclDepartmentId(ecDepartment);
            if (null != jclDepartmentId) {
                params.put("parent_dept", jclDepartmentId.getId());
                // 部门不为空，自动指定所属分部
                params.put("parent_comp", jclDepartmentId.getParentComp());
                params.put("ec_company", EcHrmRelationUtil.getEcCompanyId(Util.null2String(jclDepartmentId.getParentComp())));
            }

        }
        Map<String, Object> syncMap = new OrganizationSyncEc(user, LogModuleNameEnum.DEPARTMENT, OperateTypeEnum.ADD, params).sync();
        String ecCompanyID = Util.null2String(syncMap.get("id"));
        OrganizationAssert.isTrue(StringUtils.isNotBlank(ecCompanyID), syncMap.get("message").toString());
        // 查询UUID
        RecordInfo recordInfo = getSystemDataMapper().getHrmObjectByID(HRM_DEPARTMENT, ecCompanyID);
        params.put("uuid", recordInfo.getUuid());
        return getExtService(user).updateExtForm(user, EXTEND_TYPE, JCL_ORG_DEPT, params, "", null);
    }

    @Override
    public int updateForbiddenTagById(DeptSearchParam params) {
        HasRightUtil.hasRight(user, RIGHT_NAME, false);
        DepartmentPO departmentPO = DepartmentPO.builder().id(params.getId()).forbiddenTag(params.getForbiddenTag() ? 0 : 1).build();
        Map<String, Object> map = new HashMap<>();
        map.put("id", departmentPO.getId());
        map.put("forbiddenTag", departmentPO.getForbiddenTag());
        new OrganizationSyncEc(user, LogModuleNameEnum.DEPARTMENT, OperateTypeEnum.CANCELED, map).sync();
        return getDepartmentMapper().updateForbiddenTagById(departmentPO);
    }

    @Override
    public Long updateForm(Map<String, Object> params) {
        HasRightUtil.hasRight(user, RIGHT_NAME, false);
        DeptSearchParam searchParam = JSONObject.parseObject(JSONObject.toJSONString(params), DeptSearchParam.class);
        String groupId = (String) params.get("viewCondition");
        if ("0".equals(groupId)) {
            groupId = GROUP_ID.toString();
        }

        String oldDeptNo = getDepartmentMapper().getDeptById(searchParam.getId()).getDeptNo();
        String deptNo = searchParam.getDeptNo();
        if (!deptNo.equals(oldDeptNo)) {
            deptNo = repeatDetermine(deptNo);
            params.put("dept_no", deptNo);
        }
        // 上级分部
        String ecCompany = Util.null2String(params.get("ec_company"));
        if (StringUtils.isNotBlank(ecCompany)) {
            CompPO jclCompanyId = EcHrmRelationUtil.getJclCompanyId(ecCompany);
            if (null != jclCompanyId) {
                params.put("parent_comp", jclCompanyId.getId());
            }
        }
        // 上级部门
        String ecDepartment = Util.null2String(params.get("ec_department"));
        if (StringUtils.isNotBlank(ecDepartment)) {
            DepartmentPO jclDepartmentId = EcHrmRelationUtil.getJclDepartmentId(ecDepartment);
            if (null != jclDepartmentId) {
                params.put("parent_dept", jclDepartmentId.getId());
                // 部门不为空，自动指定所属分部
                params.put("parent_comp", jclDepartmentId.getParentComp());
                params.put("ec_company", EcHrmRelationUtil.getEcCompanyId(Util.null2String(jclDepartmentId.getParentComp())));
            }

        } else {
            params.put("parent_dept", "");
        }
        new OrganizationSyncEc(user, LogModuleNameEnum.DEPARTMENT, OperateTypeEnum.UPDATE, params).sync();
        // 更新主表数据
        getExtService(user).updateExtForm(user, EXTEND_TYPE, JCL_ORG_DEPT, params, "", searchParam.getId());
        // 更新主表拓展表
        getExtService(user).updateExtForm(user, EXTEND_TYPE, JCL_ORG_DEPTEXT, params, groupId, searchParam.getId());
        //更新明细表
        getExtService(user).updateExtDT(user, EXTEND_TYPE, JCL_ORG_DEPTEXT_DT1, params, searchParam.getId());


        Long parentComp = StringUtils.isNotEmpty(Util.null2String(params.get("parent_comp"))) ? Long.parseLong(Util.null2String(params.get("parent_comp"))) : null;
        // 刷新岗位所属分部
        refreshJobComp(searchParam.getId(), parentComp);
        List<DepartmentPO> childList = getDepartmentMapper().getDeptListByPId(searchParam.getId());
        String ecCompanyId = EcHrmRelationUtil.getEcCompanyId(Util.null2String(parentComp));
        forbiddenChildTag(parentComp, ecCompanyId, childList);

        return searchParam.getId();
    }

    @Override
    public int deleteByIds(Collection<Long> ids) {
        HasRightUtil.hasRight(user, RIGHT_NAME, false);
        OrganizationAssert.notEmpty(ids, "请选择要删除的数据");
        Map<String, Object> map = new HashMap<>();

        for (Long id : ids) {
            map.put("id", id);
            new OrganizationSyncEc(user, LogModuleNameEnum.DEPARTMENT, OperateTypeEnum.CANCELED, map).sync();
            // 删除拓展表、明细表
            MapperProxyFactory.getProxy(ExtMapper.class).deleteByID("jcl_org_deptext", id);
            MapperProxyFactory.getProxy(ExtDTMapper.class).deleteByMainID("jcl_org_deptext_dt1", id);
        }

        return getDepartmentMapper().deleteByIds(ids);
    }

    @Override
    public Map<String, Object> getSearchCondition(Map<String, Object> params) {
        Map<String, Object> apiDatas = new HashMap<>();
        List<SearchConditionGroup> addGroups = new ArrayList<>();
        List<SearchConditionItem> conditionItems = new ArrayList<>();
        // 编号
        SearchConditionItem deptNoItem = OrganizationFormItemUtil.inputItem(user, 2, 16, 2, 50, "编号", "deptNo");
        // 名称
        SearchConditionItem deptNameItem = OrganizationFormItemUtil.inputItem(user, 2, 16, 2, 50, "名称", "departmentName");
        // 简称
        SearchConditionItem deptNameShortItem = OrganizationFormItemUtil.inputItem(user, 2, 16, 2, 50, "简称", "deptNameShort");
        // 所属分部
        SearchConditionItem parentCompBrowserItem = OrganizationFormItemUtil.browserItem(user, 2, 16, 2, false, "所属分部", "164", "ecCompany", "");
        // 上级部门
        SearchConditionItem parentDeptBrowserItem = OrganizationFormItemUtil.browserItem(user, 2, 16, 2, false, "上级部门", "4", "ecDepartment", "");
        // 部门负责人
        SearchConditionItem deptPrincipalBrowserItem = OrganizationFormItemUtil.browserItem(user, 2, 16, 2, false, "部门负责人", "1", "deptPrincipal", "");
        // 显示顺序
        SearchConditionItem showOrderItem = OrganizationFormItemUtil.inputNumberItem(user, 2, 16, 2, "显示顺序", "showOrder");
        // 禁用标记
        List<SearchConditionOption> selectOptions = new ArrayList<>();
        SearchConditionOption enableOption = new SearchConditionOption("true", "启用");
        SearchConditionOption disableOption = new SearchConditionOption("false", "禁用");
        selectOptions.add(enableOption);
        selectOptions.add(disableOption);
        SearchConditionItem forbiddenTagItem = OrganizationFormItemUtil.selectItem(user, selectOptions, 2, 16, 6, false, "禁用标记", "forbiddenTag");

        conditionItems.add(deptNoItem);
        conditionItems.add(deptNameItem);
        conditionItems.add(deptNameShortItem);
        conditionItems.add(parentCompBrowserItem);
        conditionItems.add(parentDeptBrowserItem);
        conditionItems.add(deptPrincipalBrowserItem);
        conditionItems.add(showOrderItem);
        conditionItems.add(forbiddenTagItem);

        addGroups.add(new SearchConditionGroup("高级搜索条件", true, conditionItems));
        apiDatas.put("conditions", addGroups);
        return apiDatas;
    }

    @Override
    public Map<String, Object> getHasRight() {
        return MenuBtn.getDatasHasCopy();
    }

    @Override
    public Map<String, Object> getDeptBaseForm(Map<String, Object> params) {
        OrganizationAssert.notNull(params.get("viewAttr"), "请标识操作类型");

        // 2编辑 1查看
        int viewAttr = Integer.parseInt((String) params.get("viewAttr"));
        long id = Long.parseLong((String) params.get("id"));
        String groupId = (String) params.get("viewCondition");

        HashMap<String, Object> buttonsMap = new HashMap<>();
        buttonsMap.put("hasEdit", true);
        buttonsMap.put("hasSave", true);

        List<SearchConditionGroup> addGroups = new ArrayList<>();

        if ("0".equals(groupId)) {
            groupId = GROUP_ID.toString();
        }
        List<ExtendTitlePO> extendTitles = getExtendTitleMapper().getTitlesByGroupID(Long.parseLong(groupId), "1");
        if (CollectionUtils.isNotEmpty(extendTitles)) {
            for (ExtendTitlePO extendTitle : extendTitles) {
                List<SearchConditionItem> items = getExtService(user).getExtForm(user, EXTEND_TYPE + "", GROUP_ID.equals(Long.parseLong(groupId)) ? JCL_ORG_DEPT : JCL_ORG_DEPTEXT, viewAttr, id, extendTitle.getId().toString(), "");

                if (CollectionUtils.isNotEmpty(items)) {
                    addGroups.add(new SearchConditionGroup(extendTitle.getTitle(), true, items));
                }
            }
        }

        HashMap<String, Object> resultMap = new HashMap<>();
        resultMap.put("buttons", buttonsMap);
        resultMap.put("conditions", addGroups);
        resultMap.put("id", id);
        // 拓展页面分组
        resultMap.put("tabInfo", getExtService(user).getTabInfo(EXTEND_TYPE, JCL_ORG_DEPTEXT));
        // 处理明细表
        resultMap.put("tables", getExtService(user).getExtendTables(user, EXTEND_TYPE, Long.parseLong(groupId), JCL_ORG_DEPTEXT_DT1, id, viewAttr, false));
        Map<String, Object> apiDatas = new HashMap<>();

        apiDatas.put("result", resultMap);

        return apiDatas;
    }

    @Override
    public Map<String, Object> getSaveForm(DeptSearchParam param) {
        HasRightUtil.hasRight(user, RIGHT_NAME, false);
        Map<String, Object> apiDatas = new HashMap<>();
        List<SearchConditionGroup> addGroups = new ArrayList<>();
        List<ExtendTitlePO> extendTitles = getExtendTitleMapper().getTitlesByGroupID(GROUP_ID, "1");
        if (CollectionUtils.isNotEmpty(extendTitles)) {
            Map<String, Object> params = new HashMap<>();
            // 分部
            if (StringUtils.isNotBlank(Util.null2String(param.getSubcompanyid1()))) {
                CompPO compPO = getCompMapper().listById(param.getSubcompanyid1());
                if (null != compPO) {
                    params.put("parent_comp", compPO.getId());
                    params.put("ec_company", EcHrmRelationUtil.getEcCompanyId(compPO.getId().toString()));
                }
            }
            // 部门
            if (StringUtils.isNotBlank(Util.null2String(param.getDepartmentid()))) {
                DepartmentPO deptById = getDepartmentMapper().getDeptById(param.getDepartmentid());
                if (null != deptById) {
                    params.put("parent_dept", deptById.getId());
                    params.put("ec_department", EcHrmRelationUtil.getEcDepartmentId(deptById.getId().toString()));
                    params.put("parent_comp", deptById.getParentComp());
                    params.put("ec_company", EcHrmRelationUtil.getEcCompanyId(deptById.getParentComp().toString()));
                }
            }
            for (ExtendTitlePO extendTitle : extendTitles) {
                List<SearchConditionItem> items = getExtService(user).getExtSaveForm(user, EXTEND_TYPE + "", JCL_ORG_DEPT, 2, extendTitle.getId().toString(), "dept_no", RuleCodeType.DEPARTMENT.getValue(), params);
                if (CollectionUtils.isNotEmpty(items)) {
                    addGroups.add(new SearchConditionGroup(extendTitle.getTitle(), true, items));
                }
            }
        }
        apiDatas.put("condition", addGroups);
        return apiDatas;
    }

    /**
     * 复制表单
     *
     * @return
     */
    @Override
    public List<SearchConditionGroup> getCopyForm() {
        List<SearchConditionGroup> addGroups = new ArrayList<>();
        List<SearchConditionItem> condition = new ArrayList<>();
        SearchConditionItem compBrowserItem = OrganizationFormItemUtil.browserItem(user, 2, 16, 3, false, "复制到", "164", "company", "");
        compBrowserItem.setRules("required|string");
        List<SearchConditionOption> selectOptions = new ArrayList<>();
        SearchConditionOption Option = new SearchConditionOption("1", "");
        selectOptions.add(Option);
        SearchConditionItem isCheckItem = OrganizationFormItemUtil.selectItem(user, selectOptions, 2, 5, 10, false, "是否复制岗位信息", "copyJob");
        isCheckItem.setDetailtype(2);
        condition.add(compBrowserItem);
        condition.add(isCheckItem);
        addGroups.add(new SearchConditionGroup("", true, condition));
        return addGroups;
    }

    /**
     * 复制岗位到指定部门
     *
     * @param copyParam
     * @return
     */
    @Override
    public int copyDepartment(DeptCopyParam copyParam) {
        // TODO  是否复制子部门信息，是否复制子部门岗位信息
        HasRightUtil.hasRight(user, RIGHT_NAME, false);
        OrganizationAssert.notBlank(copyParam.getCompany(), "请指定需要复制的公司/分部");
        int insertCount = 0;
        List<Long> idList = Arrays.stream(copyParam.getIds().split(",")).map(Long::parseLong).collect(Collectors.toList());
        Integer maxShowOrder = getDepartmentMapper().getMaxShowOrder();
        maxShowOrder = null == maxShowOrder ? 0 : maxShowOrder;
        for (int i = 0; i < idList.size(); i++) {
            DepartmentPO deptById = getDepartmentMapper().getDeptById(idList.get(i));
            long timeMillis = System.currentTimeMillis();
            deptById.setDeptName(deptById.getDeptName() + "_" + timeMillis);
            deptById.setDeptNameShort(deptById.getDeptNameShort());
            // 处理自动编号
            deptById.setDeptNo(CodeRuleUtil.generateCode(RuleCodeType.DEPARTMENT, deptById.getDeptNo(), timeMillis));
            deptById.setParentComp(EcHrmRelationUtil.getJclCompanyId(copyParam.getCompany()).getId());
            deptById.setEcCompany(Long.parseLong(copyParam.getCompany()));
            deptById.setParentDept(null);
            // 显示顺序字段
            deptById.setShowOrder(maxShowOrder + i + 1);
            deptById.setCreateTime(new Date());
            // 新增EC表部门
            Map<String, Object> syncMap = addEcDepartment(deptById);
            String ecDepartmentID = Util.null2String(syncMap.get("id"));
            OrganizationAssert.isTrue(StringUtils.isNotBlank(ecDepartmentID), syncMap.get("message").toString());
            // 查询UUID
            RecordInfo recordInfo = getSystemDataMapper().getHrmObjectByID(HRM_DEPARTMENT, ecDepartmentID);
            deptById.setUuid(recordInfo.getUuid());
            insertCount += getDepartmentMapper().insertIgnoreNull(deptById);
            // 更新组织架构图
            new Thread(new DepartmentTriggerRunnable(deptById.getId())).start();

            //  新增岗位信息
            if ("1".equals(copyParam.getCopyJob())) {
                List<JobPO> jobPOS = MapperProxyFactory.getProxy(JobMapper.class).listJobsByDepartmentId(idList.get(i));
                Integer maxJobOrder = MapperProxyFactory.getProxy(JobMapper.class).getMaxShowOrder();
                if (maxJobOrder == null) {
                    maxJobOrder = 0;
                }
                recursionCopyJob((long) user.getUID(), jobPOS, deptById.getParentComp(), deptById.getId(), maxJobOrder, timeMillis);
            }
        }
        return insertCount;
    }

    @Override
    public List<SearchConditionGroup> getMergeForm(Long id) {
        List<SearchConditionGroup> addGroups = new ArrayList<>();
        List<SearchConditionItem> condition = new ArrayList<>();
        SearchConditionItem deptBrowserItem = OrganizationFormItemUtil.browserItem(user, 2, 16, 3, false, "合并到部门", "4", "department", "");
        deptBrowserItem.setRules("required|string");
        SearchConditionItem mergeNameItem = OrganizationFormItemUtil.inputItem(user, 2, 16, 3, 50, "合并后名称", "mergeName");
        mergeNameItem.setRules("required|string");
        String departmentName = getDepartmentMapper().getDeptNameById(id);
        mergeNameItem.setValue(departmentName);

        condition.add(deptBrowserItem);
        condition.add(mergeNameItem);
        addGroups.add(new SearchConditionGroup("", true, condition));
        return addGroups;
    }

    @Override
    public int mergeDepartment(DepartmentMergeParam mergeParam) {
        HasRightUtil.hasRight(user, RIGHT_NAME, false);
        // 被合并部门
        Long ecParamDepartment = mergeParam.getDepartment();
        DepartmentPO targetDepartment = EcHrmRelationUtil.getJclDepartmentId( Util.null2String(ecParamDepartment));

        // 断言判断
        OrganizationAssert.isFalse(null == targetDepartment, "被合并部门数据有误，暂时无法合并");
        OrganizationAssert.isFalse(mergeParam.getId().equals(targetDepartment.getId()), "所选部门与待合并部门一致，无需操作");
        OrganizationAssert.notNull(mergeParam.getDepartment(), "请选择需要合并的部门");
        OrganizationAssert.notBlank(mergeParam.getMergeName(), "请输入合并后的名称");

        // 不可选择合并的数据，本身及子部门
        Set<Long> disableIds = new HashSet<>();
        // 添加选择部门本身
        disableIds.add(mergeParam.getId());
        List<DepartmentPO> deptListByPId = getDepartmentMapper().getDeptListByPId(mergeParam.getId());
        if (CollectionUtils.isNotEmpty(deptListByPId)) {
            addDisableIds(disableIds, deptListByPId);
        }
        OrganizationAssert.isFalse(disableIds.contains(targetDepartment.getId()), "请勿选择当前部门本身及其子部门");

        // 查询该部门下一级部门
        List<DepartmentPO> firstChildDeptList = getDepartmentMapper().getDeptListByPId(mergeParam.getId());
        // 更新所属部门、所属分部
        for (DepartmentPO departmentPO : firstChildDeptList) {
            departmentPO.setParentDept(targetDepartment.getId());
            departmentPO.setEcDepartment(ecParamDepartment);
            departmentPO.setParentComp(targetDepartment.getParentComp());
            departmentPO.setEcCompany(targetDepartment.getEcCompany());
            updateEcDepartment(departmentPO);
            getDepartmentMapper().updateBaseDept(departmentPO);
            // 更新组织架构图
            new Thread(new DepartmentTriggerRunnable(departmentPO.getId())).start();
        }
        // 查询该部门一级岗位、更新岗位所属分部、所属部门
        List<JobPO> firstChildJobList = getJobMapper().listJobsByDepartmentId(mergeParam.getId());
        // 批量更新部门、所属分部
        RecordSet rs = new RecordSet();
        String targetEcDeptId = EcHrmRelationUtil.getEcDepartmentId(targetDepartment.getId().toString());
        String mergeEcDeptId = EcHrmRelationUtil.getEcDepartmentId(mergeParam.getId().toString());
        rs.executeUpdate("update jcl_org_job set parent_comp =?,ec_company =?,parent_dept =?,ec_department =? where parent_dept =?", targetDepartment.getParentComp(), targetDepartment.getEcCompany(), targetDepartment.getId(), targetEcDeptId, mergeParam.getId());
        // 更新岗位组织架构图
        for (JobPO jobPO : firstChildJobList) {
            // 刷新组织架构图
            new Thread(new JobTriggerRunnable(jobPO.getId())).start();
        }
        // 更新当前部门下的人员
        List<Long> hrmResourceIds = getSystemDataMapper().getHrmResourceIdsByDept(mergeEcDeptId);
        rs.executeUpdate("update hrmresource set SUBCOMPANYID1 =?,DEPARTMENTID =? where DEPARTMENTID =?", targetDepartment.getEcCompany(), targetEcDeptId, mergeEcDeptId);
        // 更新人员组织架构图
        for (Long hrmResourceId : hrmResourceIds) {
            new Thread(new HrmResourceTriggerRunnable(hrmResourceId)).start();
        }
        // 更新子部门下岗位的所属分部
        for (DepartmentPO departmentPO : firstChildDeptList) {
            List<DepartmentPO> deptList = getDepartmentMapper().getDeptListByPId(departmentPO.getId());
            forbiddenChildTag(targetDepartment.getParentComp(), Util.null2String(targetDepartment.getEcCompany()), deptList);
        }
        // 原部门删除
        DepartmentPO mergeDepartment = getDepartmentMapper().getDeptById(mergeParam.getId());
        Map<String, Object> map = new HashMap<>();
        map.put("id", mergeParam.getId());
        new OrganizationSyncEc(user, LogModuleNameEnum.DEPARTMENT, OperateTypeEnum.CANCELED, map).sync();
        // 删除拓展表、明细表
        MapperProxyFactory.getProxy(ExtMapper.class).deleteByID("jcl_org_deptext", mergeParam.getId());
        MapperProxyFactory.getProxy(ExtDTMapper.class).deleteByMainID("jcl_org_deptext_dt1", mergeParam.getId());
        getDepartmentMapper().deleteByIds(DeleteParam.builder().ids(mergeParam.getId().toString()).build().getIds());
        // 更新组织架构图
        new Thread(new DepartmentTriggerRunnable(mergeDepartment)).start();
        // 更新部门合并后名称
        targetDepartment.setDeptName(mergeParam.getMergeName());
        targetDepartment.setDeptNameShort(mergeParam.getMergeName());
        updateEcDepartment(targetDepartment);
        getDepartmentMapper().updateBaseDept(targetDepartment);
        // 更新组织架构图
        new Thread(new DepartmentTriggerRunnable(targetDepartment.getId())).start();
        return 0;
    }

    @Override
    public List<SearchConditionGroup> getMoveForm() {
        List<SearchConditionGroup> addGroups = new ArrayList<>();
        List<SearchConditionItem> condition = new ArrayList<>();
        SearchConditionItem compBrowserItem = OrganizationFormItemUtil.browserItem(user, 2, 16, 2, false, "选择分部", "164", "company", "");
        SearchConditionItem deptBrowserItem = OrganizationFormItemUtil.browserItem(user, 2, 16, 2, false, "选择部门", "4", "department", "");


        List<SearchConditionOption> selectOptions = new ArrayList<>();
        SearchConditionOption compOption = new SearchConditionOption("0", "分部");
        SearchConditionOption deptOption = new SearchConditionOption("1", "部门");
        selectOptions.add(compOption);
        selectOptions.add(deptOption);
        SearchConditionItem moveTypeItem = OrganizationFormItemUtil.selectItem(user, selectOptions, 2, 16, 6, false, "转移到", "moveType");
        moveTypeItem.setDetailtype(3);
        moveTypeItem.setValue("0");

        condition.add(moveTypeItem);
        condition.add(compBrowserItem);
        condition.add(deptBrowserItem);
        addGroups.add(new SearchConditionGroup("", true, condition));
        return addGroups;
    }

    @Override
    public int moveDepartment(DepartmentMoveParam moveParam) {
        HasRightUtil.hasRight(user, RIGHT_NAME, false);
        OrganizationAssert.notBlank(moveParam.getMoveType(), "请选择转移类型");
        DepartmentPO deptById = getDepartmentMapper().getDeptById(moveParam.getId());
        // 0：公司/分部 1：部门
        if ("0".equals(moveParam.getMoveType())) {
            Long company = moveParam.getCompany();
            OrganizationAssert.notNull(company, "请选择要转移到的分部");
            deptById.setEcCompany(company);
            deptById.setParentComp(Objects.requireNonNull(EcHrmRelationUtil.getJclCompanyId( Util.null2String(company))).getId());
            deptById.setParentDept(null);
        } else if ("1".equals(moveParam.getMoveType())) {
            Long department = moveParam.getDepartment();
            Long departmentId = Objects.requireNonNull(EcHrmRelationUtil.getJclDepartmentId( Util.null2String(department))).getId();
            OrganizationAssert.notNull(departmentId, "请选择要转移到的部门");
            List<DepartmentPO> deptListByPId = getDepartmentMapper().getDeptListByPId(moveParam.getId());
            Set<Long> disableIds = new HashSet<>();
            disableIds.add(moveParam.getId());
            if (CollectionUtils.isNotEmpty(deptListByPId)) {
                addDisableIds(disableIds, deptListByPId);
            }
            OrganizationAssert.isFalse(disableIds.contains(departmentId), "请勿选择当前部门本身及其子部门");
            deptById.setParentDept(departmentId);
            deptById.setEcDepartment(department);
            DepartmentPO parentDepartment = getDepartmentMapper().getDeptById(departmentId);
            deptById.setParentComp(parentDepartment.getParentComp());
        }
        // 更新EC部门
        updateEcDepartment(deptById);
        int updateBaseDept = getDepartmentMapper().updateBaseDept(deptById);
        // 更新组织架构图
        new Thread(new DepartmentTriggerRunnable(deptById.getId())).start();
        // 刷新岗位分部
        refreshJobComp(deptById.getId(), deptById.getParentComp());
        List<DepartmentPO> deptList = getDepartmentMapper().getDeptListByPId(deptById.getId());
        String ecCompanyId = EcHrmRelationUtil.getEcCompanyId(Util.null2String(deptById.getParentComp()));
        forbiddenChildTag(deptById.getParentComp(), ecCompanyId, deptList);
        // 递归更新下级部门、岗位
        return updateBaseDept;
    }

    /**
     * 获取所有子部门id
     *
     * @param parentComp
     * @param deptList
     */
    void forbiddenChildTag(Long parentComp, String ecCompanyId, List<DepartmentPO> deptList) {
        if (CollectionUtils.isNotEmpty(deptList)) {
            for (DepartmentPO departmentPO : deptList) {
                departmentPO.setParentComp(parentComp);
                departmentPO.setEcCompany(Long.parseLong(ecCompanyId));
                // 更新EC表部门
                updateEcDepartment(departmentPO);

                getDepartmentMapper().updateBaseDept(departmentPO);
                // 更新组织架构图
                new Thread(new DepartmentTriggerRunnable(departmentPO.getId())).start();
                // 刷新岗位所属分部
                refreshJobComp(departmentPO.getId(), parentComp);
                // 更新当前部门下的人员
                List<Long> hrmResourceIds = getSystemDataMapper().getHrmResourceIdsByDept(departmentPO.getId().toString());
                String ecDepartmentId = EcHrmRelationUtil.getEcDepartmentId(departmentPO.getId().toString());
                new RecordSet().executeUpdate("update hrmresource set SUBCOMPANYID1 =?  where DEPARTMENTID =?", ecCompanyId, ecDepartmentId);
                // 更新人员组织架构图
                for (Long hrmResourceId : hrmResourceIds) {
                    new Thread(new HrmResourceTriggerRunnable(hrmResourceId)).start();
                }
                List<DepartmentPO> childList = getDepartmentMapper().getDeptListByPId(departmentPO.getId());
                forbiddenChildTag(parentComp, ecCompanyId, childList);
            }
        }
    }

    /**
     * 是否为搜索查询
     *
     * @param departmentPO
     * @return
     */
    private boolean isFilter(DepartmentPO departmentPO) {
        return !(StringUtil.isEmpty(departmentPO.getDeptNo())
                && StringUtil.isEmpty(departmentPO.getDeptName())
                && StringUtil.isEmpty(departmentPO.getDeptNameShort())
                && null == departmentPO.getEcCompany()
                && null == departmentPO.getEcDepartment()
                && null == departmentPO.getParentComp()
                && null == departmentPO.getParentDept()
                && null == departmentPO.getDeptPrincipal()
                && null == departmentPO.getShowOrder()
                && null == departmentPO.getForbiddenTag());
    }


    /**
     * 根据keyword查询数据
     *
     * @param id
     * @param keyword
     * @return
     */
    private List<SearchTree> getFilterCompany(String id, String keyword) {
        // 查询部门信息
        Long parentCompId = StringUtil.isEmpty(id) ? null : Long.parseLong(id);
        CompPO compBuild = CompPO.builder().compName(keyword).parentCompany(parentCompId).forbiddenTag(0).build();
        List<CompPO> filterComps = getCompMapper().listByFilter(compBuild, "show_order");

        Set<CompPO> builderComps = new HashSet<>();
        for (CompPO compPO : filterComps) {
            buildParentComps(compPO, builderComps);
        }
        return SearchTreeUtil.builderTreeMode(CompBO.buildSetToSearchTree(builderComps));

    }

    /**
     * 添加查询元素的父级元素
     *
     * @param compPO
     * @param builderComps
     */
    private void buildParentComps(CompPO compPO, Set<CompPO> builderComps) {
        builderComps.add(compPO);
        if (SearchTreeUtil.isTop(compPO.getParentCompany())) {
            return;
        }
        CompPO parentComp = getCompMapper().listById(compPO.getParentCompany());
        if (null != parentComp && 0 == parentComp.getForbiddenTag()) {
            buildParentComps(parentComp, builderComps);
        }
    }

    /**
     * 判断编号是否重复
     *
     * @return
     */
    public static String repeatDetermine(String deptNo) {
        CodeRulePO codeRuleByType = MapperProxyFactory.getProxy(CodeRuleMapper.class).getCodeRuleByType(RuleCodeType.DEPARTMENT.getValue());
        if (StringUtils.isNotBlank(deptNo)) {
            deptNo = CodeRuleUtil.generateCode(RuleCodeType.DEPARTMENT, deptNo);
            List<DepartmentPO> list = getDepartmentMapper().listByNo(Util.null2String(deptNo));
            OrganizationAssert.isEmpty(list, "编号不允许重复");
        } else {
            if (null != codeRuleByType && "1".equals(codeRuleByType.getSerialEnable())) {
                deptNo = autoCreateCompanyNo();
            }
        }
        return deptNo;
    }

    /**
     * 自动编号处理
     *
     * @return
     */
    private static String autoCreateCompanyNo() {
        String generateCode = CodeRuleUtil.generateCode(RuleCodeType.DEPARTMENT, "");
        List<DepartmentPO> list = getDepartmentMapper().listByNo(Util.null2String(generateCode));
        if (CollectionUtils.isNotEmpty(list)) {
            generateCode = autoCreateCompanyNo();
        }
        return generateCode;
    }

    /**
     * 递归复制岗位信息
     *
     * @param creator
     * @param jobPOS
     * @param parentCompId
     * @param parentDeptId
     * @param orderNum
     */
    private void recursionCopyJob(Long creator, List<JobPO> jobPOS, Long parentCompId, Long parentDeptId, int orderNum, long timeMillis) {
        for (JobPO jobPO : jobPOS) {
            orderNum++;
            // 处理自动编号
            jobPO.setJobNo(CodeRuleUtil.generateCode(RuleCodeType.JOBTITLES, jobPO.getJobNo(), timeMillis));
            jobPO.setParentDept(parentDeptId);
            jobPO.setCreator(creator);
            jobPO.setCreateTime(new Date());
            jobPO.setParentComp(parentCompId);
            jobPO.setShowOrder(orderNum);
            MapperProxyFactory.getProxy(JobMapper.class).insertIgnoreNull(jobPO);
            // 更新组织架构图
            new Thread(new JobTriggerRunnable(jobPO.getId())).start();
            // 处理子级元素
            List<JobPO> jobsByPid = MapperProxyFactory.getProxy(JobMapper.class).getJobsByPid(jobPO.getId());
            if (CollectionUtils.isNotEmpty(jobsByPid)) {
                recursionCopyJob(creator, jobsByPid, parentCompId, parentDeptId, orderNum, timeMillis);
            }
        }
    }

    /**
     * 更新EC表部门
     *
     * @param departmentPO
     */
    private void updateEcDepartment(DepartmentPO departmentPO) {
        Map<String, Object> map = new HashMap<>();
        map.put("dept_name_short", departmentPO.getDeptNameShort());
        map.put("dept_name", departmentPO.getDeptName());
        map.put("parent_comp", departmentPO.getParentComp());
        map.put("parent_dept", departmentPO.getParentDept());
        map.put("show_order", departmentPO.getShowOrder());
        map.put("dept_no", departmentPO.getDeptNo());
        map.put("dept_principal", departmentPO.getDeptPrincipal());
        map.put("id", departmentPO.getId());
        new OrganizationSyncEc(user, LogModuleNameEnum.DEPARTMENT, OperateTypeEnum.UPDATE, map).sync();
    }

    /**
     * 新增EC表部门
     *
     * @param departmentPO
     * @return
     */
    private Map<String, Object> addEcDepartment(DepartmentPO departmentPO) {
        Map<String, Object> map = new HashMap<>();
        map.put("dept_name_short", departmentPO.getDeptNameShort());
        map.put("dept_name", departmentPO.getDeptName());
        map.put("parent_comp", departmentPO.getParentComp());
        map.put("parent_dept", departmentPO.getParentDept());
        map.put("show_order", departmentPO.getShowOrder());
        map.put("dept_no", departmentPO.getDeptNo());
        map.put("dept_principal", departmentPO.getDeptPrincipal());
        map.put("id", departmentPO.getId());
        return new OrganizationSyncEc(user, LogModuleNameEnum.DEPARTMENT, OperateTypeEnum.ADD, map).sync();
    }

    /**
     * 封存EC表部门
     *
     * @param id
     */
    private void cancelEcDepartment(Long id) {
        Map<String, Object> map = new HashMap<>();
        map.put("id", id);
        map.put("forbiddenTag", 1);
        new OrganizationSyncEc(user, LogModuleNameEnum.DEPARTMENT, OperateTypeEnum.CANCELED, map).sync();
    }

    private void addDisableIds(Set<Long> disableIds, List<DepartmentPO> deptListByPId) {
        for (DepartmentPO departmentPO : deptListByPId) {
            disableIds.add(departmentPO.getId());
            List<DepartmentPO> childDeptPOS = getDepartmentMapper().getDeptListByPId(departmentPO.getId());
            addDisableIds(disableIds, childDeptPOS);
        }
    }

    /**
     * 更新岗位的所属分部
     *
     * @param parentDepartment
     * @param parentComp
     */
    private void refreshJobComp(Long parentDepartment, Long parentComp) {
        List<JobPO> jobPOS = getJobMapper().listJobsByDepartmentId(parentDepartment);
        if (CollectionUtils.isNotEmpty(jobPOS)) {
            String ecCompanyId = EcHrmRelationUtil.getEcCompanyId(parentComp.toString());
            getJobMapper().updateJobCompany(jobPOS.stream().map(JobPO::getId).collect(Collectors.toList()), parentComp, ecCompanyId);
            for (JobPO jobPO : jobPOS) {
                // 刷新组织架构图
                new Thread(new JobTriggerRunnable(jobPO.getId())).start();
            }
        }
    }

}