package com.gkhy.safePlatform.specialWork.service.impl; import cn.hutool.core.util.IdUtil; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.gkhy.safePlatform.account.rpc.apimodel.AccountDepartmentService; import com.gkhy.safePlatform.account.rpc.apimodel.AccountUserService; import com.gkhy.safePlatform.account.rpc.apimodel.model.resp.DepInfoRPCRespDTO; import com.gkhy.safePlatform.account.rpc.apimodel.model.resp.UserInfoRPCRespDTO; import com.gkhy.safePlatform.commons.co.ContextCacheUser; import com.gkhy.safePlatform.commons.enums.E; import com.gkhy.safePlatform.commons.enums.ResultCodes; import com.gkhy.safePlatform.commons.exception.AusinessException; import com.gkhy.safePlatform.commons.exception.BusinessException; import com.gkhy.safePlatform.commons.query.PageQuery; import com.gkhy.safePlatform.commons.utils.RequestContextHolder; import com.gkhy.safePlatform.commons.vo.ResultVO; import com.gkhy.safePlatform.commons.vo.SearchResultVO; import com.gkhy.safePlatform.specialWork.entity.ApprovalRule; import com.gkhy.safePlatform.specialWork.entity.ApprovalRuleStep; import com.gkhy.safePlatform.specialWork.entity.ApprovalRuleUnit; import com.gkhy.safePlatform.specialWork.enums.ApprovalStepPersonTypeEnum; import com.gkhy.safePlatform.specialWork.enums.RuleContinueTimeUnitEnum; import com.gkhy.safePlatform.specialWork.enums.WorkTypeEnum; import com.gkhy.safePlatform.specialWork.model.bo.ApprovalRuleBO; import com.gkhy.safePlatform.specialWork.model.dto.req.*; import com.gkhy.safePlatform.specialWork.entity.*; import com.gkhy.safePlatform.specialWork.enums.*; import com.gkhy.safePlatform.specialWork.model.dto.resp.ApprovalRuleRespDTO; import com.gkhy.safePlatform.specialWork.model.dto.resp.ApprovalRuleStepRespDTO; import com.gkhy.safePlatform.specialWork.model.dto.resp.ApprovalRuleUnitItemRespDTO; import com.gkhy.safePlatform.specialWork.model.dto.resp.ApprovalRuleUnitRespDTO; import com.gkhy.safePlatform.specialWork.model.query.db.*; import com.gkhy.safePlatform.specialWork.service.RuleService; import com.gkhy.safePlatform.specialWork.service.baseService.*; import org.apache.dubbo.config.annotation.DubboReference; import org.redisson.api.RLock; import org.redisson.api.RedissonClient; import org.springframework.beans.BeanUtils; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import java.security.Guard; import java.time.LocalDateTime; import java.util.*; import java.util.concurrent.TimeUnit; import java.util.stream.Collectors; @Service("ruleService") public class RuleServiceImpl implements RuleService { @DubboReference private AccountDepartmentService accountDepartmentService; @DubboReference private AccountUserService accountUserService; @Autowired private ApprovalRuleService approvalRuleService; @Autowired private ApprovalRuleStepService approvalRuleStepService; @Autowired private ApprovalRuleUnitItemService approvalRuleUnitItemService; @Autowired private ApprovalRuleUnitService approvalRuleUnitService; @Autowired private ApprovalRuleStandService approvalRuleStandService; @Autowired private ApprovalRuleItemMeasureService approvalRuleItemMeasureService; @Autowired private RedissonClient redissonClient; @Override @Transactional public ResultVO save(ApprovalRuleAddReqDTO ruleReqDTO) { //加分布式锁,防止重复创建规则 RLock lock = redissonClient.getLock("LOCK_RULE_INSERT"); try { lock.lock(10, TimeUnit.SECONDS); // 部门验证 DepInfoRPCRespDTO depInfoByDepId = getDepInfoByDepId(ruleReqDTO.getDepId()); // 作业类型验证 WorkTypeEnum workType = WorkTypeEnum.parse(ruleReqDTO.getWorkType()); if(workType == null){ throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"作业类型不合法"); } // 作业等级验证 // 是否是特殊作业 boolean specialWork = this.isSpecialWork(workType); WorkLevelEnum workLevel = WorkLevelEnum.parse(ruleReqDTO.getWorkLevel()); if (specialWork) { // 检查等级 不能是无等级 if (workLevel == null || workLevel == WorkLevelEnum.DEFAULT) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"特殊作业需要作业等级"); } }else{ // 不是特殊作业默认无等级 workLevel = WorkLevelEnum.DEFAULT; } // 同一个部门下审批规则有且仅有一个 // 验证该部门下是否创建审批流程 ApprovalRuleListDbQuery query = new ApprovalRuleListDbQuery(); query.setDepId(ruleReqDTO.getDepId()); query.setWorkType(ruleReqDTO.getWorkType()); query.setWorkLevel(workLevel.getLevel()); // todo 改成count List ruleList = approvalRuleService.listRule(query); if (ruleList.size() > 0) { throw new AusinessException(E.DATA_DATABASE_EXIST, "该部门下该项已存在,不可重复"); } // 层级 List stepReqDTOList = ruleReqDTO.getStepList(); if (stepReqDTOList == null || stepReqDTOList.size() == 0) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "至少存在一个审批层级"); } List userList; List measureList; List standList; // 循环出数据用于后面验证 List uIdList = new ArrayList<>(); Set mIdList = new HashSet<>(); Set sIdList = new HashSet<>(); stepReqDTOList.forEach(step -> { //单元 List units = step.getUnitList(); if (null != units && units.size() > 0) { units.forEach(unit -> { uIdList.add(unit.getBindUid()); }); } //审批项 List items = step.getItemList(); if (null != items && items.size() > 0) { items.forEach(item -> { if (null != item.getMeasureId()) { mIdList.add(item.getMeasureId()); } if (null != item.getStandId()) { sIdList.add(item.getStandId()); } }); } }); // 用于后面验证 measureList = new ArrayList<>(mIdList.size()); standList = new ArrayList<>(sIdList.size()); userList = listAccountUsers(uIdList); if (mIdList.size() > 0) { measureList = approvalRuleItemMeasureService.listItemMeasureByIds(mIdList); } if (sIdList.size() > 0) { standList = approvalRuleStandService.listItemStandByIds(sIdList); } // 0.层级排序 // 1.八大作业都有监护人层级 // 2.动火作业 和 受限弓箭 需要分析人层级 checkRuleStepValid(workType, stepReqDTOList, userList, standList, measureList); ContextCacheUser currentUser = RequestContextHolder.contextUserLocal.get(); // exc // rule ApprovalRule rule = new ApprovalRule(); rule.setRuleId(IdUtil.getSnowflake(0,0).nextId()); rule.setDepId(ruleReqDTO.getDepId()); rule.setRuleName(ruleReqDTO.getRuleName()); rule.setWorkType(ruleReqDTO.getWorkType()); rule.setWorkLevel(workLevel.getLevel()); rule.setCreateUid(currentUser.getUid()); rule.setCreateUname(currentUser.getUsername()); // 上一层 id Long preStepId = null; // 层级List List saveStepList = new ArrayList<>(stepReqDTOList.size()); // 单元List List saveUnitList = new ArrayList<>(); // 审批项List List saveUnitItemList = new ArrayList<>(); for (ApprovalRuleStepAddReqDTO stepReqDTO : stepReqDTOList) { // 填充层级 ApprovalRuleStep step = new ApprovalRuleStep(); // 填充规则id step.setStepId(IdUtil.getSnowflake(0, 0).nextId()); step.setRuleId(rule.getRuleId()); step.setStepName(stepReqDTO.getStepName()); step.setStepSerial(stepReqDTO.getStepSerial()); step.setApprovalType(stepReqDTO.getApprovalType()); step.setPersonType(stepReqDTO.getPersonType()); step.setContentType(stepReqDTO.getContentType()); step.setGmtCreate(LocalDateTime.now()); step.setStatus(RuleStepStatusEnum.VALID.getCode()); step.setCreateUname(currentUser.getUsername()); step.setCreateUid(currentUser.getUid()); step.setAuditType(stepReqDTO.getAuditType()); step.setPreStepId(preStepId); if (stepReqDTO.getPersonType().equals(ApprovalStepPersonTypeEnum.TYPE_ANALYST.getType())) { // 分析人 标准 step.setContinueTime(stepReqDTO.getContinueTime()); step.setContinueTimeUnit(stepReqDTO.getContinueTimeUnit()); } saveStepList.add(step); preStepId = step.getStepId(); //单元 List unitReqDTOList = stepReqDTO.getUnitList(); //遍历审批单元 for (ApprovalRuleUnitAddReqDTO unitReqDTO : unitReqDTOList) { // 筛选用户 List uList = userList.stream() .filter(user -> user.getUid().equals(unitReqDTO.getBindUid())) .collect(Collectors.toList()); //填充单元数据 ApprovalRuleUnit unit = new ApprovalRuleUnit(); unit.setUnitId(IdUtil.getSnowflake(0, 0).nextId()); unit.setRuleId(rule.getRuleId()); unit.setStepId(step.getStepId()); unit.setBindDepId(ruleReqDTO.getDepId()); unit.setBindDepName(depInfoByDepId.getDepName()); unit.setBindUid(unitReqDTO.getBindUid()); unit.setBindUname(uList.get(0).getUsername()); unit.setGmtCreate(LocalDateTime.now()); unit.setStatus(RuleUnitStatusEnum.VALID.getCode()); unit.setCreateUid(currentUser.getUid()); unit.setCreateUname(currentUser.getUsername()); saveUnitList.add(unit); } // 审批项 List itemReqDTOList = stepReqDTO.getItemList(); //遍历审批项 if (itemReqDTOList != null && itemReqDTOList.size() > 0) { for (ApprovalRuleUnitItemAddReqDTO item : itemReqDTOList) { // 填充审批项数据 ApprovalRuleUnitItem itemVo = new ApprovalRuleUnitItem(); itemVo.setId(IdUtil.getSnowflake(0, 0).nextId()); itemVo.setItemName(item.getItemName()); itemVo.setRuleId(rule.getRuleId()); itemVo.setStepId(step.getStepId()); itemVo.setType(item.getType()); itemVo.setStatus(RuleItemStatusEnum.VALID.getCode()); itemVo.setGmtCreate(LocalDateTime.now()); itemVo.setCreateUid(currentUser.getUid()); itemVo.setCreateUname(currentUser.getUsername()); // 是否分析人审批 if (stepReqDTO.getPersonType().equals(ApprovalStepPersonTypeEnum.TYPE_ANALYST.getType())) { // 分析人 标准 itemVo.setStandId(item.getStandId()); } else { // 安全措施 itemVo.setMeasureId(item.getMeasureId()); } saveUnitItemList.add(itemVo); } } } // 插入规则 approvalRuleService.saveOneRule(rule); // 批量插入层级 if (saveStepList.size() > 0) { approvalRuleStepService.saveStepList(saveStepList); } // 批量插入单元 if (saveUnitList.size() > 0) { approvalRuleUnitService.saveUnitList(saveUnitList); } // 批量插入审批项 if (saveUnitItemList.size() > 0) { approvalRuleUnitItemService.batchSaveItemList(saveUnitItemList); } //创建成功,释放锁 lock.unlock(); }catch (AusinessException e) { e.printStackTrace(); throw new AusinessException(e.getCode(), e.getMessage()); }catch (BusinessException e) { e.printStackTrace(); throw new BusinessException(e.getCode(), e.getMessage()); } catch (Exception e) { e.printStackTrace(); throw new BusinessException(ResultCodes.SERVER_ERROR); }finally { if(lock.isLocked()){ lock.unlock(); } } return new ResultVO(ResultCodes.OK); } private boolean isSpecialWork(WorkTypeEnum workType) { boolean result = false; // 动火 if (workType == WorkTypeEnum.WORK_FIRE || // 高处 workType == WorkTypeEnum.WORK_HIGH_SPACE || // 吊装 workType == WorkTypeEnum.WORK_HANG || // 盲板 workType == WorkTypeEnum.WORK_BLIND_PLATE) { result = true; } return result; } // 1.八大作业都有监护人层级 监护人有且仅有一个 // 2.动火作业 和 受限弓箭 需要分析人层级 其他不需要分析人层级 分析人有且仅有一个 private void checkRuleStepValid(WorkTypeEnum workType, List stepReqDTOList, List userList, List standList, List measureList) { // 检查序号是否存在重复和重新排序 List collect = stepReqDTOList.stream() // 序号 .map(ApprovalRuleStepAddReqDTO::getStepSerial) // 去重 .distinct() // 集合 .collect(Collectors.toList()); if (stepReqDTOList.size() > collect.size()) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "排序号不可重复!"); } // 按照升序排序 Collections.sort(stepReqDTOList, new Comparator() { @Override public int compare(ApprovalRuleStepAddReqDTO o1, ApprovalRuleStepAddReqDTO o2) { //升序 return o1.getStepSerial().compareTo(o2.getStepSerial()); } }); // 监护人层级个数 int guardianStepCount = 0; // 分析人层级个数 int analystStepCount = 0; for (ApprovalRuleStepAddReqDTO step : stepReqDTOList) { // 层级类型 if (step.getPersonType() == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"层级人员类型为空"); } if (ApprovalStepPersonTypeEnum.parse(step.getPersonType()) == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"层级人员类型不合法"); } // 审批单位 if (step.getUnitList() == null || step.getUnitList().size() == 0) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"层级人员为空"); } // 审批内容类型 if (step.getContentType() == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"审批内容类型为空"); } ApprovalStepContentTypeEnum stepContentType = ApprovalStepContentTypeEnum.parse(step.getContentType()); if (stepContentType == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"审批内容类型不合法"); } // 审批类型 多人 还是单人 ApprovalStepApprovalTypeEnum approvalType = ApprovalStepApprovalTypeEnum.parse(step.getApprovalType()); if (approvalType == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"审批人数类型不合法"); } AuditTypeEnum auditTypeEnum = AuditTypeEnum.parse(step.getAuditType()); if (auditTypeEnum == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"并行审批类型不合法"); } // 审批层级单元 List unitList = step.getUnitList(); if (unitList == null || unitList.size() == 0) { throw new AusinessException(E.DATA_PARAM_NULL, step.getStepName() + "未选择审批人!"); } /// 审批类型(单人审批 | 多人审批) 匹配 选择人数 this.checkPersonTypeMatchCounts(approvalType, unitList); // 分析人层级 if (step.getPersonType().equals(ApprovalStepPersonTypeEnum.TYPE_ANALYST.getType())) { // 分析人层级 ++ analystStepCount++; // 有效时间 有效时间单位 if (null == step.getContinueTime() || null == step.getContinueTimeUnit()) { throw new AusinessException(E.DATA_PARAM_NULL, "分析审批人层级,有效时间或者有效时间单位不可为空!"); } // 有效时间单位 if (RuleContinueTimeUnitEnum.parse(step.getContinueTimeUnit()) == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "有效时间单位不合法!"); } if (approvalType == ApprovalStepApprovalTypeEnum.TYPE_MULTIPLE_PEOPLE && auditTypeEnum == AuditTypeEnum.CONCURRENT_JOINT_TRIAL) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "分析人选择多人只能并行单审"); } // 审批内容类型为审批项审批 if (stepContentType != ApprovalStepContentTypeEnum.APP_ITEM) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "分析层级必须为审批项审批"); } // 审批(分析)项不可为空 if (null == step.getItemList() || step.getItemList().size() == 0) { throw new AusinessException(E.DATA_PARAM_NULL, "分析审批人层级,请添加分析项!"); } // 校验审批项的标准 for (ApprovalRuleUnitItemAddReqDTO item : step.getItemList()) { RuleItemTypeEnum typeEnum = RuleItemTypeEnum.parse(item.getType()); if (typeEnum == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "审批项类型不合法"); } if (!item.getType().equals(RuleItemTypeEnum.NUMERIC.getCode())) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "审批项只适用数值类型标准"); } assert item.getStandId() != null; long count = standList.stream().filter(stand -> stand.getId().equals(item.getStandId())).count(); if (count < 1) { throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, step.getStepName() + ",审批项标准不存在!"); } } } // 监护人层级 if (step.getPersonType().equals(ApprovalStepPersonTypeEnum.TYPE_GUARDIAN.getType())) { // 监护人层级 ++ guardianStepCount++; // 1.审批项审批 if (stepContentType == ApprovalStepContentTypeEnum.APP_ITEM) { // 审批(分析)项不可为空 if (null == step.getItemList() || step.getItemList().size() == 0) { throw new AusinessException(E.DATA_PARAM_NULL, "审批项目审批,审批项不可为空!"); } for (ApprovalRuleUnitItemAddReqDTO item : step.getItemList()) { RuleItemTypeEnum typeEnum = RuleItemTypeEnum.parse(item.getType()); if (typeEnum == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "审批项类型不合法"); } // 审批项 => 填空 | 选择 if (typeEnum != RuleItemTypeEnum.FILL && typeEnum != RuleItemTypeEnum.OPTION) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "监护层审批项类型不合法"); } if (item.getMeasureId() == null) { throw new AusinessException(E.DATA_PARAM_NULL,"安全措施id为空"); } List measures = measureList.stream() .filter(measure -> measure.getId().equals(item.getMeasureId())) .collect(Collectors.toList()); if (measures.size() < 1) { throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, step.getStepName() + ",审批项安全措施不存在!"); } if (typeEnum == RuleItemTypeEnum.FILL && !measures.get(0).getType().equals(MeasureTypeEnum.TYPE_INPUT.getType())) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "请选择填空类型安全措施"); } if (typeEnum == RuleItemTypeEnum.OPTION && !measures.get(0).getType().equals(MeasureTypeEnum.TYPE_CHOSE.getType())) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "请选择选择类型安全措施"); } } } // 2.简单审批 if (stepContentType == ApprovalStepContentTypeEnum.APP_SIMPLE) { } } // 普通人审批 if (step.getPersonType().equals(ApprovalStepPersonTypeEnum.TYPE_NORMAL.getType())) { // 审批人数类型 // 单人审批 <=> 1人 单审 if (approvalType == ApprovalStepApprovalTypeEnum.TYPE_SINGLE_PERSON) { if (step.getUnitList().size() != 1) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, step.getStepName() + "层单人审批只能选择一个审批人"); } if (auditTypeEnum != AuditTypeEnum.CONCURRENT_SINGLE_TRIAL) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, step.getStepName() + "层单人审批只能选择并行单审"); } } // 多人审批 if (approvalType == ApprovalStepApprovalTypeEnum.TYPE_MULTIPLE_PEOPLE) { if (step.getUnitList().size() < 2) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, step.getStepName() + "层多人审批需选择多个审批人"); } } // 1.审批项审批 if (stepContentType == ApprovalStepContentTypeEnum.APP_ITEM) { // 审批(分析)项不可为空 if (null == step.getItemList() || step.getItemList().size() == 0) { throw new AusinessException(E.DATA_PARAM_NULL, "审批项目审批,审批项不可为空!"); } for (ApprovalRuleUnitItemAddReqDTO item : step.getItemList()) { RuleItemTypeEnum typeEnum = RuleItemTypeEnum.parse(item.getType()); if (typeEnum == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "审批项类型不合法"); } // 审批项 => 填空 | 选择 if (typeEnum != RuleItemTypeEnum.FILL && typeEnum != RuleItemTypeEnum.OPTION) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "监护层审批项类型不合法"); } if (item.getMeasureId() == null) { throw new AusinessException(E.DATA_PARAM_NULL,"安全措施id为空"); } List measures = measureList.stream() .filter(measure -> measure.getId().equals(item.getMeasureId())) .collect(Collectors.toList()); if (measures.size() < 1) { throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, step.getStepName() + ",审批项安全措施不存在!"); } if (typeEnum == RuleItemTypeEnum.FILL && !measures.get(0).getType().equals(MeasureTypeEnum.TYPE_INPUT.getType())) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "请选择填空类型安全措施"); } if (typeEnum == RuleItemTypeEnum.OPTION && !measures.get(0).getType().equals(MeasureTypeEnum.TYPE_CHOSE.getType())) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "请选择选择类型安全措施"); } } } // 2.简单审批 if (stepContentType == ApprovalStepContentTypeEnum.APP_SIMPLE) { } } // 统一做 人员id 是否存在 for (ApprovalRuleUnitAddReqDTO unit : unitList) { long count = userList.stream().filter(user -> user.getUid().equals(unit.getBindUid())).count(); if (count < 1) { throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "审批人员不存在!"); } } } // 动火 || 受限 if (workType == WorkTypeEnum.WORK_FIRE || workType == WorkTypeEnum.WORK_CLOSE_SPACE) { if (analystStepCount == 0) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "缺少分析人层级"); } if (analystStepCount > 1) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "分析人层级有且仅有一层"); } }else{ // !动火 && !受限 if (analystStepCount > 0) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "非动火和受限空间作业,不需要分析人层级"); } } if (guardianStepCount == 0) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "缺少监护人层级"); } if (guardianStepCount > 1) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "监护人层级有且仅有一层"); } } @Override @Transactional public ResultVO update(ApprovalRuleModReqDTO ruleReqDTO) { //主键 if(null == ruleReqDTO.getRuleId()){ throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL); } ApprovalRule approvalRule = approvalRuleService.getById(ruleReqDTO.getRuleId()); if (approvalRule == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"作业规则不存在"); } if (!approvalRule.getDepId().equals(ruleReqDTO.getDepId())) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"部门不能修改"); } //部门验证 DepInfoRPCRespDTO depInfoByDepId = getDepInfoByDepId(ruleReqDTO.getDepId()); //根据规则id获取所有层级 List stepList = approvalRuleStepService.listByRuleId(ruleReqDTO.getRuleId()); //根据规则id获取所有单元 List unitList = approvalRuleUnitService.listByRuleId(ruleReqDTO.getRuleId()); //根据规则id获取所有审批项 List unitItemList = approvalRuleUnitItemService.listByRuleId(ruleReqDTO.getRuleId()); ContextCacheUser currentUser = RequestContextHolder.contextUserLocal.get(); // 是否是特殊作业 WorkTypeEnum workType= WorkTypeEnum.parse(ruleReqDTO.getWorkType()); boolean specialWork = this.isSpecialWork(workType); WorkLevelEnum workLevel = WorkLevelEnum.parse(ruleReqDTO.getWorkLevel()); if (specialWork) { // 检查等级 不能是无等级 if (workLevel == null || workLevel == WorkLevelEnum.DEFAULT) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"特殊作业需要作业等级"); } }else{ // 不是特殊作业默认无等级 workLevel = WorkLevelEnum.DEFAULT; } //填充规则信息 ApprovalRule rule = new ApprovalRule(); rule.setRuleId(ruleReqDTO.getRuleId()); rule.setRuleName(ruleReqDTO.getRuleName()); rule.setModifiedUid(currentUser.getUid()); rule.setModifiedUname(currentUser.getUsername()); //层级List List saveStepList = new ArrayList<>(); List updateStepList = new ArrayList<>(); //单元List List saveUnitList = new ArrayList<>(); //审批项List List saveUnitItemList = new ArrayList<>(); List updateUnitItemList = new ArrayList<>(); //层级 List stepModReqDTOList = ruleReqDTO.getStepList(); if(stepModReqDTOList != null && stepModReqDTOList.size()>0) { List uIdList = new ArrayList<>(); Set mIdList = new HashSet<>(); Set sIdList = new HashSet<>(); //循环出数据用于后面验证 stepModReqDTOList.forEach(step ->{ //单元 List units = step.getUnitList(); if(null != units && units.size()>0){ units.forEach(unit ->{ uIdList.add(unit.getBindUid()); }); } //审批项 List items = step.getItemList(); if(null != items && items.size()>0){ items.forEach(item ->{ if (null != item.getMeasureId()){ mIdList.add(item.getMeasureId()); } if (null != item.getStandId()){ sIdList.add(item.getStandId()); } }); } }); //用于后面验证 List userList = new ArrayList<>(); List measureList = new ArrayList<>(); List standList = new ArrayList<>(); if(uIdList.size()>0){ userList = listAccountUsers(uIdList); } if(mIdList.size()>0){ measureList = approvalRuleItemMeasureService.listItemMeasureByIds(mIdList); } if(sIdList.size()>0){ standList = approvalRuleStandService.listItemStandByIds(sIdList); } //检查序号是否存在重复 List collect = stepModReqDTOList.stream().map(ApprovalRuleStepModReqDTO::getStepSerial).distinct().collect(Collectors.toList()); if (stepModReqDTOList.size() > collect.size()) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "排序号不可重复!"); } //按照升序排序 Collections.sort(stepModReqDTOList, new Comparator() { @Override public int compare(ApprovalRuleStepModReqDTO o1, ApprovalRuleStepModReqDTO o2) { //升序 return o1.getStepSerial().compareTo(o2.getStepSerial()); } }); //过滤出要删除的层级 做删除以及解绑操作 List deleteOldStepList = stepList.stream().parallel().filter(a -> stepModReqDTOList.stream().noneMatch(b -> a.getStepId().equals(b.getStepId()))) .collect(Collectors.toList()); List deleteOldStepIdList = deleteOldStepList.stream().map(step -> step.getStepId()).collect(Collectors.toList()); if(deleteOldStepIdList != null && deleteOldStepIdList.size()>0){ //删除关联的审批项 approvalRuleUnitItemService.updateStatusByStepIds(deleteOldStepIdList); //删除关联的单元 approvalRuleUnitService.updateStatusByStepIds(deleteOldStepIdList); //先删除原有层级 approvalRuleStepService.updateStatusByStepIds(deleteOldStepIdList); } Long stepId = null; WorkTypeEnum workTypeEnum = WorkTypeEnum.parse(ruleReqDTO.getWorkType()); checkRuleStepValid2(workTypeEnum, ruleReqDTO.getStepList(), userList, standList, measureList); //循环层级 更新的层级 for (ApprovalRuleStepModReqDTO stepReqDTO : stepModReqDTOList) { //填充层级数据 ApprovalRuleStep step = new ApprovalRuleStep(); List oldUnitList = new ArrayList<>(); List oldUnitItemList = new ArrayList<>(); //填充规则id step.setRuleId(rule.getRuleId()); step.setStepName(stepReqDTO.getStepName()); step.setStepSerial(stepReqDTO.getStepSerial()); step.setPersonType(stepReqDTO.getPersonType()); step.setApprovalType(stepReqDTO.getApprovalType()); step.setContentType(stepReqDTO.getContentType()); step.setAuditType(stepReqDTO.getAuditType()); if (stepReqDTO.getPersonType().equals(ApprovalStepPersonTypeEnum.TYPE_ANALYST.getType())) { // 分析人 标准 step.setContinueTime(stepReqDTO.getContinueTime()); step.setContinueTimeUnit(stepReqDTO.getContinueTimeUnit()); } //判断是否第一个节点 if (null != stepId) { step.setPreStepId(stepId); } //层级主键不为空 做更新操作 if(null != stepReqDTO.getStepId()){ step.setModifiedUid(currentUser.getUid()); step.setModifiedUname(currentUser.getUsername()); step.setStepId(stepReqDTO.getStepId()); updateStepList.add(step); //过滤出层级原有的单元人员 oldUnitList = unitList.stream().filter(unit -> unit.getStepId().equals(stepReqDTO.getStepId())).collect(Collectors.toList()); //过滤出层级原有的审批项 oldUnitItemList = unitItemList.stream().filter(item -> item.getStepId().equals(stepReqDTO.getStepId())).collect(Collectors.toList()); }else{ step.setStepId(IdUtil.getSnowflake(0,0).nextId()); step.setStatus(RuleStepStatusEnum.VALID.getCode()); step.setGmtCreate(LocalDateTime.now()); step.setCreateUid(currentUser.getUid()); step.setCreateUname(currentUser.getUsername()); saveStepList.add(step); } //赋值 stepId = step.getStepId(); //单元 List unitModReqDTOList = stepReqDTO.getUnitList(); //过滤出原来存在的单元 List undeleteOldUnitList = oldUnitList.stream().parallel().filter(oldUnit -> unitModReqDTOList.stream() .anyMatch(newUnit-> newUnit.getBindUid().equals(oldUnit.getBindUid()))).collect(Collectors.toList()); //过滤出要删除的单元 做删除操作 List deleteOldUnitList = oldUnitList.stream().parallel().filter(a -> unitModReqDTOList.stream().noneMatch(b -> a.getBindUid().equals(b.getBindUid()))) .collect(Collectors.toList()); if(deleteOldUnitList.size()>0 && deleteOldUnitList != null){ List deleteOldUnitIdList = deleteOldUnitList.stream().map(unit->unit.getUnitId()).collect(Collectors.toList()); //删除审批单元 approvalRuleUnitService.updateStatusByUnitIds(deleteOldUnitIdList); } //遍历单元 for (ApprovalRuleUnitModReqDTO unitReqDTO : unitModReqDTOList) { List uList = userList.stream().filter(user -> user.getUid().equals(unitReqDTO.getBindUid())).collect(Collectors.toList()); if (uList.size() == 0) { throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "审批人员不存在!"); } List selectUnit = undeleteOldUnitList.stream().filter(u -> u.getBindUid().equals(unitReqDTO.getBindUid())).collect(Collectors.toList()); if(selectUnit.size() == 0){ //如果非原有单元,则插入 ApprovalRuleUnit unit = new ApprovalRuleUnit(); unit.setUnitId(IdUtil.getSnowflake(0,0).nextId()); unit.setRuleId(rule.getRuleId()); unit.setStepId(step.getStepId()); unit.setBindDepId(ruleReqDTO.getDepId()); unit.setBindDepName(depInfoByDepId.getDepName()); unit.setBindUid(unitReqDTO.getBindUid()); unit.setBindUname(uList.get(0).getUsername()); unit.setGmtCreate(LocalDateTime.now()); unit.setStatus(RuleUnitStatusEnum.VALID.getCode()); unit.setCreateUid(currentUser.getUid()); unit.setCreateUname(currentUser.getUsername()); saveUnitList.add(unit); } } //审批项 List itemModReqDTOList = stepReqDTO.getItemList(); if(itemModReqDTOList != null){ //过滤出要删除的审批项 做删除操作 List deleteOldItemList = oldUnitItemList.stream().parallel().filter(a -> itemModReqDTOList.stream().noneMatch(b -> a.getId().equals(b.getId()))) .collect(Collectors.toList()); if(deleteOldItemList.size()>0 && deleteOldItemList != null){ List deleteOldUnitIdList = deleteOldItemList.stream().map(item->item.getId()).collect(Collectors.toList()); //删除审批项 approvalRuleUnitItemService.updateStatusByIds(deleteOldUnitIdList); } //遍历审批项 for (ApprovalRuleUnitItemModReqDTO itemReqDTO : itemModReqDTOList) { ApprovalRuleUnitItem itemVo = new ApprovalRuleUnitItem(); itemVo.setItemName(itemReqDTO.getItemName()); itemVo.setRuleId(rule.getRuleId()); itemVo.setStepId(step.getStepId()); itemVo.setType(itemReqDTO.getType()); // 是否分析人审批 if (stepReqDTO.getPersonType().equals(ApprovalStepPersonTypeEnum.TYPE_ANALYST.getType())) { // 分析人 标准 itemVo.setStandId(itemReqDTO.getStandId()); } else { // 安全措施 itemVo.setMeasureId(itemReqDTO.getMeasureId()); } //主键为空 则新增 if(null == itemReqDTO.getId()){ itemVo.setId(IdUtil.getSnowflake(0,0).nextId()); itemVo.setStatus(RuleItemStatusEnum.VALID.getCode()); itemVo.setGmtCreate(LocalDateTime.now()); itemVo.setCreateUid(currentUser.getUid()); itemVo.setCreateUname(currentUser.getUsername()); saveUnitItemList.add(itemVo); }else{ //修改操作 //填充主键 itemVo.setId(itemReqDTO.getId()); itemVo.setGmtModified(LocalDateTime.now()); itemVo.setModifiedUid(currentUser.getUid()); itemVo.setModifiedUname(currentUser.getUsername()); updateUnitItemList.add(itemVo); } } } } } //更新规则 approvalRuleService.updateRule(rule); if(saveStepList.size()>0){ //批量插入层级 approvalRuleStepService.saveStepList(saveStepList); } if(updateStepList.size()>0){ //批量更新层级 approvalRuleStepService.updateBatchStep(updateStepList); } if(saveUnitList.size()>0){ //批量插入单元 approvalRuleUnitService.saveUnitList(saveUnitList); } if(saveUnitItemList.size()>0){ //批量插入审批项 approvalRuleUnitItemService.batchSaveItemList(saveUnitItemList); } if(updateUnitItemList.size()>0){ //批量更新审批项 approvalRuleUnitItemService.updateBatchItem(updateUnitItemList); } return new ResultVO<>(ResultCodes.OK); } @Override @Transactional public ResultVO removeBatchRule(DeleteForm deleteForm) { //删除规则表中数据 approvalRuleService.updateStutsByRuleIds(deleteForm.getIds()); //删除关联该规则的层级 approvalRuleStepService.updateStatusByRuleIds(deleteForm.getIds()); //删除单元 approvalRuleUnitService.updateStatusByRuleIds(deleteForm.getIds()); //删除审批项 approvalRuleUnitItemService.updateStatusByRuleIds(deleteForm.getIds()); return new ResultVO<>(ResultCodes.OK); } // 1.八大作业都有监护人层级 监护人有且仅有一个 // 2.动火作业 和 受限弓箭 需要分析人层级 其他不需要分析人层级 分析人有且仅有一个 private void checkRuleStepValid2(WorkTypeEnum workType, List stepReqDTOList, List userList, List standList, List measureList) { // 检查序号是否存在重复和重新排序 List collect = stepReqDTOList.stream() // 序号 .map(ApprovalRuleStepModReqDTO::getStepSerial) // 去重 .distinct() // 集合 .collect(Collectors.toList()); if (stepReqDTOList.size() > collect.size()) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "排序号不可重复!"); } // 按照升序排序 Collections.sort(stepReqDTOList, new Comparator() { @Override public int compare(ApprovalRuleStepModReqDTO o1, ApprovalRuleStepModReqDTO o2) { //升序 return o1.getStepSerial().compareTo(o2.getStepSerial()); } }); // 监护人层级个数 int guardianStepCount = 0; // 分析人层级个数 int analystStepCount = 0; for (ApprovalRuleStepModReqDTO step : stepReqDTOList) { // 层级类型 if (step.getPersonType() == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"层级人员类型为空"); } if (ApprovalStepPersonTypeEnum.parse(step.getPersonType()) == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"层级人员类型不合法"); } // 审批单位 if (step.getUnitList() == null || step.getUnitList().size() == 0) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"层级人员为空"); } // 审批内容类型 if (step.getContentType() == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"审批内容类型为空"); } ApprovalStepContentTypeEnum stepContentType = ApprovalStepContentTypeEnum.parse(step.getContentType()); if (stepContentType == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"审批内容类型不合法"); } // 审批类型 多人 还是单人 ApprovalStepApprovalTypeEnum approvalType = ApprovalStepApprovalTypeEnum.parse(step.getApprovalType()); if (approvalType == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"审批人数类型不合法"); } AuditTypeEnum auditTypeEnum = AuditTypeEnum.parse(step.getAuditType()); if (auditTypeEnum == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"并行审批类型不合法"); } // 审批层级单元 List unitList = step.getUnitList(); if (unitList == null || unitList.size() == 0) { throw new AusinessException(E.DATA_PARAM_NULL, step.getStepName() + "未选择审批人!"); } // 多人审批 单人审批 匹配上 人数 this.checkPersonTypeMatchCounts(approvalType, unitList); // 分析人层级 if (step.getPersonType().equals(ApprovalStepPersonTypeEnum.TYPE_ANALYST.getType())) { // 分析人层级 ++ analystStepCount++; // 有效时间 有效时间单位 if (null == step.getContinueTime() || null == step.getContinueTimeUnit()) { throw new AusinessException(E.DATA_PARAM_NULL, "分析审批人层级,有效时间或者有效时间单位不可为空!"); } // 有效时间单位 if (RuleContinueTimeUnitEnum.parse(step.getContinueTimeUnit()) == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "有效时间单位不合法!"); } if (approvalType == ApprovalStepApprovalTypeEnum.TYPE_MULTIPLE_PEOPLE && auditTypeEnum == AuditTypeEnum.CONCURRENT_JOINT_TRIAL) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "分析人选择多人只能并行单审"); } // 审批内容类型为审批项审批 if (stepContentType != ApprovalStepContentTypeEnum.APP_ITEM) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "分析层级必须为审批项审批"); } // 审批(分析)项不可为空 if (null == step.getItemList() || step.getItemList().size() == 0) { throw new AusinessException(E.DATA_PARAM_NULL, "分析审批人层级,请添加分析项!"); } // 校验审批项的标准 for (ApprovalRuleUnitItemModReqDTO item : step.getItemList()) { RuleItemTypeEnum typeEnum = RuleItemTypeEnum.parse(item.getType()); if (typeEnum == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "审批项类型不合法"); } if (!item.getType().equals(RuleItemTypeEnum.NUMERIC.getCode())) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "审批项只适用数值类型标准"); } assert item.getStandId() != null; long count = standList.stream().filter(stand -> stand.getId().equals(item.getStandId())).count(); if (count < 1) { throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, step.getStepName() + ",审批项标准不存在!"); } } } // 监护人层级 if (step.getPersonType().equals(ApprovalStepPersonTypeEnum.TYPE_GUARDIAN.getType())) { // 监护人层级 ++ guardianStepCount++; // 1.审批项审批 if (stepContentType == ApprovalStepContentTypeEnum.APP_ITEM) { // 审批(分析)项不可为空 if (null == step.getItemList() || step.getItemList().size() == 0) { throw new AusinessException(E.DATA_PARAM_NULL, "审批项目审批,审批项不可为空!"); } for (ApprovalRuleUnitItemModReqDTO item : step.getItemList()) { RuleItemTypeEnum typeEnum = RuleItemTypeEnum.parse(item.getType()); if (typeEnum == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "审批项类型不合法"); } // 审批项 => 填空 | 选择 if (typeEnum != RuleItemTypeEnum.FILL && typeEnum != RuleItemTypeEnum.OPTION) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "监护层审批项类型不合法"); } if (item.getMeasureId() == null) { throw new AusinessException(E.DATA_PARAM_NULL,"安全措施id为空"); } List measures = measureList.stream() .filter(measure -> measure.getId().equals(item.getMeasureId())) .collect(Collectors.toList()); if (measures.size() < 1) { throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, step.getStepName() + ",审批项安全措施不存在!"); } if (typeEnum == RuleItemTypeEnum.FILL && !measures.get(0).getType().equals(MeasureTypeEnum.TYPE_INPUT.getType())) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "请选择填空类型安全措施"); } if (typeEnum == RuleItemTypeEnum.OPTION && !measures.get(0).getType().equals(MeasureTypeEnum.TYPE_CHOSE.getType())) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "请选择选择类型安全措施"); } } } // 2.简单审批 if (stepContentType == ApprovalStepContentTypeEnum.APP_SIMPLE) { } } // 普通人审批 if (step.getPersonType().equals(ApprovalStepPersonTypeEnum.TYPE_NORMAL.getType())) { // 审批人数类型 // 单人审批 <=> 1人 单审 if (approvalType == ApprovalStepApprovalTypeEnum.TYPE_SINGLE_PERSON) { if (step.getUnitList().size() != 1) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, step.getStepName() + "层单人审批只能选择一个审批人"); } if (auditTypeEnum != AuditTypeEnum.CONCURRENT_SINGLE_TRIAL) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, step.getStepName() + "层单人审批只能选择并行单审"); } } // 多人审批 if (approvalType == ApprovalStepApprovalTypeEnum.TYPE_MULTIPLE_PEOPLE) { if (step.getUnitList().size() < 2) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, step.getStepName() + "层多人审批需选择多个审批人"); } } // 1.审批项审批 if (stepContentType == ApprovalStepContentTypeEnum.APP_ITEM) { // 审批(分析)项不可为空 if (null == step.getItemList() || step.getItemList().size() == 0) { throw new AusinessException(E.DATA_PARAM_NULL, "审批项目审批,审批项不可为空!"); } for (ApprovalRuleUnitItemModReqDTO item : step.getItemList()) { RuleItemTypeEnum typeEnum = RuleItemTypeEnum.parse(item.getType()); if (typeEnum == null) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "审批项类型不合法"); } // 审批项 => 填空 | 选择 if (typeEnum != RuleItemTypeEnum.FILL && typeEnum != RuleItemTypeEnum.OPTION) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "监护层审批项类型不合法"); } if (item.getMeasureId() == null) { throw new AusinessException(E.DATA_PARAM_NULL,"安全措施id为空"); } List measures = measureList.stream() .filter(measure -> measure.getId().equals(item.getMeasureId())) .collect(Collectors.toList()); if (measures.size() < 1) { throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, step.getStepName() + ",审批项安全措施不存在!"); } if (typeEnum == RuleItemTypeEnum.FILL && !measures.get(0).getType().equals(MeasureTypeEnum.TYPE_INPUT.getType())) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "请选择填空类型安全措施"); } if (typeEnum == RuleItemTypeEnum.OPTION && !measures.get(0).getType().equals(MeasureTypeEnum.TYPE_CHOSE.getType())) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "请选择选择类型安全措施"); } } } // 2.简单审批 if (stepContentType == ApprovalStepContentTypeEnum.APP_SIMPLE) { } } // 统一做 人员id 是否存在 for (ApprovalRuleUnitModReqDTO unit : unitList) { long count = userList.stream().filter(user -> user.getUid().equals(unit.getBindUid())).count(); if (count < 1) { throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "审批人员不存在!"); } } } // 动火 || 受限 if (workType == WorkTypeEnum.WORK_FIRE || workType == WorkTypeEnum.WORK_CLOSE_SPACE) { if (analystStepCount == 0) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "缺少分析人层级"); } if (analystStepCount > 1) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "分析人层级有且仅有一层"); } }else{ // !动火 && !受限 if (analystStepCount > 0) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "非动火和受限空间作业,不需要分析人层级"); } } if (guardianStepCount == 0) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "缺少监护人层级"); } if (guardianStepCount > 1) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "监护人层级有且仅有一层"); } } @Override public SearchResultVO> listRuleByPage(PageQuery pageQuery) { Page page = new Page<>(pageQuery.getPageIndex(),pageQuery.getPageSize()); List approvalRules = approvalRuleService.listRuleByPage(page,pageQuery.getSearchParams()); //获取层级列表 List stepList = approvalRuleStepService.listStepByNoConditions(); //获取单元列表 List unitList = approvalRuleUnitService.listByNoConditions(); //获取审批项列表 List itemList = approvalRuleUnitItemService.listByNoConditions(); //获取对应的审批标准 //获取安全措施列表 List ruleRespList = new ArrayList<>(); for (ApprovalRule rule : approvalRules) { //复制 ApprovalRuleRespDTO ruleRespDTO = new ApprovalRuleRespDTO(); BeanUtils.copyProperties(rule,ruleRespDTO); //刷选层级 List selectStepList = stepList.stream().filter(step -> step.getRuleId().equals(rule.getRuleId())).collect(Collectors.toList()); List stepRespList = new ArrayList<>(); for (ApprovalRuleStep step : selectStepList) { //复制 ApprovalRuleStepRespDTO stepRespDTO = new ApprovalRuleStepRespDTO(); BeanUtils.copyProperties(step,stepRespDTO); //过滤单元 List selectUnitList = unitList.stream().filter(unit -> unit.getStepId().equals(step.getStepId())).collect(Collectors.toList()); List unitRespDTOList = new ArrayList<>(); for (ApprovalRuleUnit unit: selectUnitList) { //复制 ApprovalRuleUnitRespDTO unitRespDTO = new ApprovalRuleUnitRespDTO(); BeanUtils.copyProperties(unit,unitRespDTO); unitRespDTOList.add(unitRespDTO); } //过滤审批项 List selectItemList = itemList.stream().filter(item -> item.getStepId().equals(step.getStepId())).collect(Collectors.toList()); List itemRespDTOList = new ArrayList<>(); for (ApprovalRuleUnitItem item: selectItemList) { //复制 ApprovalRuleUnitItemRespDTO itemRespDTO = new ApprovalRuleUnitItemRespDTO(); BeanUtils.copyProperties(item,itemRespDTO); itemRespDTOList.add(itemRespDTO); } stepRespDTO.setUnitList(unitRespDTOList); stepRespDTO.setItemList(itemRespDTOList); stepRespList.add(stepRespDTO); } ruleRespDTO.setStepList(stepRespList); ruleRespList.add(ruleRespDTO); } //需要获取层级、单元、审批项、以及审批规则 等后面封装进去 return new SearchResultVO<>(true, page.getCurrent(), page.getSize(), page.getPages(), page.getTotal(), ruleRespList, ResultCodes.OK); } @Override public ApprovalRuleBO recursiveQueryRule(Long depId, Byte workType, Byte workLevel) { ApprovalRuleBO ruleBO = null; // rpc获取部门 if (depId == null) { return null; } ResultVO rpcResult = accountDepartmentService.getDepInfoByDepId(depId); if (rpcResult.getCode().equals(ResultCodes.OK.getCode())) { if (rpcResult.getData() != null) { DepInfoRPCRespDTO department = (DepInfoRPCRespDTO)rpcResult.getData(); ApprovalRule rule = approvalRuleService.getApprovalRuleInfo(depId, workType, workLevel); if (rule == null) { ruleBO = recursiveQueryRule(department.getParentDepId(), workType, workLevel); }else{ ruleBO = new ApprovalRuleBO(); ruleBO.setDepId(rule.getDepId()); ruleBO.setDepName(department.getDepName()); ruleBO.setEid(rule.getEid()); ruleBO.setRuleId(rule.getRuleId()); ruleBO.setRuleName(rule.getRuleName()); ruleBO.setStatus(rule.getStatus()); ruleBO.setWorkLevel(rule.getWorkLevel()); ruleBO.setWorkType(rule.getWorkType()); } } }else{ throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg()); } return ruleBO; } //调用Rpc 获取部门 private DepInfoRPCRespDTO getDepInfoByDepId(Long deptId) { DepInfoRPCRespDTO dep = new DepInfoRPCRespDTO(); ResultVO rpcResult = accountDepartmentService.getDepInfoByDepId(deptId); if (rpcResult != null && rpcResult.getCode().equals(ResultCodes.OK.getCode())) { if (rpcResult.getData() != null) { dep = (DepInfoRPCRespDTO) rpcResult.getData(); }else{ throw new BusinessException(ResultCodes.CLIENT_DEP_NOT_EXIST); } } else { throw new BusinessException(ResultCodes.RPC_ACCESS_EXCEPTION); } return dep; } //调用RPC 获取去人员 private List listAccountUsers(List userIds){ List userInfoRPCRespDTOList = new ArrayList<>(); ResultVO> listResultVO = accountUserService.listUserInfoByUids(userIds); if (listResultVO != null && listResultVO.getCode().equals(ResultCodes.OK.getCode())) { if (listResultVO.getData() != null) { userInfoRPCRespDTOList = (List) listResultVO.getData(); }else{ throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"审批人员不存在"); } } else { throw new BusinessException(ResultCodes.RPC_ACCESS_EXCEPTION); } return userInfoRPCRespDTOList; } /** * @Description: 匹配 审批类型(单人审批|多人审批) 和 人员个数 */ private void checkPersonTypeMatchCounts(ApprovalStepApprovalTypeEnum stepApprovalTypeEnum,List persons) { if (persons != null && stepApprovalTypeEnum != null) { switch (stepApprovalTypeEnum) { case TYPE_SINGLE_PERSON: if (persons.size() != 1) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID,"单人审批情况下只能选择一人"); } case TYPE_MULTIPLE_PEOPLE: if (persons.size() < 1) { throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "多人审批情况下人数请选择多人"); } } }else{ throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "人员入参为空"); } } }