package com.gk.hotwork.specialWork.service.impl;
|
|
import cn.hutool.core.util.IdUtil;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.gk.hotwork.Domain.Utils.RPCUtils;
|
import com.gk.hotwork.Domain.dto.DepInfoRPCRespDTO;
|
import com.gk.hotwork.Domain.dto.UserInfoRPCRespDTO;
|
|
import com.gk.hotwork.Domain.co.ContextCacheUser;
|
import com.gk.hotwork.Domain.Exception.E;
|
import com.gk.hotwork.Domain.Enum.ResultCodes;
|
import com.gk.hotwork.Domain.Exception.BusinessException;
|
import com.gk.hotwork.Domain.Exception.BusinessException;
|
import com.gk.hotwork.Domain.Vo.PageQuery;
|
import com.gk.hotwork.Domain.Utils.StringUtils;
|
import com.gk.hotwork.Domain.Vo.ResultVO;
|
import com.gk.hotwork.Domain.Vo.SearchResultVO;
|
import com.gk.hotwork.Service.Middle.AccountAuthService;
|
import com.gk.hotwork.Service.Middle.AccountDepartmentService;
|
import com.gk.hotwork.specialWork.entity.*;
|
import com.gk.hotwork.specialWork.enums.*;
|
import com.gk.hotwork.specialWork.model.bo.*;
|
import com.gk.hotwork.specialWork.model.dto.req.*;
|
import com.gk.hotwork.specialWork.model.dto.resp.*;
|
import com.gk.hotwork.specialWork.model.query.AllWorkApplyPageQuery;
|
import com.gk.hotwork.specialWork.model.query.WorkApplyApplyingPageQuery;
|
import com.gk.hotwork.specialWork.model.query.WorkApplyPendingPageQuery;
|
import com.gk.hotwork.specialWork.model.query.db.AllWorkApplyPageDBQuery;
|
import com.gk.hotwork.specialWork.model.query.db.WorkApplyApplyingPageDBQuery;
|
import com.gk.hotwork.specialWork.model.query.db.WorkApplyPendingPageDBQuery;
|
import com.gk.hotwork.specialWork.mq.msg.ApplySpecialWorkMsg;
|
import com.gk.hotwork.specialWork.mq.msg.ApprovalSpecialWorkMsg;
|
import com.gk.hotwork.specialWork.service.*;
|
import com.gk.hotwork.specialWork.service.baseService.*;
|
|
import org.redisson.api.RLock;
|
import org.redisson.api.RedissonClient;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.servlet.http.HttpServletResponse;
|
import java.math.BigDecimal;
|
import java.time.LocalDateTime;
|
import java.time.ZoneId;
|
import java.time.ZonedDateTime;
|
import java.util.*;
|
import java.util.concurrent.TimeUnit;
|
import java.util.stream.Collectors;
|
|
@Service("workApplyService")
|
public class WorkApplyServiceImpl implements WorkApplyService {
|
|
@Autowired
|
private AccountAuthService accountUserService;
|
@Autowired
|
private AccountDepartmentService accountDepartmentService;
|
@Autowired
|
private WorkApplyInfoService workApplyInfoService;
|
@Autowired
|
private WorkApplyOperatorInfoService workApplyOperatorInfoService;
|
@Autowired
|
private WorkApprovalRuleInfoService workApprovalRuleInfoService;
|
@Autowired
|
private WorkApprovalStepInfoService workApprovalStepInfoService;
|
@Autowired
|
private WorkApprovalUnitInfoService workApprovalUnitInfoService;
|
@Autowired
|
private WorkApprovalItemInfoService workApprovalItemInfoService;
|
@Autowired
|
private WorkApprovalFilledItemInfoService workApprovalFilledItemInfoService;
|
@Autowired
|
private WorkApprovalItemMeasureInfoService workApprovalItemMeasureInfoService;
|
@Autowired
|
private WorkApprovalItemStandInfoService workApprovalItemStandInfoService;
|
@Autowired
|
private RuleService ruleService;
|
@Autowired
|
private ApprovalRuleStepService approvalRuleStepService;
|
@Autowired
|
private ApprovalRuleUnitService approvalRuleUnitService;
|
@Autowired
|
private ApprovalRuleUnitItemService approvalRuleUnitItemService;
|
@Autowired
|
private ApprovalRuleStandService approvalRuleStandService;
|
@Autowired
|
private ApprovalRuleItemMeasureService approvalRuleItemMeasureService;
|
@Autowired
|
private WorkHotInfoService workHotInfoService;
|
|
@Autowired
|
private WorkConfinedSpaceInfoService workConfinedSpaceInfoService;
|
|
@Autowired
|
private WorkAtHeightInfoService workAtHeightInfoService;
|
|
@Autowired
|
private WorkBrokenCircuitInfoService workBrokenCircuitInfoService;
|
|
@Autowired
|
private WorkTemporaryPowerInfoService workTemporaryPowerInfoService;
|
|
@Autowired
|
private WorkHoistingInfoService workHoistingInfoService;
|
|
@Autowired
|
private WorkBlindPlatePluggingInfoService workBlindPlatePluggingInfoService;
|
|
@Autowired
|
private WorkGroundBreakingInfoService workGroundBreakingInfoService;
|
|
@Autowired
|
private WorkApplyRocketMQService workApplyRocketMQService;
|
|
@Autowired
|
private ApprovalWorkRocketMQService approvalWorkRocketMQService;
|
|
@Autowired
|
private WorkApplyRecordService workApplyRecordService;
|
|
@Autowired
|
private WorkPrintService workPrintService;
|
|
|
// @Value("${rocketmq.topic.applySpecialWorkTopic}")
|
// private String applySpecialWorkTopic;
|
//
|
// @Value("${rocketmq.topic.approvalSpecialWorkTopic}")
|
// private String approvalSpecialWorkTopic;
|
//
|
// @Autowired
|
// private RocketMQSpecialWorkTemplateHelper rocketMQSpecialWorkTemplateHelper;
|
|
// @Autowired
|
// private SpecialWorkMinoService specialWorkMinoService;
|
|
|
@Autowired
|
private RedissonClient redissonClient;
|
|
|
@Override
|
@Transactional
|
public void workApply(ContextCacheUser currentUser, WorkApplyReqDTO< ? extends WorkApplyEight> applyReqDTO) {
|
// 0.基本判断
|
if (applyReqDTO.getWorkLevel() == null ||
|
applyReqDTO.getWorkType() == null) {
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
if (StringUtils.isBlank(applyReqDTO.getWorkContent())) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "作业内容不能为空");
|
}
|
if (StringUtils.isBlank(applyReqDTO.getWorkLocation())) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "作业地点不能为空");
|
}
|
if (StringUtils.isBlank(applyReqDTO.getHazardIdentification())) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "危险辨识不能为空");
|
}
|
if (StringUtils.isBlank(applyReqDTO.getOperatorUnames())) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "作业人不能为空");
|
}
|
if (StringUtils.isBlank(applyReqDTO.getOperatorCompanys())) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "作业单位不能为空");
|
}
|
if (applyReqDTO.getExpEndTime() == null || applyReqDTO.getExpStartTime() == null) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "时间不能为空");
|
}
|
//获取当前时间
|
LocalDateTime applyTime = LocalDateTime.now();
|
if(applyTime.isAfter(applyReqDTO.getExpStartTime())){
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "作业开始时间不可早于作业申请时间");
|
}
|
if (applyReqDTO.getExpStartTime().isAfter(applyReqDTO.getExpEndTime())) {
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "时间区间非法");
|
}
|
WorkTypeEnum workTypeEnum = WorkTypeEnum.parse(applyReqDTO.getWorkType());
|
if (workTypeEnum == null) {
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "作业类型非法");
|
}
|
WorkLevelEnum workLevelEnum = WorkLevelEnum.parse(applyReqDTO.getWorkLevel());
|
if (workLevelEnum == null) {
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "作业等级非法");
|
}
|
// if (applyReqDTO.getOperatorUids().size() == 0) {
|
// throw new BusinessException(E.DATA_PARAM_NULL, "请选择作业人");
|
// }
|
if (applyReqDTO.getWorkDetail() == null) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "请填写作业主体内容");
|
}
|
// 检查八大作业
|
WorkTypeMatchDetailCheck(workTypeEnum, applyReqDTO.getWorkDetail());
|
// 该部门下获取审批流
|
Long depId = currentUser.getDepId();
|
// List<UserInfoRPCRespDTO> rpcUsers;
|
// List<Long> operatorUids = applyReqDTO.getOperatorUids();
|
// ResultVO<List<UserInfoRPCRespDTO>> rpcOperatorsResult = accountUserService.listUserInfoByUids(operatorUids);
|
// if (rpcOperatorsResult.getCode().equals(ResultCodes.OK.getCode())) {
|
// if (rpcOperatorsResult.getData() != null) {
|
// rpcUsers = RPCUtils.castList(rpcOperatorsResult.getData(), UserInfoRPCRespDTO.class);
|
// if (rpcUsers.size() != operatorUids.size()) {
|
// throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "作业人不存在");
|
// }
|
//
|
// }else{
|
// throw new BusinessException(ResultCodes.RPC_DATA_NULL);
|
// }
|
// }else{
|
// throw new BusinessException(rpcOperatorsResult.getCode(), rpcOperatorsResult.getMsg());
|
// }
|
// // 判断作业人员是否是部门或者子部门的人员
|
// ResultVO<Boolean> rpcResult = accountDepartmentService.isSelfOrSubDep(depId, operator.getDepId());
|
// if (rpcResult.getCode().equals(ResultCodes.OK.getCode())) {
|
// if (rpcResult.getData() != null) {
|
//// if (!(Boolean) rpcResult.getData()) {
|
//// throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "作业人部门越界");
|
//// }
|
//// }else{
|
//// throw new BusinessException(ResultCodes.RPC_DATA_NULL);
|
//// }
|
// }else{
|
// throw new BusinessException(rpcOperatorResult.getCode(), rpcOperatorResult.getMsg());
|
// }
|
// 1.递归寻找部门的审批规则
|
ApprovalRuleBO ruleBO = ruleService.recursiveQueryRule(depId, applyReqDTO.getWorkType(), applyReqDTO.getWorkLevel());
|
if (ruleBO == null) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "无可用审批流");
|
}
|
|
// 2.准备工作
|
|
// 2.1 workApprovalUStep
|
// 根据 approvalRuleId 获取各个层级
|
List<ApprovalRuleStep> ruleSteps = approvalRuleStepService.listApprovalRuleStepByRuleId(ruleBO.getRuleId());
|
if (ruleSteps.size() < 1) {
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "审批规则非法，审批层级不存在");
|
}
|
// 2.2 workApprovalUnit 获取各个单元
|
List<ApprovalRuleUnit> ruleUnits = approvalRuleUnitService.listApprovalUnitByRuleId(ruleBO.getRuleId());
|
// 2.3 workApprovalItem 获取各个审批项
|
List<ApprovalRuleUnitItem> ruleUnitItems = approvalRuleUnitItemService.listApprovalRuleUnitItemByRuleId(ruleBO.getRuleId());
|
|
// 1.workApply
|
WorkApplyInfo applyEntity = new WorkApplyInfo();
|
applyEntity.setId(IdUtil.getSnowflake(0,0).nextId());
|
applyEntity.setDepId(currentUser.getDepId());
|
applyEntity.setApplyUid(currentUser.getUid());
|
applyEntity.setApplyUname(currentUser.getRealName());
|
applyEntity.setDepName(currentUser.getDepName());
|
applyEntity.setWorkType(applyReqDTO.getWorkType());
|
applyEntity.setWorkLevel(applyReqDTO.getWorkLevel());
|
// 申请中状态暂定 当前创建就进入审批中
|
applyEntity.setStatus(WorkStatusEnum.STATU_IN_APPROVAL.getStatus());
|
applyEntity.setApplyTime(applyTime);
|
applyEntity.setExpStartTime(applyReqDTO.getExpStartTime());
|
applyEntity.setExpEndTime(applyReqDTO.getExpEndTime());
|
applyEntity.setGmtCreate(LocalDateTime.now());
|
applyEntity.setWorkContent(applyReqDTO.getWorkContent());
|
applyEntity.setWorkLocation(applyReqDTO.getWorkLocation());
|
applyEntity.setHazardIdentification(applyReqDTO.getHazardIdentification());
|
applyEntity.setOperatorUnames(applyReqDTO.getOperatorUnames());
|
applyEntity.setOperatorCompanys(applyReqDTO.getOperatorCompanys());
|
|
// // operator
|
// List<WorkApplyOperatorInfo> operatorEntities = new ArrayList<>(rpcUsers.size());
|
// WorkApplyOperatorInfo operatorEntity;
|
// for (UserInfoRPCRespDTO respDTO : rpcUsers) {
|
// operatorEntity = new WorkApplyOperatorInfo();
|
// operatorEntity.setId(IdUtil.getSnowflake(0, 0).nextId());
|
// operatorEntity.setOperatorUid(respDTO.getUid());
|
// operatorEntity.setOperatorUname(respDTO.getRealName());
|
// operatorEntity.setOperatorIdentify(respDTO.getIdentify());
|
// operatorEntity.setOperatorPhone(respDTO.getPhone());
|
// operatorEntity.setWorkApplyId(applyEntity.getId());
|
// operatorEntities.add(operatorEntity);
|
// }
|
|
// rule
|
WorkApprovalRuleInfo ruleEntity = new WorkApprovalRuleInfo();
|
ruleEntity.setId(IdUtil.getSnowflake(0,0).nextId());
|
ruleEntity.setApprovalRuleId(ruleBO.getRuleId());
|
ruleEntity.setApprovalRuleName(ruleBO.getRuleName());
|
ruleEntity.setDepId(ruleBO.getDepId());
|
ruleEntity.setDepName(ruleBO.getDepName());
|
ruleEntity.setWorkLevel(ruleBO.getWorkLevel());
|
ruleEntity.setWorkType(ruleBO.getWorkType());
|
ruleEntity.setWorkApplyId(applyEntity.getId());
|
|
// step
|
List<WorkApprovalStepInfoBO> ruleStepBOs = new ArrayList<>(ruleSteps.size());
|
WorkApprovalStepInfoBO ruleStepBO;
|
for (int i = 0; i < ruleSteps.size(); i++) {
|
ApprovalRuleStep ruleStep = ruleSteps.get(i);
|
ruleStepBO = new WorkApprovalStepInfoBO();
|
ruleStepBO.setId(IdUtil.getSnowflake(0, 0).nextId());
|
ruleStepBO.setStepSerial(ruleStep.getStepSerial());
|
ruleStepBO.setType(ruleStep.getType());
|
ruleStepBO.setOriginalPreStepId(ruleStep.getPreStepId());
|
ruleStepBO.setWorkApplyId(applyEntity.getId());
|
ruleStepBO.setOriginalId(ruleStep.getStepId());
|
ruleStepBO.setContinueTime(ruleStep.getContinueTime());
|
ruleStepBO.setContinueTimeUnit(ruleStep.getContinueTimeUnit());
|
ruleStepBO.setStepName(ruleStep.getStepName());
|
ruleStepBO.setAuditType(ruleStep.getAuditType());
|
if (ruleStep.getPreStepId() == null) {
|
applyEntity.setApprovalStepId(ruleStepBO.getId());
|
}
|
ruleStepBOs.add(ruleStepBO);
|
if (i == 0) {
|
ruleStepBO.setApprovalResult(WorkApprovalStepResultEnum.RESULT_IN_APPROVAL.getResult());
|
ruleStepBO.setStartApprovalTime(LocalDateTime.now());
|
}else{
|
ruleStepBO.setApprovalResult(WorkApprovalStepResultEnum.WAIT_TO_START.getResult());
|
}
|
|
}
|
// 整理ruleStepEntities
|
if (ruleStepBOs.size() > 1) {
|
ruleStepBOs = this.tidyRuleStepEntities(ruleStepBOs);
|
}
|
|
// 2.unit
|
List<WorkApprovalUnitInfoBO> unitBOs = new ArrayList<>(ruleUnits.size());
|
WorkApprovalUnitInfoBO unitBO;
|
for (int i = 0; i < ruleStepBOs.size(); i++) {
|
WorkApprovalStepInfoBO ruleStepInfo = ruleStepBOs.get(i);
|
List<ApprovalRuleUnit> stepUnits = ruleUnits.stream().filter(approvalRuleUnit ->
|
// 当前层级的单元
|
ruleStepInfo.getOriginalId().equals(approvalRuleUnit.getStepId()))
|
// 集合
|
.collect(Collectors.toList());
|
if (stepUnits.size() == 0) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "层级单元个数为0,请检查审批规则");
|
}
|
for (ApprovalRuleUnit ruleUnit : stepUnits) {
|
unitBO = new WorkApprovalUnitInfoBO();
|
unitBO.setId(IdUtil.getSnowflake(0, 0).nextId());
|
unitBO.setStepId(ruleStepInfo.getId());
|
unitBO.setApprovalUid(ruleUnit.getBindUid());
|
unitBO.setApprovalUname(ruleUnit.getBindUname());
|
unitBO.setOriginalId(ruleUnit.getUnitId());
|
unitBO.setWorkApplyId(applyEntity.getId());
|
// 第一个层级的单元开始审批
|
if (i == 0) {
|
unitBO.setResult(WorkApprovalUnitResultEnum.RESULT_IN_APPROVAL.getResult());
|
}else{
|
unitBO.setResult(WorkApprovalUnitResultEnum.WAIT_TO_START.getResult());
|
}
|
unitBOs.add(unitBO);
|
}
|
}
|
|
// 3.item
|
List<WorkApprovalItemInfoBO> itemBOs = new ArrayList<>(ruleUnitItems.size());
|
WorkApprovalItemInfoBO itemBO;
|
for (WorkApprovalStepInfoBO ruleStepInfo : ruleStepBOs) {
|
List<ApprovalRuleUnitItem> unitItems = ruleUnitItems.stream().filter(ruleUnitItem ->
|
// 当前单元的审批项
|
ruleStepInfo.getOriginalId().equals(ruleUnitItem.getStepId()))
|
// 集合
|
.collect(Collectors.toList());
|
if (unitItems.size() == 0) {
|
// 不包含审批项 <=> 填报单元就行
|
ruleStepInfo.setContainItem(Boolean.FALSE);
|
}else{
|
ruleStepInfo.setContainItem(Boolean.TRUE);
|
for (ApprovalRuleUnitItem unitItem : unitItems) {
|
itemBO = new WorkApprovalItemInfoBO();
|
itemBO.setId(IdUtil.getSnowflake(0, 0).nextId());
|
itemBO.setItemName(unitItem.getItemName());
|
itemBO.setType(unitItem.getType());
|
itemBO.setStepId(ruleStepInfo.getId());
|
itemBO.setOriginalStandId(unitItem.getStandId());
|
itemBO.setOriginalMeasureId(unitItem.getMeasureId());
|
itemBO.setOriginalId(unitItem.getId());
|
itemBO.setWorkApplyId(applyEntity.getId());
|
itemBOs.add(itemBO);
|
}
|
}
|
|
}
|
|
// 4.item measure
|
Set<Long> measureIdSet = new HashSet<>();
|
Set<Long> standIdSet = new HashSet<>();
|
for (WorkApprovalItemInfoBO itemInfo : itemBOs) {
|
// 获取 itemBO 的 measures
|
if (itemInfo.getOriginalMeasureId() != null) {
|
measureIdSet.add(itemInfo.getOriginalMeasureId());
|
}
|
// 获取 itemBO 的 stands
|
if (itemInfo.getOriginalStandId() != null) {
|
standIdSet.add(itemInfo.getOriginalStandId());
|
}
|
}
|
|
List<WorkApprovalItemMeasureInfo> measureEntities = new ArrayList<>(measureIdSet.size());
|
Map<Long, WorkApprovalItemMeasureInfo> measureMap = new HashMap<>(measureIdSet.size());
|
if (measureIdSet.size() > 0) {
|
List<ApprovalRuleItemMeasureDO> measures = approvalRuleItemMeasureService.listItemMeasureByIds(measureIdSet);
|
WorkApprovalItemMeasureInfo measureEntity;
|
for (ApprovalRuleItemMeasureDO measure : measures) {
|
measureEntity = new WorkApprovalItemMeasureInfo();
|
measureEntity.setId(IdUtil.getSnowflake(0, 0).nextId());
|
measureEntity.setContext(measure.getContext());
|
measureEntity.setCorrectVal(measure.getCorrectVal());
|
measureEntity.setType(measure.getType());
|
measureEntity.setWorkType(measure.getWorkType());
|
measureEntity.setWorkApplyId(applyEntity.getId());
|
measureEntities.add(measureEntity);
|
measureMap.put(measure.getId(), measureEntity);
|
}
|
}
|
List<WorkApprovalItemStandInfo> standEntities = new ArrayList<>(standIdSet.size());
|
Map<Long, WorkApprovalItemStandInfo> standMap = new HashMap<>(standIdSet.size());
|
if (standIdSet.size() > 0) {
|
List<ApprovalRuleItemStandDO> stands = approvalRuleStandService.listItemStandByIds(standIdSet);
|
WorkApprovalItemStandInfo standEntity;
|
for (ApprovalRuleItemStandDO stand : stands) {
|
standEntity = new WorkApprovalItemStandInfo();
|
standEntity.setId(IdUtil.getSnowflake(0, 0).nextId());
|
standEntity.setDepId(stand.getDepId());
|
standEntity.setMaxVal(stand.getMaxVal());
|
standEntity.setMaxValMatchPattern(stand.getMaxValMatchPattern());
|
standEntity.setMinVal(stand.getMinVal());
|
standEntity.setMinValMatchPattern(stand.getMinValMatchPattern());
|
standEntity.setTitle(stand.getTitle());
|
standEntity.setType(stand.getType());
|
standEntity.setWorkApplyId(applyEntity.getId());
|
standEntities.add(standEntity);
|
standMap.put(stand.getId(), standEntity);
|
|
}
|
}
|
|
for (WorkApprovalItemInfoBO itemInfo : itemBOs) {
|
if (itemInfo.getOriginalMeasureId() != null) {
|
WorkApprovalItemMeasureInfo measureInfo = measureMap.get(itemInfo.getOriginalMeasureId());
|
if (measureInfo != null) {
|
itemInfo.setMeasureId(measureInfo.getId());
|
}
|
}
|
if (itemInfo.getOriginalStandId() != null) {
|
WorkApprovalItemStandInfo standInfo = standMap.get(itemInfo.getOriginalStandId());
|
if (standInfo != null) {
|
itemInfo.setStandId(standInfo.getId());
|
}
|
}
|
}
|
|
//数据库入库
|
// execute
|
|
//加分布式锁
|
RLock lock = redissonClient.getLock("LOCK_WORK_APPLY");
|
try {
|
lock.lock(10, TimeUnit.SECONDS);
|
//生成作业编号
|
int workCount = workApplyInfoService.countWorkApplyInfo();
|
applyEntity.setWorkPermitNo(this.generateWorkCode(workCount));
|
|
// 八大作业子表
|
WorkTypeMatchDetailSave(workTypeEnum,applyEntity, applyReqDTO.getWorkDetail(),currentUser);
|
// 作业申请
|
workApplyInfoService.saveWorkApplyInfo(applyEntity);
|
// // 操作人
|
// workApplyOperatorInfoService.saveBatchOperator(operatorEntities);
|
// 规则
|
workApprovalRuleInfoService.saveRule(ruleEntity);
|
// 层级
|
workApprovalStepInfoService.saveBatchRuleStep(ruleStepBOs.stream().map(
|
// 强转实体类
|
item -> (WorkApprovalStepInfo) item)
|
// 集合
|
.collect(Collectors.toList()));
|
// 单元
|
workApprovalUnitInfoService.saveBatchRuleUnit(unitBOs.stream().map(
|
// 强转实体类
|
item -> (WorkApprovalUnitInfo) item)
|
// 集合
|
.collect(Collectors.toList()));
|
|
// 审批项
|
if (itemBOs.size() > 0) {
|
workApprovalItemInfoService.saveBatchRuleItem(itemBOs.stream().map(
|
// 强转实体类
|
item -> (WorkApprovalItemInfo) item)
|
// 集合
|
.collect(Collectors.toList()));
|
}
|
|
// 安全措施
|
if (measureEntities.size() > 0) {
|
workApprovalItemMeasureInfoService.saveBatchMeasure(measureEntities);
|
}
|
// 标准
|
if (standEntities.size() > 0) {
|
workApprovalItemStandInfoService.saveBatchStand(standEntities);
|
}
|
|
workApplyRecordService.log(currentUser, ProcessOperationEnum.APPLY, applyEntity.getId(), null, null, null);
|
//创建成功，释放锁
|
lock.unlock();
|
//发送延时消息
|
ApplySpecialWorkMsg applySpecialWorkMsg = new ApplySpecialWorkMsg();
|
applySpecialWorkMsg.setWorkApplyId(applyEntity.getId());
|
applySpecialWorkMsg.setExpStartTime(conversionTimeType(applyEntity.getExpStartTime()));
|
approvalWorkRocketMQService.syncSend(applySpecialWorkMsg);
|
} 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();
|
}
|
}
|
}
|
|
private void WorkTypeMatchDetailSave(WorkTypeEnum workTypeEnum,WorkApplyInfo applyEntity, Object workDetail,ContextCacheUser currentUser) {
|
switch (workTypeEnum) {
|
case WORK_FIRE:
|
if (workDetail instanceof WorkApplyHotReqDTO) {
|
WorkApplyHotReqDTO workApplyHotReqDTO = ((WorkApplyHotReqDTO) workDetail);
|
WorkHotInfo workHotInfo = new WorkHotInfo();
|
workHotInfo.setWorkApplyId(applyEntity.getId());
|
workHotInfo.setId(IdUtil.getSnowflake(0,0).nextId());
|
workHotInfo.setHotMethod(workApplyHotReqDTO.getHotMethod());
|
workHotInfo.setOtherSpecialWork(workApplyHotReqDTO.getOtherSpecialWork());
|
workHotInfoService.save(workHotInfo);
|
applyEntity.setWorkDetailId(workHotInfo.getId());
|
}
|
break;
|
case WORK_HANG:
|
if (workDetail instanceof WorkApplyHoistingReqDTO) {
|
WorkApplyHoistingReqDTO reqDTO = ((WorkApplyHoistingReqDTO) workDetail);
|
WorkHoistingInfo vo = new WorkHoistingInfo();
|
vo.setWorkApplyId(applyEntity.getId());
|
vo.setId(IdUtil.getSnowflake(0,0).nextId());
|
vo.setHoistingToolName(reqDTO.getHoistingToolName());
|
vo.setWeightMass(reqDTO.getWeightMass());
|
workHoistingInfoService.save(vo);
|
applyEntity.setWorkDetailId(vo.getId());
|
}
|
break;
|
case WORK_DIF_SOLI:
|
if (workDetail instanceof WorkApplyGroundBreakingReqDTO) {
|
WorkApplyGroundBreakingReqDTO reqDTO = ((WorkApplyGroundBreakingReqDTO) workDetail);
|
WorkGroundBreakingInfo vo = new WorkGroundBreakingInfo();
|
vo.setWorkApplyId(applyEntity.getId());
|
vo.setId(IdUtil.getSnowflake(0,0).nextId());
|
vo.setOperationDepId(reqDTO.getOperationDepId());
|
vo.setGbMethod(reqDTO.getGbMethod());
|
vo.setGbScope(reqDTO.getGbScope());
|
vo.setGbPath(reqDTO.getGbPath());
|
vo.setOtherSpecialWork(reqDTO.getOtherSpecialWork());
|
workGroundBreakingInfoService.save(vo);
|
applyEntity.setWorkDetailId(vo.getId());
|
}
|
break;
|
case WORK_BROKE_ROAD:
|
if (workDetail instanceof WorkApplyBrokenCircuitReqDTO) {
|
WorkApplyBrokenCircuitReqDTO reqDTO = ((WorkApplyBrokenCircuitReqDTO) workDetail);
|
WorkBrokenCircuitInfo vo = new WorkBrokenCircuitInfo();
|
vo.setWorkApplyId(applyEntity.getId());
|
vo.setId(IdUtil.getSnowflake(0,0).nextId());
|
vo.setOperationDepId(reqDTO.getOperationDepId());
|
vo.setBcReason(reqDTO.getBcReason());
|
vo.setBcExplain(reqDTO.getBcExplain());
|
vo.setBcPath(reqDTO.getBcPath());
|
vo.setInvolvedDepIds(reqDTO.getInvolvedDepIds());
|
workBrokenCircuitInfoService.save(vo);
|
applyEntity.setWorkDetailId(vo.getId());
|
}
|
break;
|
case WORK_HIGH_SPACE:
|
if (workDetail instanceof WorkApplyAtHighReqDTO) {
|
WorkApplyAtHighReqDTO reqDTO = ((WorkApplyAtHighReqDTO) workDetail);
|
WorkAtHeightInfo vo = new WorkAtHeightInfo();
|
vo.setWorkApplyId(applyEntity.getId());
|
vo.setId(IdUtil.getSnowflake(0,0).nextId());
|
vo.setOperationDepId(reqDTO.getOperationDepId());
|
vo.setOperationHeight(reqDTO.getOperationHeight());
|
vo.setOtherSpecialWork(reqDTO.getOtherSpecialWork());
|
workAtHeightInfoService.save(vo);
|
applyEntity.setWorkDetailId(vo.getId());
|
}
|
break;
|
case WORK_BLIND_PLATE:
|
if (workDetail instanceof WorkApplyBlindPlatePluggingReqDTO) {
|
WorkApplyBlindPlatePluggingReqDTO reqDTO = ((WorkApplyBlindPlatePluggingReqDTO) workDetail);
|
WorkBlindPlatePluggingInfo vo = new WorkBlindPlatePluggingInfo();
|
vo.setWorkApplyId(applyEntity.getId());
|
vo.setId(IdUtil.getSnowflake(0,0).nextId());
|
vo.setBpCode(reqDTO.getBpCode());
|
vo.setMainMedia(reqDTO.getMainMedia());
|
vo.setTemperature(reqDTO.getTemperature());
|
vo.setPressure(reqDTO.getPressure());
|
vo.setBpMaterialQuality(reqDTO.getBpMaterialQuality());
|
vo.setBpSpecification(reqDTO.getBpSpecification());
|
vo.setBpLocation(reqDTO.getBpLocation());
|
vo.setBpLocationMapPath(reqDTO.getBpLocationMapPath());
|
vo.setInstallBpTime(reqDTO.getInstallBpTime());
|
vo.setUninstallBpTime(reqDTO.getUninstallBpTime());
|
vo.setOtherSpecialWork(reqDTO.getOtherSpecialWork());
|
workBlindPlatePluggingInfoService.save(vo);
|
applyEntity.setWorkDetailId(vo.getId());
|
}
|
break;
|
case WORK_CLOSE_SPACE:
|
if (workDetail instanceof WorkApplyConfinedSpaceReqDTO) {
|
WorkApplyConfinedSpaceReqDTO reqDTO = ((WorkApplyConfinedSpaceReqDTO) workDetail);
|
WorkConfinedSpaceInfo vo = new WorkConfinedSpaceInfo();
|
vo.setWorkApplyId(applyEntity.getId());
|
vo.setId(IdUtil.getSnowflake(0,0).nextId());
|
vo.setCsDepId(reqDTO.getCsDepId());
|
vo.setCsName(reqDTO.getCsName());
|
vo.setCsOriginalName(reqDTO.getCsOriginalName());
|
vo.setOtherSpecialWork(reqDTO.getOtherSpecialWork());
|
workConfinedSpaceInfoService.save(vo);
|
applyEntity.setWorkDetailId(vo.getId());
|
}
|
break;
|
case WORK_TEMP_ELECTRIC:
|
if (workDetail instanceof WorkApplyTemporaryPowerReqDTO) {
|
WorkApplyTemporaryPowerReqDTO reqDTO = ((WorkApplyTemporaryPowerReqDTO) workDetail);
|
WorkTemporaryPowerInfo vo = new WorkTemporaryPowerInfo();
|
vo.setWorkApplyId(applyEntity.getId());
|
vo.setId(IdUtil.getSnowflake(0,0).nextId());
|
vo.setPowerAccessPoint(reqDTO.getPowerAccessPoint());
|
vo.setWorkingVoltage(reqDTO.getWorkingVoltage());
|
vo.setEquipmentAndPower(reqDTO.getEquipmentAndPower());
|
workTemporaryPowerInfoService.save(vo);
|
applyEntity.setWorkDetailId(vo.getId());
|
}
|
break;
|
default:
|
{
|
throw new RuntimeException();
|
}
|
// throw new BusinessException(ResultCodes.SERVER_ERROR);
|
}
|
}
|
|
private void WorkTypeMatchDetailCheck(WorkTypeEnum workTypeEnum, Object workDetail) {
|
switch (workTypeEnum) {
|
case WORK_FIRE:
|
if (workDetail instanceof WorkApplyHotReqDTO) {
|
checkHotReqDTO((WorkApplyHotReqDTO) workDetail);
|
}
|
break;
|
case WORK_CLOSE_SPACE:
|
if (workDetail instanceof WorkApplyConfinedSpaceReqDTO) {
|
checkConfinedSpaceReqDTO((WorkApplyConfinedSpaceReqDTO) workDetail);
|
}
|
case WORK_HANG:
|
if (workDetail instanceof WorkApplyHoistingReqDTO) {
|
checkHostingReqDTO((WorkApplyHoistingReqDTO) workDetail);
|
}
|
break;
|
case WORK_DIF_SOLI:
|
if (workDetail instanceof WorkApplyGroundBreakingReqDTO) {
|
checkGroundBreakingReqDTO((WorkApplyGroundBreakingReqDTO) workDetail);
|
}
|
break;
|
case WORK_BROKE_ROAD:
|
if (workDetail instanceof WorkApplyBrokenCircuitReqDTO) {
|
checkBrokenCircuitReqDTO((WorkApplyBrokenCircuitReqDTO) workDetail);
|
}
|
break;
|
case WORK_HIGH_SPACE:
|
if (workDetail instanceof WorkApplyAtHighReqDTO) {
|
checkAtHighReqDTO((WorkApplyAtHighReqDTO) workDetail);
|
}
|
break;
|
case WORK_TEMP_ELECTRIC:
|
if (workDetail instanceof WorkApplyTemporaryPowerReqDTO) {
|
checkTemporaryPowerReqDTO((WorkApplyTemporaryPowerReqDTO) workDetail);
|
}
|
break;
|
case WORK_BLIND_PLATE:
|
if (workDetail instanceof WorkApplyBlindPlatePluggingReqDTO) {
|
checkBlindPlatePluggingReqDTO((WorkApplyBlindPlatePluggingReqDTO) workDetail);
|
}
|
break;
|
|
}
|
}
|
//动土作业
|
private void checkGroundBreakingReqDTO(WorkApplyGroundBreakingReqDTO workDetail) {
|
if(null == workDetail.getOperationDepId()){
|
throw new BusinessException(E.DATA_PARAM_NULL, "作业单位不能为空");
|
}
|
ResultVO<DepInfoRPCRespDTO> resultVO = accountDepartmentService.getDepInfoByDepId(null,workDetail.getOperationDepId());
|
DepInfoRPCRespDTO depInfoByDepId= (DepInfoRPCRespDTO)resultVO.getData();
|
if (null == depInfoByDepId) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "作业单位不存在");
|
}
|
if(StringUtils.isBlank(workDetail.getGbScope())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "动土范围不能为空");
|
}
|
if(null == workDetail.getGbMethod()){
|
throw new BusinessException(E.DATA_PARAM_NULL, "动土方式不能为空");
|
}
|
if(StringUtils.isBlank(workDetail.getGbPath())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "图片路径不能为空");
|
}
|
}
|
|
//临时用电作业
|
private void checkTemporaryPowerReqDTO(WorkApplyTemporaryPowerReqDTO workDetail) {
|
if(StringUtils.isBlank(workDetail.getPowerAccessPoint())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "电源接入点不能为空");
|
}
|
if(null == workDetail.getWorkingVoltage()){
|
throw new BusinessException(E.DATA_PARAM_NULL, "起吊物体质量不能为空");
|
}
|
if(StringUtils.isBlank(workDetail.getEquipmentAndPower())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "用电设备及功率不能为空");
|
}
|
}
|
|
//吊装作业
|
private void checkHostingReqDTO(WorkApplyHoistingReqDTO workDetail) {
|
if(StringUtils.isBlank(workDetail.getHoistingToolName())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "吊装工具名称不能为空");
|
}
|
if(null == workDetail.getWeightMass()){
|
throw new BusinessException(E.DATA_PARAM_NULL, "起吊物体质量不能为空");
|
}
|
}
|
|
//断路作业
|
private void checkBrokenCircuitReqDTO(WorkApplyBrokenCircuitReqDTO workDetail) {
|
if(null == workDetail.getOperationDepId()){
|
throw new BusinessException(E.DATA_PARAM_NULL, "作业单位不能为空");
|
}
|
ResultVO<DepInfoRPCRespDTO> resultVO = accountDepartmentService.getDepInfoByDepId(null,workDetail.getOperationDepId());
|
DepInfoRPCRespDTO depInfoByDepId= (DepInfoRPCRespDTO)resultVO.getData();
|
if (null == depInfoByDepId) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "作业单位不存在");
|
}
|
if(StringUtils.isBlank(workDetail.getBcReason())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "断路地段原因不能为空");
|
}
|
if(StringUtils.isBlank(workDetail.getBcExplain())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "断路地段说明不能为空");
|
}
|
// todo 图片上传
|
if(StringUtils.isBlank(workDetail.getBcPath())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "断路地段图片路径不能为空");
|
}
|
if(StringUtils.isBlank(workDetail.getInvolvedDepIds())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "涉及相关部门不能为空");
|
}
|
}
|
|
//高处作业
|
private void checkAtHighReqDTO(WorkApplyAtHighReqDTO workDetail) {
|
if(null == workDetail.getOperationDepId()){
|
throw new BusinessException(E.DATA_PARAM_NULL, "作业单位不能为空");
|
}
|
ResultVO<DepInfoRPCRespDTO> resultVO = accountDepartmentService.getDepInfoByDepId(null,workDetail.getOperationDepId());
|
DepInfoRPCRespDTO depInfoByDepId= (DepInfoRPCRespDTO)resultVO.getData();
|
if (null == depInfoByDepId) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "作业单位不存在");
|
}
|
if(null == workDetail.getOperationHeight()){
|
throw new BusinessException(E.DATA_PARAM_NULL, "作业高度不能为空");
|
}
|
}
|
|
//盲板抽都作业
|
private void checkBlindPlatePluggingReqDTO(WorkApplyBlindPlatePluggingReqDTO workDetail) {
|
if(StringUtils.isBlank(workDetail.getBpCode())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "盲板编号不能为空");
|
}
|
if(StringUtils.isBlank(workDetail.getMainMedia())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "主要介质不能为空");
|
}
|
if(null == workDetail.getTemperature()){
|
throw new BusinessException(E.DATA_PARAM_NULL, "温度不能为空");
|
}
|
if(null == workDetail.getPressure()){
|
throw new BusinessException(E.DATA_PARAM_NULL, "压力不能为空");
|
}
|
if(StringUtils.isBlank(workDetail.getBpMaterialQuality())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "盲板材质不能为空");
|
}
|
if(StringUtils.isBlank(workDetail.getBpSpecification())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "盲板规格不能为空");
|
}
|
if(StringUtils.isBlank(workDetail.getBpLocation())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "盲板位置不能为空");
|
}
|
if(StringUtils.isBlank(workDetail.getBpLocationMapPath())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "盲板位置图路径不能为空");
|
}
|
if(null == workDetail.getInstallBpTime()){
|
throw new BusinessException(E.DATA_PARAM_NULL, "装盲板时间不能为空");
|
}
|
if(null == workDetail.getUninstallBpTime()){
|
throw new BusinessException(E.DATA_PARAM_NULL, "拆盲板时间不能为空");
|
}
|
|
|
|
}
|
|
//受限空间验证
|
private void checkConfinedSpaceReqDTO(WorkApplyConfinedSpaceReqDTO workDetail) {
|
// 受限空间所属单位
|
if(null == workDetail.getCsDepId()){
|
throw new BusinessException(E.DATA_PARAM_NULL, "受限空间所属单位不能为空");
|
}
|
ResultVO<DepInfoRPCRespDTO> resultVO = accountDepartmentService.getDepInfoByDepId(null,workDetail.getCsDepId());
|
DepInfoRPCRespDTO depInfoByDepId= (DepInfoRPCRespDTO)resultVO.getData();
|
if (null == depInfoByDepId) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "受限空间所属单位不存在");
|
}
|
// 受限空间名称
|
if (StringUtils.isBlank(workDetail.getCsName())) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "受限空间名称不能为空");
|
}
|
// 受限空间内原有介质名称
|
if (StringUtils.isBlank(workDetail.getCsOriginalName())) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "受限空间内原有介质名称不能为空");
|
}
|
|
}
|
|
private void checkHotReqDTO(WorkApplyHotReqDTO workDetail) {
|
// 动火方式
|
if (StringUtils.isBlank(workDetail.getHotMethod())) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "动火方式不能为空");
|
}
|
|
}
|
|
@Override
|
@Transactional
|
public void cancelWorkApply(ContextCacheUser currentUser, Long workApplyId) {
|
if (workApplyId == null) {
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
WorkApplyInfo workApplyInfo = workApplyInfoService.getById(workApplyId);
|
if (workApplyInfo == null) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "作业申请不存在");
|
}
|
if (!workApplyInfo.getApplyUid().equals(currentUser.getUid())) {
|
throw new BusinessException(E.DATA_OPERATION_NO_PERMISSION, "需要本人取消申请");
|
}
|
if (!workApplyInfo.getStatus().equals(WorkStatusEnum.STATU_IN_APPROVAL.getStatus())) {
|
throw new BusinessException(E.DATA_STATUS_CHECK_INVALID, "申请单只有在审批中状态时才可以退回");
|
}
|
|
List<WorkApprovalUnitInfo> currentStepUnits = workApprovalUnitInfoService.listApprovalRuleUnitByStepId(workApplyInfo.getApprovalStepId());
|
List<Long> unitIds= currentStepUnits.stream().filter(unit ->
|
unit.getResult().equals(WorkApprovalUnitResultEnum.RESULT_IN_APPROVAL.getResult()) ||
|
unit.getResult().equals(WorkApprovalUnitResultEnum.RESULT_AUTO_REJECT.getResult()))
|
// id
|
.map(WorkApprovalUnitInfo::getId)
|
// 集合
|
.collect(Collectors.toList());
|
if (unitIds.size() > 0) {
|
// 单元审批中断
|
workApprovalUnitInfoService.updateStatusByIds(unitIds, WorkApprovalUnitResultEnum.RESULT_INTERRUPTED);
|
}
|
// 审批层级终止
|
workApprovalStepInfoService.updateStatusById(workApplyInfo.getApprovalStepId(),WorkApprovalStepResultEnum.RESULT_ABORD);
|
|
// 作业取消
|
workApplyInfoService.updateStatusById(workApplyId,WorkStatusEnum.STATU_APPLY_CANCEL);
|
// 操作记录
|
WorkApprovalStepInfo currentStep = workApprovalStepInfoService.getById(workApplyInfo.getApprovalStepId());
|
workApplyRecordService.log(currentUser, ProcessOperationEnum.CANCEL, workApplyId, workApplyInfo.getApprovalStepId(), currentStep.getStepName(), null);
|
|
}
|
|
@Override
|
public ResultVO<List<WorkApplyPageRespDTO>> listApplyingWorkApplyByPage(ContextCacheUser currentUser, PageQuery<WorkApplyApplyingPageQuery> pageQuery) {
|
// 申请
|
WorkApplyApplyingPageDBQuery dbQuery = new WorkApplyApplyingPageDBQuery();
|
if (pageQuery.getSearchParams() != null) {
|
dbQuery.setStartTime(pageQuery.getSearchParams().getStartTime());
|
dbQuery.setEndTime(pageQuery.getSearchParams().getEndTime());
|
dbQuery.setStatus(pageQuery.getSearchParams().getStatus());
|
dbQuery.setWorkType(pageQuery.getSearchParams().getWorkType());
|
}
|
dbQuery.setApplyUid(currentUser.getUid());
|
Page<WorkApplyInfo> page = new Page<>(pageQuery.getPageIndex(), pageQuery.getPageSize());
|
List<WorkApplyInfo> dbData = workApplyInfoService.listWorkApplyInfoByPage(page, dbQuery);
|
List<WorkApplyPageRespDTO> respDTOs = new ArrayList<>(dbData.size());
|
WorkStatusEnum statusEnum;
|
WorkLevelEnum levelEnum;
|
WorkTypeEnum workTypeEnum;
|
// List<WorkApplyOperatorRespDTO> operatorRespDTOs;
|
// WorkApplyOperatorRespDTO operatorRespDTO;
|
for (WorkApplyInfo workApplyInfo : dbData) {
|
WorkApplyPageRespDTO respDTO = new WorkApplyPageRespDTO();
|
respDTO.setWorkApplyId(workApplyInfo.getId());
|
respDTO.setWorkPermitNo(workApplyInfo.getWorkPermitNo());
|
respDTO.setWorkContent(workApplyInfo.getWorkContent());
|
respDTO.setWorkLocation(workApplyInfo.getWorkLocation());
|
respDTO.setHazardIdentification(workApplyInfo.getHazardIdentification());
|
respDTO.setDepId(workApplyInfo.getDepId());
|
respDTO.setDepName(workApplyInfo.getDepName());
|
respDTO.setApplyTime(workApplyInfo.getApplyTime());
|
respDTO.setApplyUid(workApplyInfo.getApplyUid());
|
respDTO.setApplyUname(workApplyInfo.getApplyUname());
|
respDTO.setApprovalStepId(workApplyInfo.getApprovalStepId());
|
respDTO.setExpEndTime(workApplyInfo.getExpEndTime());
|
respDTO.setExpStartTime(workApplyInfo.getExpStartTime());
|
respDTO.setGmtCreate(workApplyInfo.getGmtCreate());
|
respDTO.setGmtModified(workApplyInfo.getGmtModified());
|
respDTO.setStatus(workApplyInfo.getStatus());
|
statusEnum = WorkStatusEnum.parse(workApplyInfo.getStatus());
|
if (statusEnum != null) {
|
respDTO.setStatusDesc(statusEnum.getDesc());
|
}
|
respDTO.setWorkLevel(workApplyInfo.getWorkLevel());
|
levelEnum = WorkLevelEnum.parse(workApplyInfo.getWorkLevel());
|
if (levelEnum != null) {
|
respDTO.setWorkLevelDesc(levelEnum.getTitle());
|
}
|
respDTO.setWorkType(workApplyInfo.getWorkType());
|
workTypeEnum = WorkTypeEnum.parse(workApplyInfo.getWorkType());
|
if (workTypeEnum != null) {
|
respDTO.setWorkTypeDesc(workTypeEnum.getName());
|
}
|
// 操作人
|
respDTO.setOperatorUnames(workApplyInfo.getOperatorUnames());
|
respDTO.setOperatorCompanys(workApplyInfo.getOperatorCompanys());
|
// List<WorkApplyOperatorInfo> operators = workApplyOperatorInfoService.listWorkOperatorByWorkApplyId(workApplyInfo.getId());
|
// operatorRespDTOs = new ArrayList<>(operators.size());
|
// for (WorkApplyOperatorInfo operator : operators) {
|
// operatorRespDTO = new WorkApplyOperatorRespDTO();
|
// operatorRespDTO.setId(operator.getId());
|
// operatorRespDTO.setOperatorUid(operator.getOperatorUid());
|
// operatorRespDTO.setOperatorUname(operator.getOperatorUname());
|
// operatorRespDTO.setOperatorCertificate(operator.getOperatorCertificate());
|
// operatorRespDTO.setOperatorPhone(operator.getOperatorPhone());
|
// operatorRespDTO.setOperatorIdentify(operator.getOperatorIdentify());
|
// operatorRespDTO.setWorkApplyId(operator.getWorkApplyId());
|
// operatorRespDTOs.add(operatorRespDTO);
|
// }
|
// respDTO.setOperators(operatorRespDTOs);
|
// 八大作业
|
if (workTypeEnum != null) {
|
Object workDetail = this.getWorkDetail(workTypeEnum, workApplyInfo.getId(), workApplyInfo.getWorkDetailId());
|
if (workDetail != null) {
|
respDTO.setWorkDetail(workDetail);
|
}
|
}
|
respDTOs.add(respDTO);
|
}
|
return new SearchResultVO<>(true,
|
page.getCurrent(),
|
page.getSize(),
|
page.getPages(),
|
page.getTotal(),
|
respDTOs,
|
ResultCodes.OK);
|
}
|
|
@Override
|
public ResultVO<List<WorkApplyPendingPageRespDTO>> listPendingWorkApplyByPage(ContextCacheUser currentUser, PageQuery<WorkApplyPendingPageQuery> pageQuery) {
|
|
WorkApplyPendingPageDBQuery dbQuery = new WorkApplyPendingPageDBQuery();
|
if (pageQuery.getSearchParams() != null) {
|
dbQuery.setStartTime(pageQuery.getSearchParams().getStartTime());
|
dbQuery.setEndTime(pageQuery.getSearchParams().getEndTime());
|
dbQuery.setApplyUname(pageQuery.getSearchParams().getApplyUname());
|
dbQuery.setWorkType(pageQuery.getSearchParams().getWorkType());
|
}
|
dbQuery.setApprovalUid(currentUser.getUid());
|
Page<WorkApplyPendingInfoBO> page = new Page<>(pageQuery.getPageIndex(), pageQuery.getPageSize());
|
List<WorkApplyPendingInfoBO> dbData = workApplyInfoService.listPendingWorkApplyInfo(page, dbQuery);
|
List<WorkApplyPendingPageRespDTO> respDTOs = new ArrayList<>(dbData.size());
|
WorkApplyPendingPageRespDTO respDTO;
|
WorkStatusEnum statusEnum;
|
ApprovalStepTypeEnum stepTypeEnum;
|
WorkApprovalStepResultEnum stepResultEnum;
|
WorkApprovalUnitResultEnum unitResultEnum;
|
WorkLevelEnum levelEnum;
|
WorkTypeEnum workTypeEnum;
|
// List<WorkApplyOperatorRespDTO> operatorRespDTOs;
|
// WorkApplyOperatorRespDTO operatorRespDTO;
|
for (WorkApplyPendingInfoBO workApplyInfoBO : dbData) {
|
respDTO = new WorkApplyPendingPageRespDTO();
|
// work
|
respDTO.setWorkApplyId(workApplyInfoBO.getWorkApplyId());
|
respDTO.setWorkLevel(workApplyInfoBO.getWorkLevel());
|
levelEnum = WorkLevelEnum.parse(workApplyInfoBO.getWorkLevel());
|
if (levelEnum != null) {
|
respDTO.setWorkLevelDesc(levelEnum.getTitle());
|
}
|
respDTO.setWorkType(workApplyInfoBO.getWorkType());
|
workTypeEnum = WorkTypeEnum.parse(workApplyInfoBO.getWorkType());
|
if (workTypeEnum != null) {
|
respDTO.setWorkTypeDesc(workTypeEnum.getName());
|
}
|
respDTO.setWorkPermitNo(workApplyInfoBO.getWorkPermitNo());
|
respDTO.setWorkContent(workApplyInfoBO.getWorkContent());
|
respDTO.setWorkLocation(workApplyInfoBO.getWorkLocation());
|
respDTO.setHazardIdentification(workApplyInfoBO.getHazardIdentification());
|
respDTO.setDepId(workApplyInfoBO.getDepId());
|
respDTO.setDepName(workApplyInfoBO.getDepName());
|
respDTO.setApplyTime(workApplyInfoBO.getApplyTime());
|
respDTO.setApplyUid(workApplyInfoBO.getApplyUid());
|
respDTO.setApplyUname(workApplyInfoBO.getApplyUname());
|
respDTO.setApprovalStepId(workApplyInfoBO.getApprovalStepId());
|
respDTO.setExpEndTime(workApplyInfoBO.getExpEndTime());
|
respDTO.setExpStartTime(workApplyInfoBO.getExpStartTime());
|
respDTO.setGmtCreate(workApplyInfoBO.getGmtCreate());
|
respDTO.setGmtModified(workApplyInfoBO.getGmtModified());
|
respDTO.setStatus(workApplyInfoBO.getStatus());
|
statusEnum = WorkStatusEnum.parse(workApplyInfoBO.getStatus());
|
if (statusEnum != null) {
|
respDTO.setStatusDesc(statusEnum.getDesc());
|
}
|
// step
|
respDTO.setStepId(workApplyInfoBO.getStepId());
|
respDTO.setStepExpFinishApprovalTime(workApplyInfoBO.getStepExpFinishApprovalTime());
|
respDTO.setStepFinishApprovalTime(workApplyInfoBO.getStepFinishApprovalTime());
|
respDTO.setStepStartApprovalTime(workApplyInfoBO.getStepStartApprovalTime());
|
respDTO.setStepApprovalResult(workApplyInfoBO.getStepApprovalResult());
|
respDTO.setNextStepId(workApplyInfoBO.getNextStepId());
|
respDTO.setPreStepId(workApplyInfoBO.getPreStepId());
|
respDTO.setStepContainItem(workApplyInfoBO.getContainItem());
|
stepResultEnum = WorkApprovalStepResultEnum.parse(workApplyInfoBO.getStepApprovalResult());
|
if (stepResultEnum != null) {
|
respDTO.setStepApprovalResultDesc(stepResultEnum.getDesc());
|
}
|
respDTO.setStepType(workApplyInfoBO.getStepType());
|
stepTypeEnum = ApprovalStepTypeEnum.parse(workApplyInfoBO.getStepType());
|
if (stepTypeEnum != null) {
|
respDTO.setStepTypeDesc(stepTypeEnum.getDesc());
|
}
|
// unit
|
respDTO.setUnitId(workApplyInfoBO.getUnitId());
|
respDTO.setUnitApprovalUid(workApplyInfoBO.getUnitApprovalUid());
|
respDTO.setUnitApprovalUname(workApplyInfoBO.getUnitApprovalUname());
|
respDTO.setUnitApprovalEndTime(workApplyInfoBO.getUnitApprovalEndTime());
|
respDTO.setUnitApprovalStartTime(workApplyInfoBO.getUnitApprovalStartTime());
|
respDTO.setUnitApprovalActualTime(workApplyInfoBO.getUnitApprovalActualTime());
|
respDTO.setUnitResult(workApplyInfoBO.getUnitResult());
|
respDTO.setUnitFilledContent(workApplyInfoBO.getUnitFillContent());
|
unitResultEnum = WorkApprovalUnitResultEnum.parse(workApplyInfoBO.getUnitResult());
|
if (unitResultEnum != null) {
|
respDTO.setUnitResultDesc(unitResultEnum.getDesc());
|
}
|
// 操作人
|
respDTO.setOperatorUnames(workApplyInfoBO.getOperatorUnames());
|
respDTO.setOperatorCompanys(workApplyInfoBO.getOperatorCompanys());
|
// List<WorkApplyOperatorInfo> operators = workApplyOperatorInfoService.listWorkOperatorByWorkApplyId(workApplyInfoBO.getWorkApplyId());
|
// operatorRespDTOs = new ArrayList<>(operators.size());
|
// for (WorkApplyOperatorInfo operator : operators) {
|
// operatorRespDTO = new WorkApplyOperatorRespDTO();
|
// operatorRespDTO.setId(operator.getId());
|
// operatorRespDTO.setOperatorUid(operator.getOperatorUid());
|
// operatorRespDTO.setOperatorUname(operator.getOperatorUname());
|
// operatorRespDTO.setOperatorCertificate(operator.getOperatorCertificate());
|
// operatorRespDTO.setOperatorPhone(operator.getOperatorPhone());
|
// operatorRespDTO.setOperatorIdentify(operator.getOperatorIdentify());
|
// operatorRespDTO.setWorkApplyId(operator.getWorkApplyId());
|
// operatorRespDTOs.add(operatorRespDTO);
|
// }
|
// respDTO.setOperators(operatorRespDTOs);
|
|
// 八大作业
|
if (workTypeEnum != null) {
|
Object workDetail = this.getWorkDetail(workTypeEnum, workApplyInfoBO.getWorkApplyId(), workApplyInfoBO.getWorkDetailId());
|
if (workDetail != null) {
|
respDTO.setWorkDetail(workDetail);
|
}
|
}
|
respDTOs.add(respDTO);
|
}
|
|
return new SearchResultVO<>(true,
|
page.getCurrent(),
|
page.getSize(),
|
page.getPages(),
|
page.getTotal(),
|
respDTOs,
|
ResultCodes.OK);
|
}
|
|
|
@Override
|
public ApplicantWorkApprovedApplyDetailRespDTO getApprovedApplyDetailForApplicant(ContextCacheUser currentUser, Long workApplyId) {
|
if (workApplyId == null) {
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
WorkApplyInfo workApplyInfo = workApplyInfoService.getById(workApplyId);
|
if (workApplyInfo == null) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "作业申请不存在");
|
}
|
if (!workApplyInfo.getApplyUid().equals(currentUser.getUid())) {
|
throw new BusinessException(E.DATA_OPERATION_NO_PERMISSION, "你不是作业申请人");
|
}
|
// if (workApplyInfo.getStatus().equals(WorkStatusEnum.STATU_IN_APPLY.getStatus())) {
|
// throw new BusinessException(E.DATA_STATUS_CHECK_INVALID, "作业还未审批");
|
// }
|
|
// 结果 result
|
ApplicantWorkApprovedApplyDetailRespDTO result = new ApplicantWorkApprovedApplyDetailRespDTO();
|
// // 获取作业人
|
// List<WorkApplyOperatorInfo> operators = workApplyOperatorInfoService.listWorkOperatorByWorkApplyId(workApplyId);
|
// 获取层级
|
List<WorkApprovalStepInfo> steps = workApprovalStepInfoService.listApprovalRuleStepByWorkApplyId(workApplyId);
|
// 获取单元
|
List<WorkApprovalUnitInfo> units = workApprovalUnitInfoService.listApprovalRuleUnitByWorkApplyId(workApplyId);
|
// 获取审批项
|
List<WorkApprovalItemInfo> items = workApprovalItemInfoService.listWorkApprovalItemByWorkApplyId(workApplyId);
|
// 获取已经填报审批项
|
List<WorkApprovalFilledItemInfo> filledItems = workApprovalFilledItemInfoService.listApprovalFilledItemInfoByWorkApplyId(workApplyId);
|
// 获取标准
|
List<WorkApprovalItemStandInfo> stands = workApprovalItemStandInfoService.listWorkApprovalItemStandByWorkApplyId(workApplyId);
|
// 获取措施
|
List<WorkApprovalItemMeasureInfo> measures = workApprovalItemMeasureInfoService.listWorkApprovalItemMeasureByWorkApplyId(workApplyId);
|
|
// 措施处理映射
|
Map<Long, ApplicantWorkApprovalItemMeasureRespDTO> measureMap = new HashMap<>(measures.size());
|
ApplicantWorkApprovalItemMeasureRespDTO measureRespDTO;
|
MeasureTypeEnum measureTypeEnum;
|
WorkTypeEnum workTypeEnum;
|
for (WorkApprovalItemMeasureInfo measureInfo : measures) {
|
measureRespDTO = new ApplicantWorkApprovalItemMeasureRespDTO();
|
measureRespDTO.setMeasureId(measureInfo.getId());
|
measureRespDTO.setContext(measureInfo.getContext());
|
measureRespDTO.setCorrectVal(measureInfo.getCorrectVal());
|
measureRespDTO.setWorkType(measureInfo.getWorkType());
|
measureRespDTO.setType(measureInfo.getType());
|
measureTypeEnum = MeasureTypeEnum.parse(measureInfo.getType());
|
if (measureTypeEnum != null) {
|
measureRespDTO.setTypeDesc(measureTypeEnum.getDesc());
|
}
|
workTypeEnum = WorkTypeEnum.parse(measureInfo.getWorkType());
|
if (workTypeEnum != null) {
|
measureRespDTO.setWorkTypeDesc(workTypeEnum.getName());
|
}
|
measureMap.put(measureRespDTO.getMeasureId(), measureRespDTO);
|
}
|
|
// 标准处理映射
|
Map<Long, ApplicantWorkApprovalItemStandRespDTO> standMap = new HashMap<>(stands.size());
|
ApplicantWorkApprovalItemStandRespDTO standRespDTO;
|
WorkStandTypeEnum standTypeEnum;
|
RuleStandMatchingTypeEnum pattern;
|
for (WorkApprovalItemStandInfo standInfo : stands) {
|
standRespDTO = new ApplicantWorkApprovalItemStandRespDTO();
|
standRespDTO.setStandId(standInfo.getId());
|
standRespDTO.setWorkApplyId(standInfo.getWorkApplyId());
|
standRespDTO.setDepId(standInfo.getDepId());
|
standRespDTO.setDepName(standInfo.getDepName());
|
standRespDTO.setEid(standInfo.getEid());
|
standRespDTO.setMaxVal(standInfo.getMaxVal());
|
standRespDTO.setMaxValMatchPattern(standInfo.getMaxValMatchPattern());
|
pattern = RuleStandMatchingTypeEnum.parse(standInfo.getMaxValMatchPattern());
|
if (pattern != null) {
|
standRespDTO.setMaxValMatchPatternDesc(pattern.getValue());
|
}
|
standRespDTO.setMinVal(standInfo.getMinVal());
|
standRespDTO.setMinValMatchPattern(standInfo.getMinValMatchPattern());
|
pattern = RuleStandMatchingTypeEnum.parse(standInfo.getMinValMatchPattern());
|
if (pattern != null) {
|
standRespDTO.setMinValMatchPatternDesc(pattern.getValue());
|
}
|
standRespDTO.setTitle(standInfo.getTitle());
|
standRespDTO.setType(standInfo.getType());
|
standTypeEnum = WorkStandTypeEnum.parse(standInfo.getType());
|
if (standTypeEnum != null) {
|
standRespDTO.setTypeDesc(standTypeEnum.getDesc());
|
}
|
|
standMap.put(standRespDTO.getStandId(), standRespDTO);
|
}
|
|
// 审批项映射
|
Map<Long, WorkApprovalItemInfo> itemsMap = new HashMap<>(items.size());
|
for (WorkApprovalItemInfo item : items) {
|
itemsMap.put(item.getId(), item);
|
}
|
// 已填写审批项映射
|
Map<Long, List<ApplicantWorkApprovalUnitFilledItemRespDTO>> filledItemMap = new HashMap<>(filledItems.size());
|
ApplicantWorkApprovalUnitFilledItemRespDTO filledItemRespDTO;
|
WorkApprovalItemInfo itemInfo;
|
RuleItemTypeEnum itemType;
|
WorkRuleMeasureOptEnum optEnum;
|
ApprovalFilledItemType filledItemType;
|
for (WorkApprovalFilledItemInfo filledItem : filledItems) {
|
filledItemRespDTO = new ApplicantWorkApprovalUnitFilledItemRespDTO();
|
filledItemRespDTO.setId(filledItem.getId());
|
filledItemRespDTO.setWorkApplyId(filledItem.getWorkApplyId());
|
filledItemRespDTO.setUnitId(filledItem.getUnitId());
|
filledItemRespDTO.setMeasureVal(filledItem.getMeasureVal());
|
filledItemRespDTO.setMeasureText(filledItem.getMeasureText());
|
filledItemRespDTO.setAnalysisLocation(filledItem.getAnalysisLocation());
|
filledItemRespDTO.setVal(filledItem.getVal());
|
filledItemRespDTO.setItemId(filledItem.getItemId());
|
filledItemRespDTO.setFillType(filledItem.getFillType());
|
optEnum = WorkRuleMeasureOptEnum.parse(filledItem.getMeasureVal());
|
if (optEnum != null) {
|
filledItemRespDTO.setMeasureValDesc(optEnum.getDesc());
|
}
|
filledItemType = ApprovalFilledItemType.parse(filledItem.getFillType());
|
if (filledItemType != null) {
|
filledItemRespDTO.setFillTypeDesc(filledItemType.value);
|
}
|
itemInfo = itemsMap.get(filledItem.getItemId());
|
if (itemInfo != null) {
|
filledItemRespDTO.setItemName(itemInfo.getItemName());
|
filledItemRespDTO.setStandId(itemInfo.getStandId());
|
filledItemRespDTO.setMeasureId(itemInfo.getMeasureId());
|
filledItemRespDTO.setMeasureInvolve(itemInfo.getMeasureInvolve());
|
filledItemRespDTO.setItemType(itemInfo.getType());
|
itemType = RuleItemTypeEnum.parse(itemInfo.getType());
|
if (itemType != null) {
|
filledItemRespDTO.setItemTypeDesc(itemType.getValue());
|
}
|
// 措施
|
filledItemRespDTO.setMeasure(measureMap.get(itemInfo.getMeasureId()));
|
// 标准
|
filledItemRespDTO.setStand(standMap.get(itemInfo.getStandId()));
|
|
}
|
|
if (filledItemMap.get(filledItem.getUnitId()) == null) {
|
List<ApplicantWorkApprovalUnitFilledItemRespDTO> list = new ArrayList<>();
|
list.add(filledItemRespDTO);
|
filledItemMap.put(filledItem.getUnitId(), list);
|
}else{
|
filledItemMap.get(filledItem.getUnitId()).add(filledItemRespDTO);
|
}
|
}
|
|
// 作业人处理
|
// List<ApplicantWorkApprovedApplyOperatorRespDTO> operatorRespDTOs = new ArrayList<>(operators.size());
|
// ApplicantWorkApprovedApplyOperatorRespDTO operatorRespDTO;
|
// for (WorkApplyOperatorInfo operator : operators) {
|
// operatorRespDTO = new ApplicantWorkApprovedApplyOperatorRespDTO();
|
// operatorRespDTO.setId(operator.getId());
|
// operatorRespDTO.setOperatorUid(operator.getOperatorUid());
|
// operatorRespDTO.setOperatorUname(operator.getOperatorUname());
|
// operatorRespDTO.setOperatorCertificate(operator.getOperatorCertificate());
|
// operatorRespDTO.setOperatorPhone(operator.getOperatorPhone());
|
// operatorRespDTO.setOperatorIdentify(operator.getOperatorIdentify());
|
// operatorRespDTO.setWorkApplyId(operator.getWorkApplyId());
|
// operatorRespDTOs.add(operatorRespDTO);
|
// }
|
|
// 层级处理
|
Long currentStepId = workApplyInfo.getApprovalStepId();
|
// 已经走过的层级和当前所处层级
|
List<WorkApprovalStepInfo> approvedSteps = this.makeApprovedStepInOrder(currentStepId, steps);
|
|
List<ApplicantWorkApprovalStepRespDTO> stepRespDTOs = new ArrayList<>(approvedSteps.size());
|
ApplicantWorkApprovalStepRespDTO stepRespDTO;
|
ApplicantWorkApprovalUnitRespDTO stepUnitRespDTO;
|
ApplicantWorkApprovalItemRespDTO stepItemRespDTO;
|
ApprovalStepTypeEnum stepTypeEnum;
|
WorkApprovalStepResultEnum approvalStepResultEnum;
|
WorkApprovalUnitResultEnum approvalUnitResultEnum;
|
RuleItemTypeEnum itemTypeEnum;
|
AuditTypeEnum auditTypeEnum;
|
// 1.层级处理和单元处理
|
for (WorkApprovalStepInfo step : approvedSteps) {
|
stepRespDTO = new ApplicantWorkApprovalStepRespDTO();
|
stepRespDTO.setStepId(step.getId());
|
stepRespDTO.setWorkApplyId(step.getWorkApplyId());
|
stepRespDTO.setApprovalResult(step.getApprovalResult());
|
approvalStepResultEnum = WorkApprovalStepResultEnum.parse(step.getApprovalResult());
|
if (approvalStepResultEnum != null) {
|
stepRespDTO.setApprovalResultDesc(approvalStepResultEnum.getDesc());
|
}
|
stepRespDTO.setExpFinishApprovalTime(step.getExpFinishApprovalTime());
|
stepRespDTO.setFinishApprovalTime(step.getFinishApprovalTime());
|
stepRespDTO.setType(step.getType());
|
stepTypeEnum = ApprovalStepTypeEnum.parse(step.getType());
|
if (stepTypeEnum != null) {
|
stepRespDTO.setTypeDesc(stepTypeEnum.getDesc());
|
}
|
stepRespDTO.setStartApprovalTime(step.getStartApprovalTime());
|
stepRespDTO.setStepSerial(step.getStepSerial());
|
stepRespDTO.setNextStepId(step.getNextStepId());
|
stepRespDTO.setPreStepId(step.getPreStepId());
|
stepRespDTO.setContainItem(step.getContainItem());
|
stepRespDTO.setStepName(step.getStepName());
|
stepRespDTO.setAuditType(step.getAuditType());
|
auditTypeEnum = AuditTypeEnum.parse(step.getAuditType());
|
if (auditTypeEnum != null) {
|
stepRespDTO.setAuditTypeDesc(auditTypeEnum.getDesc());
|
}
|
|
// 审批项处理
|
List<WorkApprovalItemInfo> stepItems = items.stream().filter(item ->
|
// 当前层级的审批项
|
step.getId().equals(item.getStepId()))
|
// 集合
|
.collect(Collectors.toList());
|
|
List<ApplicantWorkApprovalItemRespDTO> stepItemDTOs = new ArrayList<>(stepItems.size());
|
for (WorkApprovalItemInfo stepItem : stepItems) {
|
stepItemRespDTO = new ApplicantWorkApprovalItemRespDTO();
|
stepItemRespDTO.setItemId(stepItem.getId());
|
stepItemRespDTO.setStepId(step.getId());
|
stepItemRespDTO.setWorkApplyId(stepItem.getWorkApplyId());
|
stepItemRespDTO.setItemName(stepItem.getItemName());
|
stepItemRespDTO.setMeasureId(stepItem.getMeasureId());
|
stepItemRespDTO.setMeasureInvolve(stepItem.getMeasureInvolve());
|
stepItemRespDTO.setStandId(stepItem.getStandId());
|
stepItemRespDTO.setUnitId(stepItem.getUnitId());
|
stepItemRespDTO.setType(stepItem.getType());
|
itemTypeEnum = RuleItemTypeEnum.parse(stepItem.getType());
|
stepItemRespDTO.setTypeDesc(itemTypeEnum.getValue());
|
// 措施
|
stepItemRespDTO.setMeasure(measureMap.get(stepItem.getMeasureId()));
|
// 标准
|
stepItemRespDTO.setStand(standMap.get(stepItem.getStandId()));
|
stepItemDTOs.add(stepItemRespDTO);
|
}
|
|
// 当前层级单元
|
List<WorkApprovalUnitInfo> stepUnits = units.stream().filter(unit ->
|
// 所属层级
|
step.getId().equals(unit.getStepId()))
|
// 集合
|
.collect(Collectors.toList());
|
// 单元处理
|
List<ApplicantWorkApprovalUnitRespDTO> stepUnitDTOs = new ArrayList<>(stepUnits.size());
|
for (WorkApprovalUnitInfo stepUnit : stepUnits) {
|
stepUnitRespDTO = new ApplicantWorkApprovalUnitRespDTO();
|
stepUnitRespDTO.setUnitId(stepUnit.getId());
|
stepUnitRespDTO.setStepId(stepUnit.getStepId());
|
stepUnitRespDTO.setWorkApplyId(stepUnit.getWorkApplyId());
|
stepUnitRespDTO.setResult(stepUnit.getResult());
|
approvalUnitResultEnum = WorkApprovalUnitResultEnum.parse(stepUnit.getResult());
|
if (approvalUnitResultEnum != null) {
|
stepUnitRespDTO.setResultDesc(approvalUnitResultEnum.getDesc());
|
}
|
stepUnitRespDTO.setApprovalUid(stepUnit.getApprovalUid());
|
stepUnitRespDTO.setApprovalUname(stepUnit.getApprovalUname());
|
stepUnitRespDTO.setApprovalActualTime(stepUnit.getApprovalActualTime());
|
stepUnitRespDTO.setApprovalEndTime(stepUnit.getApprovalEndTime());
|
stepUnitRespDTO.setApprovalStartTime(stepUnit.getApprovalStartTime());
|
stepUnitRespDTO.setFilledContent(stepUnit.getFillContent());
|
if (filledItemMap.get(stepUnit.getId()) != null) {
|
stepUnitRespDTO.setFilledItems(filledItemMap.get(stepUnit.getId()));
|
}
|
stepUnitDTOs.add(stepUnitRespDTO);
|
}
|
|
stepRespDTO.setStepItems(stepItemDTOs);
|
stepRespDTO.setStepUnits(stepUnitDTOs);
|
stepRespDTOs.add(stepRespDTO);
|
|
|
}
|
result.setWorkApplyId(workApplyInfo.getId());
|
result.setWorkPermitNo(workApplyInfo.getWorkPermitNo());
|
result.setOperatorCompanys(workApplyInfo.getOperatorCompanys());
|
result.setOperatorUnames(workApplyInfo.getOperatorUnames());
|
result.setApprovalSteps(stepRespDTOs);
|
result.setWorkContent(workApplyInfo.getWorkContent());
|
result.setWorkLocation(workApplyInfo.getWorkLocation());
|
result.setHazardIdentification(workApplyInfo.getHazardIdentification());
|
return result;
|
|
}
|
|
@Override
|
public ApproverWorkApprovedApplyDetailRespDTO getApprovedApplyDetailForApprover(ContextCacheUser currentUser, Long workApplyId) {
|
if (workApplyId == null) {
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
WorkApplyInfo workApplyInfo = workApplyInfoService.getById(workApplyId);
|
if (workApplyInfo == null) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "作业申请不存在");
|
}
|
|
// 循环过程中判断 当前人是否是审批人
|
boolean isApprover = false;
|
|
// 结果 result
|
ApproverWorkApprovedApplyDetailRespDTO result = new ApproverWorkApprovedApplyDetailRespDTO();
|
// // 获取操作人
|
// List<WorkApplyOperatorInfo> operators = workApplyOperatorInfoService.listWorkOperatorByWorkApplyId(workApplyId);
|
// 获取层级
|
List<WorkApprovalStepInfo> steps = workApprovalStepInfoService.listApprovalRuleStepByWorkApplyId(workApplyId);
|
// 获取单元
|
List<WorkApprovalUnitInfo> units = workApprovalUnitInfoService.listApprovalRuleUnitByWorkApplyId(workApplyId);
|
// 获取审批项
|
List<WorkApprovalItemInfo> items = workApprovalItemInfoService.listWorkApprovalItemByWorkApplyId(workApplyId);
|
// 获取已经填报审批项
|
List<WorkApprovalFilledItemInfo> filledItems = workApprovalFilledItemInfoService.listApprovalFilledItemInfoByWorkApplyId(workApplyId);
|
// 获取标准
|
List<WorkApprovalItemStandInfo> stands = workApprovalItemStandInfoService.listWorkApprovalItemStandByWorkApplyId(workApplyId);
|
// 获取措施
|
List<WorkApprovalItemMeasureInfo> measures = workApprovalItemMeasureInfoService.listWorkApprovalItemMeasureByWorkApplyId(workApplyId);
|
|
// 措施处理映射
|
Map<Long, ApproverWorkApprovalItemMeasureRespDTO> measureMap = new HashMap<>(measures.size());
|
ApproverWorkApprovalItemMeasureRespDTO measureRespDTO;
|
MeasureTypeEnum measureTypeEnum;
|
WorkTypeEnum workTypeEnum;
|
for (WorkApprovalItemMeasureInfo measureInfo : measures) {
|
measureRespDTO = new ApproverWorkApprovalItemMeasureRespDTO();
|
measureRespDTO.setMeasureId(measureInfo.getId());
|
measureRespDTO.setContext(measureInfo.getContext());
|
measureRespDTO.setCorrectVal(measureInfo.getCorrectVal());
|
measureRespDTO.setWorkType(measureInfo.getWorkType());
|
measureRespDTO.setType(measureInfo.getType());
|
measureTypeEnum = MeasureTypeEnum.parse(measureInfo.getType());
|
if (measureTypeEnum != null) {
|
measureRespDTO.setTypeDesc(measureTypeEnum.getDesc());
|
}
|
workTypeEnum = WorkTypeEnum.parse(measureInfo.getWorkType());
|
if (workTypeEnum != null) {
|
measureRespDTO.setWorkTypeDesc(workTypeEnum.getName());
|
}
|
measureMap.put(measureRespDTO.getMeasureId(), measureRespDTO);
|
}
|
|
// 标准处理映射
|
Map<Long, ApproverWorkApprovalItemStandRespDTO> standMap = new HashMap<>(stands.size());
|
ApproverWorkApprovalItemStandRespDTO standRespDTO;
|
WorkStandTypeEnum standTypeEnum;
|
RuleStandMatchingTypeEnum pattern;
|
for (WorkApprovalItemStandInfo standInfo : stands) {
|
standRespDTO = new ApproverWorkApprovalItemStandRespDTO();
|
standRespDTO.setStandId(standInfo.getId());
|
standRespDTO.setWorkApplyId(standInfo.getWorkApplyId());
|
standRespDTO.setDepId(standInfo.getDepId());
|
standRespDTO.setDepName(standInfo.getDepName());
|
standRespDTO.setEid(standInfo.getEid());
|
standRespDTO.setMaxVal(standInfo.getMaxVal());
|
standRespDTO.setMaxValMatchPattern(standInfo.getMaxValMatchPattern());
|
pattern = RuleStandMatchingTypeEnum.parse(standInfo.getMaxValMatchPattern());
|
if (pattern != null) {
|
standRespDTO.setMaxValMatchPatternDesc(pattern.getValue());
|
}
|
standRespDTO.setMinVal(standInfo.getMinVal());
|
standRespDTO.setMinValMatchPattern(standInfo.getMinValMatchPattern());
|
pattern = RuleStandMatchingTypeEnum.parse(standInfo.getMinValMatchPattern());
|
if (pattern != null) {
|
standRespDTO.setMaxValMatchPatternDesc(pattern.getValue());
|
}
|
standRespDTO.setTitle(standInfo.getTitle());
|
standRespDTO.setType(standInfo.getType());
|
standTypeEnum = WorkStandTypeEnum.parse(standInfo.getType());
|
if (standTypeEnum != null) {
|
standRespDTO.setTypeDesc(standTypeEnum.getDesc());
|
}
|
|
standMap.put(standRespDTO.getStandId(), standRespDTO);
|
}
|
|
// 审批项映射
|
Map<Long, WorkApprovalItemInfo> itemsMap = new HashMap<>(items.size());
|
for (WorkApprovalItemInfo item : items) {
|
itemsMap.put(item.getId(), item);
|
}
|
|
// 已填写审批项映射
|
Map<Long, List<ApproverWorkApprovalUnitFilledItemRespDTO>> filledItemMap = new HashMap<>(filledItems.size());
|
ApproverWorkApprovalUnitFilledItemRespDTO filledItemRespDTO;
|
WorkApprovalItemInfo itemInfo;
|
RuleItemTypeEnum itemType;
|
WorkRuleMeasureOptEnum optEnum;
|
ApprovalFilledItemType filledItemType;
|
for (WorkApprovalFilledItemInfo filledItem : filledItems) {
|
filledItemRespDTO = new ApproverWorkApprovalUnitFilledItemRespDTO();
|
filledItemRespDTO.setId(filledItem.getId());
|
filledItemRespDTO.setWorkApplyId(filledItem.getWorkApplyId());
|
filledItemRespDTO.setUnitId(filledItem.getUnitId());
|
filledItemRespDTO.setMeasureVal(filledItem.getMeasureVal());
|
filledItemRespDTO.setMeasureText(filledItem.getMeasureText());
|
filledItemRespDTO.setAnalysisLocation(filledItem.getAnalysisLocation());
|
filledItemRespDTO.setVal(filledItem.getVal());
|
filledItemRespDTO.setItemId(filledItem.getItemId());
|
filledItemRespDTO.setFillType(filledItem.getFillType());
|
optEnum = WorkRuleMeasureOptEnum.parse(filledItem.getMeasureVal());
|
if (optEnum != null) {
|
filledItemRespDTO.setMeasureValDesc(optEnum.getDesc());
|
}
|
filledItemType = ApprovalFilledItemType.parse(filledItem.getFillType());
|
if (filledItemType != null) {
|
filledItemRespDTO.setFillTypeDesc(filledItemType.value);
|
}
|
itemInfo = itemsMap.get(filledItem.getItemId());
|
if (itemInfo != null) {
|
filledItemRespDTO.setItemName(itemInfo.getItemName());
|
filledItemRespDTO.setStandId(itemInfo.getStandId());
|
filledItemRespDTO.setMeasureId(itemInfo.getMeasureId());
|
filledItemRespDTO.setMeasureInvolve(itemInfo.getMeasureInvolve());
|
filledItemRespDTO.setItemType(itemInfo.getType());
|
itemType = RuleItemTypeEnum.parse(itemInfo.getType());
|
if (itemType != null) {
|
filledItemRespDTO.setItemTypeDesc(itemType.getValue());
|
}
|
// 措施
|
filledItemRespDTO.setMeasure(measureMap.get(itemInfo.getMeasureId()));
|
// 标准
|
filledItemRespDTO.setStand(standMap.get(itemInfo.getStandId()));
|
|
}
|
if (filledItemMap.get(filledItem.getUnitId()) == null) {
|
List<ApproverWorkApprovalUnitFilledItemRespDTO> list = new ArrayList<>();
|
list.add(filledItemRespDTO);
|
filledItemMap.put(filledItem.getUnitId(), list);
|
}else{
|
filledItemMap.get(filledItem.getUnitId()).add(filledItemRespDTO);
|
}
|
}
|
|
// 作业人处理
|
// List<ApproverWorkApprovedApplyOperatorRespDTO> operatorRespDTOs= new ArrayList<>(operators.size());
|
// ApproverWorkApprovedApplyOperatorRespDTO operatorRespDTO;
|
// for (WorkApplyOperatorInfo operator : operators) {
|
// operatorRespDTO = new ApproverWorkApprovedApplyOperatorRespDTO();
|
// operatorRespDTO.setId(operator.getId());
|
// operatorRespDTO.setOperatorUid(operator.getOperatorUid());
|
// operatorRespDTO.setOperatorUname(operator.getOperatorUname());
|
// operatorRespDTO.setOperatorCertificate(operator.getOperatorCertificate());
|
// operatorRespDTO.setOperatorPhone(operator.getOperatorPhone());
|
// operatorRespDTO.setOperatorIdentify(operator.getOperatorIdentify());
|
// operatorRespDTO.setWorkApplyId(operator.getWorkApplyId());
|
// operatorRespDTOs.add(operatorRespDTO);
|
// }
|
|
// 层级处理
|
Long currentStepId = workApplyInfo.getApprovalStepId();
|
// 已经走过的层级和当前所处层级
|
List<WorkApprovalStepInfo> approvedSteps = this.makeApprovedStepInOrder(currentStepId, steps);
|
|
List<ApproverWorkApprovalStepRespDTO> stepRespDTOs = new ArrayList<>(approvedSteps.size());
|
ApproverWorkApprovalStepRespDTO stepRespDTO;
|
ApproverWorkApprovalUnitRespDTO stepUnitRespDTO;
|
ApproverWorkApprovalItemRespDTO stepItemRespDTO;
|
ApprovalStepTypeEnum stepTypeEnum;
|
WorkApprovalStepResultEnum approvalStepResultEnum;
|
WorkApprovalUnitResultEnum approvalUnitResultEnum;
|
RuleItemTypeEnum itemTypeEnum;
|
AuditTypeEnum auditTypeEnum;
|
// 1.层级处理和单元处理
|
for (WorkApprovalStepInfo step : approvedSteps) {
|
stepRespDTO = new ApproverWorkApprovalStepRespDTO();
|
stepRespDTO.setStepId(step.getId());
|
stepRespDTO.setWorkApplyId(step.getWorkApplyId());
|
stepRespDTO.setApprovalResult(step.getApprovalResult());
|
approvalStepResultEnum = WorkApprovalStepResultEnum.parse(step.getApprovalResult());
|
if (approvalStepResultEnum != null) {
|
stepRespDTO.setApprovalResultDesc(approvalStepResultEnum.getDesc());
|
}
|
stepRespDTO.setExpFinishApprovalTime(step.getExpFinishApprovalTime());
|
stepRespDTO.setFinishApprovalTime(step.getFinishApprovalTime());
|
stepRespDTO.setType(step.getType());
|
stepTypeEnum = ApprovalStepTypeEnum.parse(step.getType());
|
if (stepTypeEnum != null) {
|
stepRespDTO.setTypeDesc(stepTypeEnum.getDesc());
|
}
|
stepRespDTO.setStartApprovalTime(step.getStartApprovalTime());
|
stepRespDTO.setStepSerial(step.getStepSerial());
|
stepRespDTO.setNextStepId(step.getNextStepId());
|
stepRespDTO.setPreStepId(step.getPreStepId());
|
stepRespDTO.setContainItem(step.getContainItem());
|
stepRespDTO.setStepName(step.getStepName());
|
stepRespDTO.setAuditType(step.getAuditType());
|
auditTypeEnum = AuditTypeEnum.parse(step.getAuditType());
|
if (auditTypeEnum != null) {
|
stepRespDTO.setAuditTypeDesc(auditTypeEnum.getDesc());
|
}
|
|
// 审批项处理
|
List<WorkApprovalItemInfo> stepItems = items.stream().filter(item ->
|
// 当前层级的审批项
|
step.getId().equals(item.getStepId()))
|
// 集合
|
.collect(Collectors.toList());
|
|
List<ApproverWorkApprovalItemRespDTO> stepItemDTOs = new ArrayList<>(stepItems.size());
|
for (WorkApprovalItemInfo stepItem : stepItems) {
|
stepItemRespDTO = new ApproverWorkApprovalItemRespDTO();
|
stepItemRespDTO.setItemId(stepItem.getId());
|
stepItemRespDTO.setStepId(step.getId());
|
stepItemRespDTO.setWorkApplyId(stepItem.getWorkApplyId());
|
stepItemRespDTO.setItemName(stepItem.getItemName());
|
stepItemRespDTO.setMeasureId(stepItem.getMeasureId());
|
stepItemRespDTO.setMeasureInvolve(stepItem.getMeasureInvolve());
|
stepItemRespDTO.setStandId(stepItem.getStandId());
|
stepItemRespDTO.setUnitId(stepItem.getUnitId());
|
stepItemRespDTO.setType(stepItem.getType());
|
itemTypeEnum = RuleItemTypeEnum.parse(stepItem.getType());
|
stepItemRespDTO.setTypeDesc(itemTypeEnum.getValue());
|
// 措施
|
stepItemRespDTO.setMeasure(measureMap.get(stepItem.getMeasureId()));
|
// 标准
|
stepItemRespDTO.setStand(standMap.get(stepItem.getStandId()));
|
stepItemDTOs.add(stepItemRespDTO);
|
}
|
|
// 当前层级单元
|
List<WorkApprovalUnitInfo> stepUnits = units.stream().filter(unit ->
|
// 所属层级
|
step.getId().equals(unit.getStepId()))
|
// 集合
|
.collect(Collectors.toList());
|
// 单元处理
|
List<ApproverWorkApprovalUnitRespDTO> stepUnitDTOs = new ArrayList<>(stepUnits.size());
|
for (WorkApprovalUnitInfo stepUnit : stepUnits) {
|
stepUnitRespDTO = new ApproverWorkApprovalUnitRespDTO();
|
stepUnitRespDTO.setUnitId(stepUnit.getId());
|
stepUnitRespDTO.setStepId(stepUnit.getStepId());
|
stepUnitRespDTO.setWorkApplyId(stepUnit.getWorkApplyId());
|
stepUnitRespDTO.setResult(stepUnit.getResult());
|
approvalUnitResultEnum = WorkApprovalUnitResultEnum.parse(stepUnit.getResult());
|
if (approvalUnitResultEnum != null) {
|
stepUnitRespDTO.setResultDesc(approvalUnitResultEnum.getDesc());
|
}
|
stepUnitRespDTO.setApprovalUid(stepUnit.getApprovalUid());
|
stepUnitRespDTO.setApprovalUname(stepUnit.getApprovalUname());
|
stepUnitRespDTO.setApprovalActualTime(stepUnit.getApprovalActualTime());
|
stepUnitRespDTO.setApprovalEndTime(stepUnit.getApprovalEndTime());
|
stepUnitRespDTO.setApprovalStartTime(stepUnit.getApprovalStartTime());
|
stepUnitRespDTO.setFilledContent(stepUnit.getFillContent());
|
if (filledItemMap.get(stepUnit.getId()) != null) {
|
stepUnitRespDTO.setFilledItems(filledItemMap.get(stepUnit.getId()));
|
}
|
stepUnitDTOs.add(stepUnitRespDTO);
|
|
// 判断是否是审批人
|
if (stepUnit.getApprovalUid().equals(currentUser.getUid())) {
|
isApprover = true;
|
}
|
}
|
|
stepRespDTO.setStepItems(stepItemDTOs);
|
stepRespDTO.setStepUnits(stepUnitDTOs);
|
stepRespDTOs.add(stepRespDTO);
|
}
|
|
if (!isApprover) {
|
throw new BusinessException(E.DATA_OPERATION_NO_PERMISSION, "操作人不为审批人");
|
}
|
|
result.setWorkApplyId(workApplyInfo.getId());
|
result.setWorkPermitNo(workApplyInfo.getWorkPermitNo());
|
// result.setOperators(operatorRespDTOs);
|
result.setOperatorCompanys(workApplyInfo.getOperatorCompanys());
|
result.setOperatorUnames(workApplyInfo.getOperatorUnames());
|
result.setApprovalSteps(stepRespDTOs);
|
result.setWorkContent(workApplyInfo.getWorkContent());
|
result.setWorkLocation(workApplyInfo.getWorkLocation());
|
result.setHazardIdentification(workApplyInfo.getHazardIdentification());
|
return result;
|
}
|
|
@Override
|
public ApproverWorkPendingApprovalDataRespDTO getPendingApprovalData(ContextCacheUser currentUser, Long workApplyId) {
|
if (workApplyId == null) {
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
WorkApplyInfo workApplyInfo = workApplyInfoService.getWorkApprovalByApprovalUid(workApplyId, currentUser.getUid());
|
if (workApplyInfo == null) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "作业申请不存在或者你不是该作业的审批人");
|
}
|
// 获取当前层级
|
WorkApprovalStepInfo currentStep = workApprovalStepInfoService.getById(workApplyInfo.getApprovalStepId());
|
// todo 当前层级状态判断 如果已经有状态，没有可以审批的信息
|
// 获取当前单元
|
WorkApprovalUnitInfo currentUnit = workApprovalUnitInfoService.getWorkApprovalUnitByStepIdAndUid(currentStep.getId(), currentUser.getUid());
|
// 如果单元被自动驳回,需要返回当时的数据进行修改
|
if (currentUnit.getResult().equals(WorkApprovalUnitResultEnum.RESULT_SUCCESS.getResult())) {
|
throw new BusinessException(E.DATA_STATUS_CHECK_INVALID, "单元审批已完成");
|
}
|
ApproverWorkPendingApprovalDataRespDTO pendingData = new ApproverWorkPendingApprovalDataRespDTO();
|
// 层级
|
pendingData.setStepId(currentStep.getId());
|
pendingData.setWorkApplyId(currentStep.getWorkApplyId());
|
pendingData.setStepType(currentStep.getType());
|
ApprovalStepTypeEnum stepTypeEnum = ApprovalStepTypeEnum.parse(currentStep.getType());
|
if (stepTypeEnum != null) {
|
pendingData.setStepTypeDesc(stepTypeEnum.getDesc());
|
}
|
pendingData.setStepApprovalResult(currentStep.getApprovalResult());
|
WorkApprovalStepResultEnum approvalStepResultEnum = WorkApprovalStepResultEnum.parse(currentStep.getApprovalResult());
|
if (approvalStepResultEnum != null) {
|
pendingData.setStepApprovalResultDesc(approvalStepResultEnum.getDesc());
|
}
|
pendingData.setStepStartApprovalTime(currentStep.getStartApprovalTime());
|
pendingData.setStepExpFinishApprovalTime(currentStep.getExpFinishApprovalTime());
|
pendingData.setStepFinishApprovalTime(currentStep.getFinishApprovalTime());
|
pendingData.setPreStepId(currentStep.getPreStepId());
|
pendingData.setNextStepId(currentStep.getNextStepId());
|
pendingData.setContainItem(currentStep.getContainItem());
|
pendingData.setStepName(currentStep.getStepName());
|
// 单元
|
pendingData.setUnitId(currentUnit.getId());
|
pendingData.setApprovalUid(currentUnit.getApprovalUid());
|
pendingData.setApprovalUname(currentUnit.getApprovalUname());
|
pendingData.setUnitApprovalResult(currentUnit.getResult());
|
WorkApprovalUnitResultEnum approvalUnitResultEnum = WorkApprovalUnitResultEnum.parse(currentUnit.getResult());
|
if (approvalUnitResultEnum != null) {
|
pendingData.setUnitApprovalResultDesc(approvalUnitResultEnum.getDesc());
|
}
|
pendingData.setUnitApprovalStartTime(currentUnit.getApprovalStartTime());
|
pendingData.setUnitApprovalEndTime(currentUnit.getApprovalEndTime());
|
pendingData.setUnitApprovalActualTime(currentUnit.getApprovalActualTime());
|
|
// 审批项
|
List<WorkApprovalItemInfo> items = workApprovalItemInfoService.listWorkApprovalItemInfoByStepId(currentStep.getId());
|
// 审批措施
|
List<WorkApprovalItemMeasureInfo> measures = workApprovalItemMeasureInfoService.listWorkApprovalItemMeasureByWorkApplyId(workApplyId);
|
// 审批标准
|
List<WorkApprovalItemStandInfo> stands = workApprovalItemStandInfoService.listWorkApprovalItemStandByWorkApplyId(workApplyId);
|
// // 已填写审批项内容
|
// List<WorkApprovalFilledItemInfo> filledItems = workApprovalFilledItemInfoService.listApprovalFilledItemInfoByUnitId(currentUnit.getId());
|
// 安全措施映射准备
|
Map<Long, ApproverWorkPendingApprovalItemMeasureRespDTO> measureMap = new HashMap<>(measures.size());
|
ApproverWorkPendingApprovalItemMeasureRespDTO measureRespDTO;
|
WorkTypeEnum workTypeEnum;
|
MeasureTypeEnum measureTypeEnum;
|
for (WorkApprovalItemMeasureInfo measure : measures) {
|
measureRespDTO = new ApproverWorkPendingApprovalItemMeasureRespDTO();
|
measureRespDTO.setMeasureId(measure.getId());
|
measureRespDTO.setWorkType(measure.getWorkType());
|
workTypeEnum = WorkTypeEnum.parse(measure.getWorkType());
|
if (workTypeEnum != null) {
|
measureRespDTO.setWorkTypeDesc(workTypeEnum.getName());
|
}
|
measureRespDTO.setType(measure.getType());
|
measureTypeEnum = MeasureTypeEnum.parse(measure.getType());
|
if (measureTypeEnum != null) {
|
measureRespDTO.setTypeDesc(measureTypeEnum.getDesc());
|
}
|
measureRespDTO.setCorrectVal(measure.getCorrectVal());
|
measureRespDTO.setContext(measure.getContext());
|
measureRespDTO.setWorkApplyId(measure.getWorkApplyId());
|
measureMap.put(measureRespDTO.getMeasureId(), measureRespDTO);
|
}
|
// 标准映射准备
|
Map<Long, ApproverWorkPendingApprovalItemStandRespDTO> standMap = new HashMap<>(stands.size());
|
ApproverWorkPendingApprovalItemStandRespDTO standRespDTO;
|
WorkStandTypeEnum standTypeEnum;
|
RuleStandMatchingTypeEnum pattern;
|
for (WorkApprovalItemStandInfo stand : stands) {
|
standRespDTO = new ApproverWorkPendingApprovalItemStandRespDTO();
|
standRespDTO.setStandId(stand.getId());
|
standRespDTO.setType(stand.getType());
|
standTypeEnum = WorkStandTypeEnum.parse(stand.getType());
|
if (standTypeEnum != null) {
|
standRespDTO.setTypeDesc(standTypeEnum.getDesc());
|
}
|
standRespDTO.setDepName(stand.getDepName());
|
standRespDTO.setMinVal(stand.getMinVal());
|
standRespDTO.setMinValMatchPattern(stand.getMinValMatchPattern());
|
pattern = RuleStandMatchingTypeEnum.parse(stand.getMinValMatchPattern());
|
if (pattern != null) {
|
standRespDTO.setMinValMatchPatternDesc(pattern.getValue());
|
}
|
standRespDTO.setMaxVal(stand.getMaxVal());
|
standRespDTO.setMaxValMatchPattern(stand.getMaxValMatchPattern());
|
pattern = RuleStandMatchingTypeEnum.parse(stand.getMaxValMatchPattern());
|
if (pattern != null) {
|
standRespDTO.setMaxValMatchPatternDesc(pattern.getValue());
|
}
|
standRespDTO.setTitle(stand.getTitle());
|
standRespDTO.setWorkApplyId(stand.getWorkApplyId());
|
standMap.put(standRespDTO.getStandId(), standRespDTO);
|
}
|
|
// // 已经填写的内容准备
|
// Map<Long, ApproverWorkApprovalUnitFilledItemRespDTO> filledItemRespDTOMap = new HashMap<>(filledItems.size());
|
// ApproverWorkApprovalUnitFilledItemRespDTO filledItemRespDTO;
|
// for (WorkApprovalFilledItemInfo filledItem : filledItems) {
|
// filledItemRespDTO = new ApproverWorkApprovalUnitFilledItemRespDTO();
|
// filledItemRespDTO.setId(filledItem.getId());
|
// filledItemRespDTO.setItemId(filledItem.getItemId());
|
// filledItemRespDTO.setUnitId(filledItem.getUnitId());
|
// filledItemRespDTO.setVal(filledItem.getVal());
|
// filledItemRespDTO.setWorkApplyId(filledItem.getWorkApplyId());
|
// filledItemRespDTO.setMeasureVal(filledItem.getMeasureVal());
|
// filledItemRespDTO.setMeasureText(filledItem.getMeasureText());
|
// filledItemRespDTOMap.put(filledItemRespDTO.getItemId(), filledItemRespDTO);
|
//
|
// }
|
List<ApproverWorkPendingApprovalItemRespDTO> itemRespDTOS = new ArrayList<>(items.size());
|
ApproverWorkPendingApprovalItemRespDTO itemRespDTO;
|
RuleItemTypeEnum itemTypeEnum;
|
for (WorkApprovalItemInfo item : items) {
|
itemRespDTO = new ApproverWorkPendingApprovalItemRespDTO();
|
itemRespDTO.setItemId(item.getId());
|
itemRespDTO.setItemName(item.getItemName());
|
itemRespDTO.setWorkApplyId(item.getWorkApplyId());
|
itemRespDTO.setStepId(item.getStepId());
|
itemRespDTO.setUnitId(item.getUnitId());
|
itemRespDTO.setType(item.getType());
|
itemTypeEnum = RuleItemTypeEnum.parse(item.getType());
|
itemRespDTO.setTypeDesc(itemTypeEnum.getValue());
|
itemRespDTO.setStandId(item.getStandId());
|
itemRespDTO.setStand(standMap.get(item.getStandId()));
|
itemRespDTO.setMeasureId(item.getMeasureId());
|
itemRespDTO.setMeasure(measureMap.get(item.getMeasureId()));
|
// filledItemRespDTO = filledItemRespDTOMap.get(itemRespDTO.getItemId());
|
// if (filledItemRespDTO != null) {
|
// itemRespDTO.setFilled(true);
|
// itemRespDTO.setFilledItemContent(filledItemRespDTO);
|
// }
|
itemRespDTOS.add(itemRespDTO);
|
}
|
pendingData.setItems(itemRespDTOS);
|
return pendingData;
|
}
|
|
@Override
|
@Transactional
|
public void approveItem(ContextCacheUser currentUser, ApprovalItemDataReqDTO approvalItemData) {
|
if (approvalItemData.getWorkApplyId() == null ) {
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
WorkApplyInfo workApplyInfo = workApplyInfoService.getById(approvalItemData.getWorkApplyId());
|
if (workApplyInfo == null) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "作业申请不存在");
|
}
|
if (workApplyInfo.getStatus().equals(WorkStatusEnum.STATU_ABORD.getStatus())) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "作业申请已终止");
|
}
|
if (workApplyInfo.getStatus().equals(WorkStatusEnum.STATU_FINISH.getStatus())) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "作业申请已结束");
|
}
|
WorkApprovalStepInfo currentStep = workApprovalStepInfoService.getById(workApplyInfo.getApprovalStepId());
|
if (currentStep.getApprovalResult().equals(WorkApprovalStepResultEnum.WAIT_TO_START.getResult())) {
|
throw new BusinessException(E.DATA_STATUS_CHECK_INVALID,"当前层级审批未开始");
|
}
|
|
// 当前层级不在审批中 <=> 层级审批结束
|
if (!currentStep.getApprovalResult().equals(WorkApprovalStepResultEnum.RESULT_IN_APPROVAL.getResult())) {
|
throw new BusinessException(E.DATA_STATUS_CHECK_INVALID,"当前层级审批已结束");
|
}
|
WorkApprovalUnitInfo currentUnit = workApprovalUnitInfoService.getWorkApprovalUnitByStepIdAndUid(currentStep.getId(), currentUser.getUid());
|
// 审批单元 不存在 <=> 审批人非法
|
if (currentUnit == null) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "操作人非审批人");
|
}
|
if (currentUnit.getResult().equals(WorkApprovalUnitResultEnum.WAIT_TO_START.getResult())) {
|
throw new BusinessException(E.DATA_STATUS_CHECK_INVALID,"当前层级单元未开始");
|
}
|
|
// 如果单元状态既不是 !（审批中 | 自动驳回）
|
if (!currentUnit.getResult().equals(WorkApprovalUnitResultEnum.RESULT_IN_APPROVAL.getResult()) &&
|
!currentUnit.getResult().equals(WorkApprovalUnitResultEnum.RESULT_AUTO_REJECT.getResult())) {
|
// 审批单元不在审批中 或者 自动驳回 <=> 当前单元已经结束
|
throw new BusinessException(E.DATA_STATUS_CHECK_INVALID, "当前审批单元已经结束");
|
}
|
|
// 1.层级为审批项审批
|
if (currentStep.getContainItem()) {
|
List<ApprovalItemReqDTO> itemFilledContents = approvalItemData.getItemFilledContents();
|
if (itemFilledContents == null || itemFilledContents.size() == 0) {
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "审批项提交为空");
|
}
|
// 查询当前层级所有审批项
|
List<WorkApprovalItemInfo> items = workApprovalItemInfoService.listWorkApprovalItemInfoByStepId(currentStep.getId());
|
List<Long> dBItemIds = items.stream().map(WorkApprovalItemInfo::getId).collect(Collectors.toList());
|
List<Long> paramItemIds = itemFilledContents.stream().map(ApprovalItemReqDTO::getItemId).collect(Collectors.toList());
|
// 判断提交的审批项 是否和 层级的审批项 id 完全相等
|
if (dBItemIds.size() != paramItemIds.size()) {
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "提交的审批项个数非法");
|
}
|
if (!dBItemIds.containsAll(paramItemIds)) {
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "提交的审批项id不匹配");
|
}
|
|
// 获取所有标准
|
List<WorkApprovalItemStandInfo> stands = workApprovalItemStandInfoService.listWorkApprovalItemStandByWorkApplyId(workApplyInfo.getId());
|
// 获取所有措施
|
List<WorkApprovalItemMeasureInfo> measures = workApprovalItemMeasureInfoService.listWorkApprovalItemMeasureByWorkApplyId(workApplyInfo.getId());
|
|
// 审批项 审批内容映射
|
Map<Long, WorkApprovalItemInfo> itemMap = new HashMap<>(items.size());
|
for (WorkApprovalItemInfo item : items) {
|
itemMap.put(item.getId(), item);
|
}
|
|
// 审批标准映射
|
Map<Long, WorkApprovalItemStandInfo> standMap = new HashMap<>(stands.size());
|
if (stands.size() > 0) {
|
for (WorkApprovalItemStandInfo stand : stands) {
|
standMap.put(stand.getId(), stand);
|
}
|
}
|
|
|
// 审批措施映射
|
Map<Long, WorkApprovalItemMeasureInfo> measureMap = new HashMap<>(measures.size());
|
if (measures.size() > 0) {
|
for (WorkApprovalItemMeasureInfo measure : measures) {
|
measureMap.put(measure.getId(), measure);
|
}
|
}
|
|
|
// 校验 审批项标准和填写字段
|
if (currentStep.getType().equals(ApprovalStepTypeEnum.TYPE_ANALYST.getType())) {
|
// 审批规则 => 分析人 审批绑定标准
|
boolean flag = true;
|
for (ApprovalItemReqDTO itemFilledContent : itemFilledContents) {
|
WorkApprovalItemInfo itemInfo = itemMap.get(itemFilledContent.getItemId());
|
assert itemInfo != null;
|
RuleItemTypeEnum itemTypeEnum = RuleItemTypeEnum.parse(itemInfo.getType());
|
assert itemTypeEnum == RuleItemTypeEnum.NUMERIC;
|
ApprovalFilledItemType filledItemType = ApprovalFilledItemType.parse(itemFilledContent.getFillType());
|
if (filledItemType == null) {
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "审批项标准数据填写类型非法");
|
}
|
if (filledItemType == ApprovalFilledItemType.INVOLVED) {
|
if (itemFilledContent.getVal() == null) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "审批项数值填写为空");
|
}
|
if (StringUtils.isBlank(itemFilledContent.getAnalysisLocation())) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "分析人层级请填写每个审批项的分析地点");
|
}
|
flag = false;
|
}
|
}
|
// 分析人必须涉及一项审批项
|
if (flag) {
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "至少填写一项标准数据");
|
}
|
}else{
|
// 不是分析人审批 => 安全措施 和 措施内容填写
|
for (ApprovalItemReqDTO itemFilledContent : itemFilledContents) {
|
WorkApprovalItemInfo itemInfo = itemMap.get(itemFilledContent.getItemId());
|
assert itemInfo != null;
|
RuleItemTypeEnum itemTypeEnum = RuleItemTypeEnum.parse(itemInfo.getType());
|
if (itemTypeEnum == RuleItemTypeEnum.FILL) {
|
if (StringUtils.isBlank(itemFilledContent.getMeasureText())) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "审批项措施内容填写为空");
|
}
|
}
|
if (itemTypeEnum == RuleItemTypeEnum.OPTION) {
|
if (itemFilledContent.getMeasureVal() == null) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "审批措施选项填写为空");
|
}
|
WorkRuleMeasureOptEnum measureOptEnum = WorkRuleMeasureOptEnum.parse(itemFilledContent.getMeasureVal());
|
if (measureOptEnum == null) {
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "审批措施选项非法填写");
|
}
|
}
|
}
|
}
|
|
|
|
// 单元审批中 或者 被自动驳回 <=> 新增
|
|
List<WorkApprovalFilledItemInfo> filledItemInfos = new ArrayList<>(items.size());
|
List<String> contents = new ArrayList<>(items.size());
|
WorkApprovalFilledItemInfo filledItemInfo;
|
boolean unitAutoReject = false;
|
for (ApprovalItemReqDTO itemFilledContent : itemFilledContents) {
|
// 根据item 的类型
|
WorkApprovalItemInfo itemInfo = itemMap.get(itemFilledContent.getItemId());
|
filledItemInfo = new WorkApprovalFilledItemInfo();
|
filledItemInfo.setId(IdUtil.getSnowflake(0,0).nextId());
|
filledItemInfo.setItemId(itemFilledContent.getItemId());
|
filledItemInfo.setUnitId(currentUnit.getId());
|
filledItemInfo.setWorkApplyId(workApplyInfo.getId());
|
if (currentStep.getType().equals(ApprovalStepTypeEnum.TYPE_ANALYST.getType())) {
|
filledItemInfo.setAnalysisLocation(itemFilledContent.getAnalysisLocation());
|
filledItemInfo.setFillType(itemFilledContent.getFillType());
|
}
|
|
|
// 数值类型 && 涉及填写 <=> 分析人审批 需要获取标准自动判断
|
if (itemInfo.getType().equals(RuleItemTypeEnum.NUMERIC.getCode()) && filledItemInfo.getFillType() == ApprovalFilledItemType.INVOLVED.code) {
|
// 对象数值赋予
|
filledItemInfo.setVal(itemFilledContent.getVal());
|
// 数值记录
|
contents.add(String.format("%s 填写数值:%s", itemInfo.getItemName(), filledItemInfo.getVal()));
|
// 标准
|
WorkApprovalItemStandInfo standInfo = standMap.get(itemInfo.getStandId());
|
// 最大值和最小值是否合格
|
boolean standQualified = judge(filledItemInfo.getVal(), standInfo.getMaxVal(), RuleStandMatchingTypeEnum.parse(standInfo.getMaxValMatchPattern())) &&
|
judge(filledItemInfo.getVal(), standInfo.getMinVal(), RuleStandMatchingTypeEnum.parse(standInfo.getMinValMatchPattern()));
|
// 有一项不合格 <=> 单元自动驳回
|
if (!standQualified) {
|
unitAutoReject = true;
|
// 终止判断
|
break;
|
}
|
}
|
// 选项类型 - 安全措施自动判断
|
if (itemInfo.getType().equals(RuleItemTypeEnum.OPTION.getCode())) {
|
// 对象选项赋予
|
filledItemInfo.setMeasureVal(itemFilledContent.getMeasureVal());
|
|
WorkRuleMeasureOptEnum optEnum = WorkRuleMeasureOptEnum.parse(filledItemInfo.getMeasureVal());
|
// 选项记录
|
contents.add(String.format("%s 判断为:%s", itemInfo.getItemName(), optEnum.getDesc()));
|
// 安全措施
|
WorkApprovalItemMeasureInfo measureInfo = measureMap.get(itemInfo.getMeasureId());
|
// 是否符合安全措施的判断
|
boolean measureQualified = itemFilledContent.getMeasureVal().equals(measureInfo.getCorrectVal());
|
// 选项为是或否 && 不符合安全措施的判断 => 自动驳回
|
if (optEnum != WorkRuleMeasureOptEnum.UNINVOLVED && !measureQualified) {
|
unitAutoReject = true;
|
// 终止判断
|
break;
|
}
|
}
|
|
if (itemInfo.getType().equals(RuleItemTypeEnum.FILL.getCode())) {
|
// 对象填空赋予
|
filledItemInfo.setMeasureText(itemFilledContent.getMeasureText());
|
// 填空记录
|
contents.add(String.format("%s 填写:%s", itemInfo.getItemName(), filledItemInfo.getMeasureText()));
|
}
|
// add
|
filledItemInfos.add(filledItemInfo);
|
}
|
// 填报记录
|
workApplyRecordService.log(currentUser, ProcessOperationEnum.APPROVE, workApplyInfo.getId(), workApplyInfo.getApprovalStepId(), currentStep.getStepName(), String.join(",", contents));
|
|
// 没有自动驳回 所有审批项默认符合标准，保存进数据库
|
if (!unitAutoReject) {
|
workApprovalFilledItemInfoService.saveBatchFilledItemInfo(filledItemInfos);
|
// 单元状态 => 通过
|
workApprovalUnitInfoService.updateStatusById(currentUnit.getId(), WorkApprovalUnitResultEnum.RESULT_SUCCESS);
|
// 操作记录
|
workApplyRecordService.log(ProcessOperationEnum.APPROVE_SUCCESS, workApplyInfo.getId(), workApplyInfo.getApprovalStepId(),currentStep.getStepName(), null);
|
|
}else{
|
// 单元状态 => 自动驳回
|
workApprovalUnitInfoService.updateStatusById(currentUnit.getId(), WorkApprovalUnitResultEnum.RESULT_AUTO_REJECT);
|
// 自动驳回 <=> 单元阻塞
|
// 操作记录
|
workApplyRecordService.log(ProcessOperationEnum.AUTO_REJECT, workApplyInfo.getId(), workApplyInfo.getApprovalStepId(), currentStep.getStepName(), null);
|
}
|
|
}
|
|
|
// 2.层级为审批单元即可
|
if (!currentStep.getContainItem()) {
|
if (StringUtils.isBlank(approvalItemData.getUnitFillContent())) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "单元填报意见不能为空");
|
}
|
// 填报记录
|
workApplyRecordService.log(currentUser, ProcessOperationEnum.APPROVE, workApplyInfo.getId(), workApplyInfo.getApprovalStepId(),currentStep.getStepName(), approvalItemData.getUnitFillContent());
|
// 单元状态 => 填报内容 && 通过
|
workApprovalUnitInfoService.updateStatusAndFillContentById(currentUnit.getId(), approvalItemData.getUnitFillContent(), WorkApprovalUnitResultEnum.RESULT_SUCCESS);
|
// 操作记录
|
workApplyRecordService.log(ProcessOperationEnum.APPROVE_SUCCESS, workApplyInfo.getId(), workApplyInfo.getApprovalStepId(),currentStep.getStepName(), null);
|
}
|
|
|
// 3.判断是否所有单元是否通过
|
List<WorkApprovalUnitInfo> units = workApprovalUnitInfoService.listApprovalRuleUnitByStepId(currentStep.getId());
|
// 是否还有单元再审批中（审批中 和 自动驳回 都是需要审批）
|
boolean isUnitUnderApproval = false;
|
for (WorkApprovalUnitInfo unit : units) {
|
if (unit.getResult().equals(WorkApprovalUnitResultEnum.RESULT_IN_APPROVAL.getResult()) ||
|
unit.getResult().equals(WorkApprovalUnitResultEnum.RESULT_AUTO_REJECT.getResult())) {
|
isUnitUnderApproval = true;
|
break;
|
}
|
}
|
// 是否有一个人通过
|
boolean jointTrialOneSuccess = false;
|
// 未审批通过单元 ids
|
List<Long> otherUnApprovalUnitIds = new ArrayList<>(units.size());
|
// 多人会审 => 判断是否存在单元通过
|
if (currentStep.getAuditType() != null && currentStep.getAuditType().equals(AuditTypeEnum.CONCURRENT_JOINT_TRIAL.getType())) {
|
for (WorkApprovalUnitInfo unit : units) {
|
if (unit.getResult().equals(WorkApprovalUnitResultEnum.RESULT_SUCCESS.getResult())) {
|
jointTrialOneSuccess = true;
|
}else{
|
otherUnApprovalUnitIds.add(unit.getId());
|
}
|
}
|
}
|
|
|
// 没有单元审批中 || 多人会审一人通过 => 层级通过
|
if (!isUnitUnderApproval || jointTrialOneSuccess) {
|
// 会审情况 => 将其他单元状态改成未审批通过（层级已结束）
|
if (jointTrialOneSuccess && otherUnApprovalUnitIds.size() > 0) {
|
// 修改状态
|
workApprovalUnitInfoService.batchUpdateStatusByIds(otherUnApprovalUnitIds, WorkApprovalUnitResultEnum.RESULT_APPROVED_UNSUCCESS);
|
}
|
// 层级通过
|
workApprovalStepInfoService.updateStatusById(currentStep.getId(), WorkApprovalStepResultEnum.RESULT_SUCCESS);
|
// 层级结束时间
|
workApprovalStepInfoService.updateFinishApprovalTimeById(currentStep.getId(), LocalDateTime.now());
|
// 层级是最后的层级 <=> 作业结束
|
if (currentStep.getNextStepId() == null) {
|
// 作业结束
|
workApplyInfoService.updateStatusById(workApplyInfo.getId(),WorkStatusEnum.STATU_FINISH);
|
// 操作记录
|
workApplyRecordService.log(ProcessOperationEnum.FINISH, workApplyInfo.getId(), workApplyInfo.getApprovalStepId(),currentStep.getStepName(), null);
|
}else{
|
// 开始下一个层级
|
WorkApprovalStepInfo nextStep = workApprovalStepInfoService.getById(currentStep.getNextStepId());
|
// 作业指向下一个层级
|
workApplyInfoService.updateApprovalStepIdById(workApplyInfo.getId(),currentStep.getNextStepId());
|
// 下一个层级状态为审批中
|
workApprovalStepInfoService.updateStatusById(nextStep.getId(), WorkApprovalStepResultEnum.RESULT_IN_APPROVAL);
|
// 下一个层级开始时间更新
|
workApprovalStepInfoService.updateStartApprovalTimeById(nextStep.getId(), LocalDateTime.now());
|
// 层级下所有单元状态为审批中
|
workApprovalUnitInfoService.updateStatusByStepId(nextStep.getId(),WorkApprovalUnitResultEnum.RESULT_IN_APPROVAL);
|
}
|
}
|
|
// 分析人审批 => 作业限时
|
if (currentStep.getType().equals(ApprovalStepTypeEnum.TYPE_ANALYST.getType())) {
|
RuleContinueTimeUnitEnum timeUnitEnum = RuleContinueTimeUnitEnum.parse(currentStep.getContinueTimeUnit());
|
// 延时秒数
|
long seconds = generateSeconds(timeUnitEnum, currentStep.getContinueTime());
|
// 具体判断时间点
|
LocalDateTime approvalEffectiveTime = LocalDateTime.now().plusSeconds(seconds);
|
//发送一条消息
|
ApprovalSpecialWorkMsg approvalSpecialWorkMsg = new ApprovalSpecialWorkMsg();
|
approvalSpecialWorkMsg.setWorkApplyId(approvalItemData.getWorkApplyId());
|
approvalSpecialWorkMsg.setApprovalEffectiveTime(conversionTimeType(approvalEffectiveTime));
|
approvalWorkRocketMQService.syncSend(approvalSpecialWorkMsg);
|
}
|
|
}
|
|
@Override
|
public void abordItem(ContextCacheUser currentUser, ApprovalItemAbordDataReqDTO abordDataReqDTO) {
|
if ( abordDataReqDTO.getWorkApplyId() == null) {
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
WorkApplyInfo workApplyInfo = workApplyInfoService.getById(abordDataReqDTO.getWorkApplyId());
|
if (workApplyInfo == null) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "作业申请不存在");
|
}
|
if (workApplyInfo.getStatus().equals(WorkStatusEnum.STATU_ABORD.getStatus())) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "作业申请已终止");
|
}
|
if (workApplyInfo.getStatus().equals(WorkStatusEnum.STATU_FINISH.getStatus())) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "作业申请已结束");
|
}
|
WorkApprovalStepInfo currentStep = workApprovalStepInfoService.getById(workApplyInfo.getApprovalStepId());
|
if (currentStep.getApprovalResult().equals(WorkApprovalStepResultEnum.WAIT_TO_START.getResult())) {
|
throw new BusinessException(E.DATA_STATUS_CHECK_INVALID,"当前层级审批未开始");
|
}
|
// 当前层级不在审批中 <=> 层级审批结束
|
if (!currentStep.getApprovalResult().equals(WorkApprovalStepResultEnum.RESULT_IN_APPROVAL.getResult())) {
|
throw new BusinessException(E.DATA_STATUS_CHECK_INVALID,"当前层级审批已结束");
|
}
|
WorkApprovalUnitInfo currentUnit = workApprovalUnitInfoService.getWorkApprovalUnitByStepIdAndUid(currentStep.getId(), currentUser.getUid());
|
// 审批单元 不存在 <=> 审批人非法
|
if (currentUnit == null) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "操作人非审批人");
|
}
|
if (currentUnit.getResult().equals(WorkApprovalUnitResultEnum.WAIT_TO_START.getResult())) {
|
throw new BusinessException(E.DATA_STATUS_CHECK_INVALID,"当前层级单元未开始");
|
}
|
if (currentUnit.getResult().equals(WorkApprovalUnitResultEnum.RESULT_IN_APPROVAL.getResult()) ||
|
currentUnit.getResult().equals(WorkApprovalUnitResultEnum.RESULT_AUTO_REJECT.getResult())) {
|
// 1.单元终止
|
workApprovalUnitInfoService.updateStatusById(currentUnit.getId(), WorkApprovalUnitResultEnum.RESULT_ABORD);
|
// 2.当前层级其他单元 更新状态为 终止提前结束
|
List<WorkApprovalUnitInfo> currentStepUnits = workApprovalUnitInfoService.listApprovalRuleUnitByStepId(currentStep.getId());
|
List<Long> unitIdsExceptCurrent = currentStepUnits.stream().filter(unit ->
|
// 除此之外 && 状态是(审批中 | 自动驳回）
|
!unit.getId().equals(currentUnit.getId()) &&
|
(unit.getResult().equals(WorkApprovalUnitResultEnum.RESULT_IN_APPROVAL.getResult()) ||
|
unit.getResult().equals(WorkApprovalUnitResultEnum.RESULT_AUTO_REJECT.getResult())))
|
// id
|
.map(WorkApprovalUnitInfo::getId)
|
// 集合
|
.collect(Collectors.toList());
|
if (unitIdsExceptCurrent.size() > 0) {
|
workApprovalUnitInfoService.updateStatusByIds(unitIdsExceptCurrent, WorkApprovalUnitResultEnum.RESULT_INTERRUPTED);
|
}
|
// 3.层级终止
|
workApprovalStepInfoService.updateStatusById(currentStep.getId(), WorkApprovalStepResultEnum.RESULT_ABORD);
|
// 4.作业终止
|
workApplyInfoService.updateStatusById(workApplyInfo.getId(), WorkStatusEnum.STATU_ABORD);
|
// 5.操作记录
|
workApplyRecordService.log(currentUser, ProcessOperationEnum.ABORD, workApplyInfo.getId(), workApplyInfo.getApprovalStepId(), currentStep.getStepName(), null);
|
|
}else{
|
// 审批单元不在审批中 或者 自动驳回 <=> 当前单元已经结束
|
throw new BusinessException(E.DATA_STATUS_CHECK_INVALID, "当前审批单元已经结束");
|
}
|
}
|
|
|
|
@Override
|
public SearchResultVO<List<AllWorkApplyPageRespDTO>> listAllWorkApply(ContextCacheUser currentUser, PageQuery<AllWorkApplyPageQuery> pageQuery) {
|
|
AllWorkApplyPageDBQuery dbQuery = new AllWorkApplyPageDBQuery();
|
if (pageQuery.getSearchParams() != null) {
|
dbQuery.setStatus(pageQuery.getSearchParams().getStatus());
|
dbQuery.setWorkType(pageQuery.getSearchParams().getWorkType());
|
dbQuery.setWorkLevel(pageQuery.getSearchParams().getWorkLevel());
|
dbQuery.setApplyDepId(pageQuery.getSearchParams().getApplyDepId());
|
dbQuery.setApplyStartTime(pageQuery.getSearchParams().getApplyStartTime());
|
dbQuery.setApplyEndTime(pageQuery.getSearchParams().getApplyEndTime());
|
}
|
Page<WorkApplyInfo> page = new Page<>(pageQuery.getPageIndex(), pageQuery.getPageSize());
|
List<WorkApplyInfo> dbData = workApplyInfoService.listAllWorkApplyByPage(page, dbQuery);
|
List<AllWorkApplyPageRespDTO> respDTOs = new ArrayList<>(dbData.size());
|
WorkStatusEnum statusEnum;
|
WorkLevelEnum levelEnum;
|
WorkTypeEnum workTypeEnum;
|
// List<WorkApplyOperatorRespDTO> operatorRespDTOs;
|
// WorkApplyOperatorRespDTO operatorRespDTO;
|
for (WorkApplyInfo workApplyInfo : dbData) {
|
AllWorkApplyPageRespDTO respDTO = new AllWorkApplyPageRespDTO();
|
respDTO.setWorkApplyId(workApplyInfo.getId());
|
respDTO.setWorkPermitNo(workApplyInfo.getWorkPermitNo());
|
respDTO.setWorkContent(workApplyInfo.getWorkContent());
|
respDTO.setWorkLocation(workApplyInfo.getWorkLocation());
|
respDTO.setHazardIdentification(workApplyInfo.getHazardIdentification());
|
respDTO.setDepId(workApplyInfo.getDepId());
|
respDTO.setDepName(workApplyInfo.getDepName());
|
respDTO.setApplyTime(workApplyInfo.getApplyTime());
|
respDTO.setApplyUid(workApplyInfo.getApplyUid());
|
respDTO.setApplyUname(workApplyInfo.getApplyUname());
|
respDTO.setApprovalStepId(workApplyInfo.getApprovalStepId());
|
respDTO.setExpEndTime(workApplyInfo.getExpEndTime());
|
respDTO.setExpStartTime(workApplyInfo.getExpStartTime());
|
respDTO.setGmtCreate(workApplyInfo.getGmtCreate());
|
respDTO.setGmtModified(workApplyInfo.getGmtModified());
|
respDTO.setStatus(workApplyInfo.getStatus());
|
statusEnum = WorkStatusEnum.parse(workApplyInfo.getStatus());
|
if (statusEnum != null) {
|
respDTO.setStatusDesc(statusEnum.getDesc());
|
}
|
respDTO.setWorkLevel(workApplyInfo.getWorkLevel());
|
levelEnum = WorkLevelEnum.parse(workApplyInfo.getWorkLevel());
|
if (levelEnum != null) {
|
respDTO.setWorkLevelDesc(levelEnum.getTitle());
|
}
|
respDTO.setWorkType(workApplyInfo.getWorkType());
|
workTypeEnum = WorkTypeEnum.parse(workApplyInfo.getWorkType());
|
if (workTypeEnum != null) {
|
respDTO.setWorkTypeDesc(workTypeEnum.getName());
|
}
|
// 操作人
|
// List<WorkApplyOperatorInfo> operators = workApplyOperatorInfoService.listWorkOperatorByWorkApplyId(workApplyInfo.getId());
|
// operatorRespDTOs = new ArrayList<>(operators.size());
|
// for (WorkApplyOperatorInfo operator : operators) {
|
// operatorRespDTO = new WorkApplyOperatorRespDTO();
|
// operatorRespDTO.setId(operator.getId());
|
// operatorRespDTO.setOperatorUid(operator.getOperatorUid());
|
// operatorRespDTO.setOperatorUname(operator.getOperatorUname());
|
// operatorRespDTO.setOperatorCertificate(operator.getOperatorCertificate());
|
// operatorRespDTO.setOperatorPhone(operator.getOperatorPhone());
|
// operatorRespDTO.setOperatorIdentify(operator.getOperatorIdentify());
|
// operatorRespDTO.setWorkApplyId(operator.getWorkApplyId());
|
// operatorRespDTOs.add(operatorRespDTO);
|
// }
|
// respDTO.setOperators(operatorRespDTOs);
|
respDTO.setOperatorCompanys(workApplyInfo.getOperatorCompanys());
|
respDTO.setOperatorUnames(workApplyInfo.getOperatorUnames());
|
// 八大作业
|
if (workTypeEnum != null) {
|
Object workDetail = this.getWorkDetail(workTypeEnum, workApplyInfo.getId(), workApplyInfo.getWorkDetailId());
|
if (workDetail != null) {
|
respDTO.setWorkDetail(workDetail);
|
}
|
}
|
|
respDTOs.add(respDTO);
|
}
|
|
return new SearchResultVO<>(
|
true, page.getCurrent(),
|
page.getSize(),
|
page.getPages(),
|
page.getTotal(),
|
respDTOs,
|
ResultCodes.OK);
|
|
}
|
|
@Override
|
public OthersWorkApprovedApplyDetailRespDTO getWorkApplyDetailForOthers(ContextCacheUser currentUser, Long workApplyId) {
|
if (workApplyId == null) {
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
WorkApplyInfo workApplyInfo = workApplyInfoService.getById(workApplyId);
|
if (workApplyInfo == null) {
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "作业申请不存在");
|
}
|
|
|
// 结果 result
|
OthersWorkApprovedApplyDetailRespDTO result = new OthersWorkApprovedApplyDetailRespDTO();
|
// 获取作业人
|
// List<WorkApplyOperatorInfo> operators = workApplyOperatorInfoService.listWorkOperatorByWorkApplyId(workApplyId);
|
// 获取层级
|
List<WorkApprovalStepInfo> steps = workApprovalStepInfoService.listApprovalRuleStepByWorkApplyId(workApplyId);
|
// 获取单元
|
List<WorkApprovalUnitInfo> units = workApprovalUnitInfoService.listApprovalRuleUnitByWorkApplyId(workApplyId);
|
// 获取审批项
|
List<WorkApprovalItemInfo> items = workApprovalItemInfoService.listWorkApprovalItemByWorkApplyId(workApplyId);
|
// 获取已经填报审批项
|
List<WorkApprovalFilledItemInfo> filledItems = workApprovalFilledItemInfoService.listApprovalFilledItemInfoByWorkApplyId(workApplyId);
|
// 获取标准
|
List<WorkApprovalItemStandInfo> stands = workApprovalItemStandInfoService.listWorkApprovalItemStandByWorkApplyId(workApplyId);
|
// 获取措施
|
List<WorkApprovalItemMeasureInfo> measures = workApprovalItemMeasureInfoService.listWorkApprovalItemMeasureByWorkApplyId(workApplyId);
|
|
// 措施处理映射
|
Map<Long, OthersWorkApprovalItemMeasureRespDTO> measureMap = new HashMap<>(measures.size());
|
OthersWorkApprovalItemMeasureRespDTO measureRespDTO;
|
MeasureTypeEnum measureTypeEnum;
|
WorkTypeEnum workTypeEnum;
|
for (WorkApprovalItemMeasureInfo measureInfo : measures) {
|
measureRespDTO = new OthersWorkApprovalItemMeasureRespDTO();
|
measureRespDTO.setMeasureId(measureInfo.getId());
|
measureRespDTO.setContext(measureInfo.getContext());
|
measureRespDTO.setCorrectVal(measureInfo.getCorrectVal());
|
measureRespDTO.setWorkType(measureInfo.getWorkType());
|
measureRespDTO.setType(measureInfo.getType());
|
measureTypeEnum = MeasureTypeEnum.parse(measureInfo.getType());
|
if (measureTypeEnum != null) {
|
measureRespDTO.setTypeDesc(measureTypeEnum.getDesc());
|
}
|
workTypeEnum = WorkTypeEnum.parse(measureInfo.getWorkType());
|
if (workTypeEnum != null) {
|
measureRespDTO.setWorkTypeDesc(workTypeEnum.getName());
|
}
|
measureMap.put(measureRespDTO.getMeasureId(), measureRespDTO);
|
}
|
|
// 标准处理映射
|
Map<Long, OthersWorkApprovalItemStandRespDTO> standMap = new HashMap<>(stands.size());
|
OthersWorkApprovalItemStandRespDTO standRespDTO;
|
WorkStandTypeEnum standTypeEnum;
|
RuleStandMatchingTypeEnum pattern;
|
for (WorkApprovalItemStandInfo standInfo : stands) {
|
standRespDTO = new OthersWorkApprovalItemStandRespDTO();
|
standRespDTO.setStandId(standInfo.getId());
|
standRespDTO.setWorkApplyId(standInfo.getWorkApplyId());
|
standRespDTO.setDepId(standInfo.getDepId());
|
standRespDTO.setDepName(standInfo.getDepName());
|
standRespDTO.setEid(standInfo.getEid());
|
standRespDTO.setMaxVal(standInfo.getMaxVal());
|
standRespDTO.setMaxValMatchPattern(standInfo.getMaxValMatchPattern());
|
pattern = RuleStandMatchingTypeEnum.parse(standInfo.getMaxValMatchPattern());
|
if (pattern != null) {
|
standRespDTO.setMaxValMatchPatternDesc(pattern.getValue());
|
}
|
standRespDTO.setMinVal(standInfo.getMinVal());
|
standRespDTO.setMinValMatchPattern(standInfo.getMinValMatchPattern());
|
pattern = RuleStandMatchingTypeEnum.parse(standInfo.getMinValMatchPattern());
|
if (pattern != null) {
|
standRespDTO.setMinValMatchPatternDesc(pattern.getValue());
|
}
|
standRespDTO.setTitle(standInfo.getTitle());
|
standRespDTO.setType(standInfo.getType());
|
standTypeEnum = WorkStandTypeEnum.parse(standInfo.getType());
|
if (standTypeEnum != null) {
|
standRespDTO.setTypeDesc(standTypeEnum.getDesc());
|
}
|
|
standMap.put(standRespDTO.getStandId(), standRespDTO);
|
}
|
|
// 审批项映射
|
Map<Long, WorkApprovalItemInfo> itemsMap = new HashMap<>(items.size());
|
for (WorkApprovalItemInfo item : items) {
|
itemsMap.put(item.getId(), item);
|
}
|
// 已填写审批项映射
|
Map<Long, List<OthersWorkApprovalUnitFilledItemRespDTO>> filledItemMap = new HashMap<>(filledItems.size());
|
OthersWorkApprovalUnitFilledItemRespDTO filledItemRespDTO;
|
WorkApprovalItemInfo itemInfo;
|
RuleItemTypeEnum itemType;
|
WorkRuleMeasureOptEnum optEnum;
|
ApprovalFilledItemType filledItemType;
|
for (WorkApprovalFilledItemInfo filledItem : filledItems) {
|
filledItemRespDTO = new OthersWorkApprovalUnitFilledItemRespDTO();
|
filledItemRespDTO.setId(filledItem.getId());
|
filledItemRespDTO.setWorkApplyId(filledItem.getWorkApplyId());
|
filledItemRespDTO.setUnitId(filledItem.getUnitId());
|
filledItemRespDTO.setMeasureVal(filledItem.getMeasureVal());
|
filledItemRespDTO.setMeasureText(filledItem.getMeasureText());
|
filledItemRespDTO.setAnalysisLocation(filledItem.getAnalysisLocation());
|
filledItemRespDTO.setVal(filledItem.getVal());
|
filledItemRespDTO.setItemId(filledItem.getItemId());
|
filledItemRespDTO.setFillType(filledItem.getFillType());
|
optEnum = WorkRuleMeasureOptEnum.parse(filledItem.getMeasureVal());
|
if (optEnum != null) {
|
filledItemRespDTO.setMeasureValDesc(optEnum.getDesc());
|
}
|
filledItemType = ApprovalFilledItemType.parse(filledItem.getFillType());
|
if (filledItemType != null) {
|
filledItemRespDTO.setFillTypeDesc(filledItemType.value);
|
}
|
itemInfo = itemsMap.get(filledItem.getItemId());
|
if (itemInfo != null) {
|
filledItemRespDTO.setItemName(itemInfo.getItemName());
|
filledItemRespDTO.setStandId(itemInfo.getStandId());
|
filledItemRespDTO.setMeasureId(itemInfo.getMeasureId());
|
filledItemRespDTO.setMeasureInvolve(itemInfo.getMeasureInvolve());
|
filledItemRespDTO.setItemType(itemInfo.getType());
|
itemType = RuleItemTypeEnum.parse(itemInfo.getType());
|
if (itemType != null) {
|
filledItemRespDTO.setItemTypeDesc(itemType.getValue());
|
}
|
// 措施
|
filledItemRespDTO.setMeasure(measureMap.get(itemInfo.getMeasureId()));
|
// 标准
|
filledItemRespDTO.setStand(standMap.get(itemInfo.getStandId()));
|
|
}
|
|
if (filledItemMap.get(filledItem.getUnitId()) == null) {
|
List<OthersWorkApprovalUnitFilledItemRespDTO> list = new ArrayList<>();
|
list.add(filledItemRespDTO);
|
filledItemMap.put(filledItem.getUnitId(), list);
|
} else {
|
filledItemMap.get(filledItem.getUnitId()).add(filledItemRespDTO);
|
}
|
}
|
|
// 作业人处理
|
// List<OthersWorkApprovedApplyOperatorRespDTO> operatorRespDTOs = new ArrayList<>(operators.size());
|
// OthersWorkApprovedApplyOperatorRespDTO operatorRespDTO;
|
// for (WorkApplyOperatorInfo operator : operators) {
|
// operatorRespDTO = new OthersWorkApprovedApplyOperatorRespDTO();
|
// operatorRespDTO.setId(operator.getId());
|
// operatorRespDTO.setOperatorUid(operator.getOperatorUid());
|
// operatorRespDTO.setOperatorUname(operator.getOperatorUname());
|
// operatorRespDTO.setOperatorCertificate(operator.getOperatorCertificate());
|
// operatorRespDTO.setOperatorPhone(operator.getOperatorPhone());
|
// operatorRespDTO.setOperatorIdentify(operator.getOperatorIdentify());
|
// operatorRespDTO.setWorkApplyId(operator.getWorkApplyId());
|
// operatorRespDTOs.add(operatorRespDTO);
|
// }
|
|
// 层级处理
|
Long currentStepId = workApplyInfo.getApprovalStepId();
|
// 已经走过的层级和当前所处层级
|
List<WorkApprovalStepInfo> approvedSteps = this.makeApprovedStepInOrder(currentStepId, steps);
|
|
List<OthersWorkApprovalStepRespDTO> stepRespDTOs = new ArrayList<>(approvedSteps.size());
|
OthersWorkApprovalStepRespDTO stepRespDTO;
|
OthersWorkApprovalUnitRespDTO stepUnitRespDTO;
|
OthersWorkApprovalItemRespDTO stepItemRespDTO;
|
ApprovalStepTypeEnum stepTypeEnum;
|
WorkApprovalStepResultEnum approvalStepResultEnum;
|
WorkApprovalUnitResultEnum approvalUnitResultEnum;
|
RuleItemTypeEnum itemTypeEnum;
|
AuditTypeEnum auditTypeEnum;
|
// 1.层级处理和单元处理
|
for (WorkApprovalStepInfo step : approvedSteps) {
|
stepRespDTO = new OthersWorkApprovalStepRespDTO();
|
stepRespDTO.setStepId(step.getId());
|
stepRespDTO.setWorkApplyId(step.getWorkApplyId());
|
stepRespDTO.setApprovalResult(step.getApprovalResult());
|
approvalStepResultEnum = WorkApprovalStepResultEnum.parse(step.getApprovalResult());
|
if (approvalStepResultEnum != null) {
|
stepRespDTO.setApprovalResultDesc(approvalStepResultEnum.getDesc());
|
}
|
stepRespDTO.setExpFinishApprovalTime(step.getExpFinishApprovalTime());
|
stepRespDTO.setFinishApprovalTime(step.getFinishApprovalTime());
|
stepRespDTO.setType(step.getType());
|
stepTypeEnum = ApprovalStepTypeEnum.parse(step.getType());
|
if (stepTypeEnum != null) {
|
stepRespDTO.setTypeDesc(stepTypeEnum.getDesc());
|
}
|
stepRespDTO.setStartApprovalTime(step.getStartApprovalTime());
|
stepRespDTO.setStepSerial(step.getStepSerial());
|
stepRespDTO.setNextStepId(step.getNextStepId());
|
stepRespDTO.setPreStepId(step.getPreStepId());
|
stepRespDTO.setContainItem(step.getContainItem());
|
stepRespDTO.setStepName(step.getStepName());
|
stepRespDTO.setAuditType(step.getAuditType());
|
auditTypeEnum = AuditTypeEnum.parse(step.getAuditType());
|
if (auditTypeEnum != null) {
|
stepRespDTO.setAuditTypeDesc(auditTypeEnum.getDesc());
|
}
|
|
// 审批项处理
|
List<WorkApprovalItemInfo> stepItems = items.stream().filter(item ->
|
// 当前层级的审批项
|
step.getId().equals(item.getStepId()))
|
// 集合
|
.collect(Collectors.toList());
|
|
List<OthersWorkApprovalItemRespDTO> stepItemDTOs = new ArrayList<>(stepItems.size());
|
for (WorkApprovalItemInfo stepItem : stepItems) {
|
stepItemRespDTO = new OthersWorkApprovalItemRespDTO();
|
stepItemRespDTO.setItemId(stepItem.getId());
|
stepItemRespDTO.setStepId(step.getId());
|
stepItemRespDTO.setWorkApplyId(stepItem.getWorkApplyId());
|
stepItemRespDTO.setItemName(stepItem.getItemName());
|
stepItemRespDTO.setMeasureId(stepItem.getMeasureId());
|
stepItemRespDTO.setMeasureInvolve(stepItem.getMeasureInvolve());
|
stepItemRespDTO.setStandId(stepItem.getStandId());
|
stepItemRespDTO.setUnitId(stepItem.getUnitId());
|
stepItemRespDTO.setType(stepItem.getType());
|
itemTypeEnum = RuleItemTypeEnum.parse(stepItem.getType());
|
stepItemRespDTO.setTypeDesc(itemTypeEnum.getValue());
|
// 措施
|
stepItemRespDTO.setMeasure(measureMap.get(stepItem.getMeasureId()));
|
// 标准
|
stepItemRespDTO.setStand(standMap.get(stepItem.getStandId()));
|
stepItemDTOs.add(stepItemRespDTO);
|
}
|
|
// 当前层级单元
|
List<WorkApprovalUnitInfo> stepUnits = units.stream().filter(unit ->
|
// 所属层级
|
step.getId().equals(unit.getStepId()))
|
// 集合
|
.collect(Collectors.toList());
|
// 单元处理
|
List<OthersWorkApprovalUnitRespDTO> stepUnitDTOs = new ArrayList<>(stepUnits.size());
|
for (WorkApprovalUnitInfo stepUnit : stepUnits) {
|
stepUnitRespDTO = new OthersWorkApprovalUnitRespDTO();
|
stepUnitRespDTO.setUnitId(stepUnit.getId());
|
stepUnitRespDTO.setStepId(stepUnit.getStepId());
|
stepUnitRespDTO.setWorkApplyId(stepUnit.getWorkApplyId());
|
stepUnitRespDTO.setResult(stepUnit.getResult());
|
approvalUnitResultEnum = WorkApprovalUnitResultEnum.parse(stepUnit.getResult());
|
if (approvalUnitResultEnum != null) {
|
stepUnitRespDTO.setResultDesc(approvalUnitResultEnum.getDesc());
|
}
|
stepUnitRespDTO.setApprovalUid(stepUnit.getApprovalUid());
|
stepUnitRespDTO.setApprovalUname(stepUnit.getApprovalUname());
|
stepUnitRespDTO.setApprovalActualTime(stepUnit.getApprovalActualTime());
|
stepUnitRespDTO.setApprovalEndTime(stepUnit.getApprovalEndTime());
|
stepUnitRespDTO.setApprovalStartTime(stepUnit.getApprovalStartTime());
|
stepUnitRespDTO.setFilledContent(stepUnit.getFillContent());
|
if (filledItemMap.get(stepUnit.getId()) != null) {
|
stepUnitRespDTO.setFilledItems(filledItemMap.get(stepUnit.getId()));
|
}
|
stepUnitDTOs.add(stepUnitRespDTO);
|
}
|
|
stepRespDTO.setStepItems(stepItemDTOs);
|
stepRespDTO.setStepUnits(stepUnitDTOs);
|
stepRespDTOs.add(stepRespDTO);
|
|
|
}
|
result.setWorkApplyId(workApplyInfo.getId());
|
result.setWorkPermitNo(workApplyInfo.getWorkPermitNo());
|
// result.setOperators(operatorRespDTOs);
|
result.setOperatorCompanys(workApplyInfo.getOperatorCompanys());
|
result.setOperatorUnames(workApplyInfo.getOperatorUnames());
|
result.setApprovalSteps(stepRespDTOs);
|
result.setWorkContent(workApplyInfo.getWorkContent());
|
result.setWorkLocation(workApplyInfo.getWorkLocation());
|
result.setHazardIdentification(workApplyInfo.getHazardIdentification());
|
return result;
|
}
|
|
/**
|
* 打印票证
|
* @param currentUser
|
*/
|
@Override
|
public void printing(ContextCacheUser currentUser, Long applyWorkId, HttpServletResponse response) {
|
//主键id不可为空
|
if(null == applyWorkId){
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
//获取当前作业基础数据
|
WorkApplyInfo workApplyInfo = workApplyInfoService.getById(applyWorkId);
|
if(workApplyInfo == null){
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT,"该条作业不存在!");
|
}
|
//判断该作业未结束不可打印（暂定）
|
if(!WorkStatusEnum.parse(workApplyInfo.getStatus()).equals(WorkStatusEnum.STATU_FINISH)){
|
throw new BusinessException(E.DATA_STATUS_CHECK_INVALID,"此作业票未走完审批流，不可导出!");
|
}
|
//调用具体导出功能
|
workPrintService.workPrint(response,workApplyInfo);
|
|
}
|
|
|
private Object getWorkDetail(WorkTypeEnum workTypeEnum, Long workApplyId, Long workDetailId) {
|
Object result = null;
|
switch (workTypeEnum) {
|
case WORK_FIRE:
|
if (null != workDetailId) {
|
WorkHotInfo workHotInfo = workHotInfoService.getById(workDetailId);
|
if (workHotInfo != null) {
|
WorkApplyHotRespDTO hotRespDTO = new WorkApplyHotRespDTO();
|
hotRespDTO.setHotId(workHotInfo.getId());
|
hotRespDTO.setWorkApplyId(workApplyId);
|
hotRespDTO.setHotMethod(workHotInfo.getHotMethod());
|
hotRespDTO.setOtherSpecialWork(workHotInfo.getOtherSpecialWork());
|
result = hotRespDTO;
|
}
|
}
|
break;
|
case WORK_CLOSE_SPACE:
|
if (null != workDetailId) {
|
WorkConfinedSpaceInfo confinedSpaceInfo = workConfinedSpaceInfoService.getById(workDetailId);
|
if (confinedSpaceInfo != null) {
|
WorkApplyConfinedSpaceRespDTO confinedSpaceRespDTO = new WorkApplyConfinedSpaceRespDTO();
|
confinedSpaceRespDTO.setId(confinedSpaceInfo.getId());
|
confinedSpaceRespDTO.setWorkApplyId(workApplyId);
|
confinedSpaceRespDTO.setCsDepId(confinedSpaceInfo.getCsDepId());
|
confinedSpaceRespDTO.setCsName(confinedSpaceInfo.getCsName());
|
confinedSpaceRespDTO.setCsOriginalName(confinedSpaceInfo.getCsOriginalName());
|
confinedSpaceRespDTO.setOtherSpecialWork(confinedSpaceInfo.getOtherSpecialWork());
|
result = confinedSpaceRespDTO;
|
}
|
}
|
break;
|
case WORK_BLIND_PLATE:
|
if (null != workDetailId) {
|
WorkBlindPlatePluggingInfo blindPlatePluggingInfo = workBlindPlatePluggingInfoService.getById(workDetailId);
|
if (blindPlatePluggingInfo != null) {
|
WorkApplyBlindPlatePluggingRespDTO blindPlatePluggingRespDTO = new WorkApplyBlindPlatePluggingRespDTO();
|
blindPlatePluggingRespDTO.setId(blindPlatePluggingInfo.getId());
|
blindPlatePluggingRespDTO.setWorkApplyId(workApplyId);
|
blindPlatePluggingRespDTO.setBpCode(blindPlatePluggingInfo.getBpCode());
|
blindPlatePluggingRespDTO.setMainMedia(blindPlatePluggingInfo.getMainMedia());
|
blindPlatePluggingRespDTO.setTemperature(blindPlatePluggingInfo.getTemperature());
|
blindPlatePluggingRespDTO.setPressure(blindPlatePluggingInfo.getPressure());
|
blindPlatePluggingRespDTO.setBpMaterialQuality(blindPlatePluggingInfo.getBpMaterialQuality());
|
blindPlatePluggingRespDTO.setBpSpecification(blindPlatePluggingInfo.getBpSpecification());
|
blindPlatePluggingRespDTO.setBpLocation(blindPlatePluggingInfo.getBpLocation());
|
blindPlatePluggingRespDTO.setInstallBpTime(blindPlatePluggingInfo.getInstallBpTime());
|
blindPlatePluggingRespDTO.setUninstallBpTime(blindPlatePluggingInfo.getUninstallBpTime());
|
blindPlatePluggingRespDTO.setOtherSpecialWork(blindPlatePluggingInfo.getOtherSpecialWork());
|
blindPlatePluggingRespDTO.setBpLocationMapPath(blindPlatePluggingInfo.getBpLocationMapPath());
|
result = blindPlatePluggingRespDTO;
|
}
|
}
|
break;
|
case WORK_BROKE_ROAD:
|
if (null != workDetailId) {
|
WorkBrokenCircuitInfo brokenCircuitInfo = workBrokenCircuitInfoService.getById(workDetailId);
|
if (brokenCircuitInfo != null) {
|
WorkApplyBrokenCircuitRespDTO brokenCircuitRespDTO = new WorkApplyBrokenCircuitRespDTO();
|
brokenCircuitRespDTO.setId(brokenCircuitInfo.getId());
|
brokenCircuitRespDTO.setWorkApplyId(workApplyId);
|
brokenCircuitRespDTO.setOperationDepId(brokenCircuitInfo.getOperationDepId());
|
brokenCircuitRespDTO.setBcReason(brokenCircuitInfo.getBcReason());
|
brokenCircuitRespDTO.setBcExplain(brokenCircuitInfo.getBcExplain());
|
brokenCircuitRespDTO.setInvolvedDepIds(brokenCircuitInfo.getInvolvedDepIds());
|
brokenCircuitRespDTO.setBcPath(brokenCircuitInfo.getBcPath());
|
result = brokenCircuitRespDTO;
|
}
|
}
|
break;
|
case WORK_DIF_SOLI:
|
if (null != workDetailId) {
|
WorkGroundBreakingInfo groundBreakingInfo = workGroundBreakingInfoService.getById(workDetailId);
|
if (groundBreakingInfo != null) {
|
WorkApplyGroundBreakingRespDTO groundBreakingRespDTO = new WorkApplyGroundBreakingRespDTO();
|
groundBreakingRespDTO.setId(groundBreakingInfo.getId());
|
groundBreakingRespDTO.setWorkApplyId(workApplyId);
|
groundBreakingRespDTO.setOperationDepId(groundBreakingInfo.getOperationDepId());
|
groundBreakingRespDTO.setGbScope(groundBreakingInfo.getGbScope());
|
groundBreakingRespDTO.setGbMethod(groundBreakingInfo.getGbMethod());
|
groundBreakingRespDTO.setOtherSpecialWork(groundBreakingInfo.getOtherSpecialWork());
|
groundBreakingRespDTO.setGbPath(groundBreakingInfo.getGbPath());
|
result = groundBreakingRespDTO;
|
}
|
}
|
break;
|
case WORK_HIGH_SPACE:
|
if (null != workDetailId) {
|
WorkAtHeightInfo atHeightInfo = workAtHeightInfoService.getById(workDetailId);
|
if (atHeightInfo != null) {
|
WorkApplyAtHeightRespDTO atHeightRespDTO = new WorkApplyAtHeightRespDTO();
|
atHeightRespDTO.setId(atHeightInfo.getId());
|
atHeightRespDTO.setWorkApplyId(workApplyId);
|
atHeightRespDTO.setOperationDepId(atHeightInfo.getOperationDepId());
|
atHeightRespDTO.setOperationHeight(atHeightInfo.getOperationHeight());
|
atHeightRespDTO.setOtherSpecialWork(atHeightInfo.getOtherSpecialWork());
|
result = atHeightRespDTO;
|
}
|
}
|
break;
|
case WORK_HANG:
|
if (null != workDetailId) {
|
WorkHoistingInfo hoistingInfo = workHoistingInfoService.getById(workDetailId);
|
if (hoistingInfo != null) {
|
WorkApplyHoistingRespDTO hoistingRespDTO = new WorkApplyHoistingRespDTO();
|
hoistingRespDTO.setId(hoistingInfo.getId());
|
hoistingRespDTO.setWorkApplyId(workApplyId);
|
hoistingRespDTO.setHoistingToolName(hoistingInfo.getHoistingToolName());
|
hoistingRespDTO.setWeightMass(hoistingInfo.getWeightMass());
|
result = hoistingRespDTO;
|
}
|
}
|
break;
|
case WORK_TEMP_ELECTRIC:
|
if (null != workDetailId) {
|
WorkTemporaryPowerInfo temporaryPowerInfo = workTemporaryPowerInfoService.getById(workDetailId);
|
if (temporaryPowerInfo != null) {
|
WorkApplyTemporaryPowerRespDTO temporaryPowerRespDTO = new WorkApplyTemporaryPowerRespDTO();
|
temporaryPowerRespDTO.setId(temporaryPowerInfo.getId());
|
temporaryPowerRespDTO.setWorkApplyId(workApplyId);
|
temporaryPowerRespDTO.setPowerAccessPoint(temporaryPowerInfo.getPowerAccessPoint());
|
temporaryPowerRespDTO.setWorkingVoltage(temporaryPowerInfo.getWorkingVoltage());
|
temporaryPowerRespDTO.setEquipmentAndPower(temporaryPowerInfo.getEquipmentAndPower());
|
result = temporaryPowerRespDTO;
|
}
|
}
|
break;
|
}
|
return result;
|
}
|
|
// 递归寻找有序的层级
|
private List<WorkApprovalStepInfo> makeApprovedStepInOrder(Long currentStepId, List<WorkApprovalStepInfo> steps) {
|
Map<Long, WorkApprovalStepInfo> map = new HashMap<>();
|
List<WorkApprovalStepInfo> result = new ArrayList<>();
|
for (WorkApprovalStepInfo step : steps) {
|
map.put(step.getId(), step);
|
}
|
|
WorkApprovalStepInfo currentStep = map.get(currentStepId);
|
make(currentStep, map, result);
|
return result;
|
}
|
|
private void make(WorkApprovalStepInfo currentStep, Map<Long, WorkApprovalStepInfo> map,List<WorkApprovalStepInfo> result) {
|
result.add(0, currentStep);
|
if (currentStep.getPreStepId() != null) {
|
currentStep = map.get(currentStep.getPreStepId());
|
make(currentStep, map, result);
|
}
|
}
|
|
/**
|
* @Description: 根据 单向变双向
|
*/
|
private List<WorkApprovalStepInfoBO> tidyRuleStepEntities(List<WorkApprovalStepInfoBO> ruleStepEntities) {
|
List<WorkApprovalStepInfoBO> result = Collections.emptyList();
|
if (ruleStepEntities != null && ruleStepEntities.size() > 0) {
|
Map<Long, WorkApprovalStepInfoBO> map = new HashMap<>();
|
Map<Long, Long> idMap = new HashMap<>();
|
// 头节点
|
for (WorkApprovalStepInfoBO workApprovalStepInfo : ruleStepEntities) {
|
map.put(workApprovalStepInfo.getOriginalPreStepId(), workApprovalStepInfo);
|
idMap.put(workApprovalStepInfo.getOriginalId(), workApprovalStepInfo.getId());
|
}
|
WorkApprovalStepInfoBO headStep = map.get(null);
|
if (headStep != null) {
|
makeNext(headStep, map,idMap);
|
}
|
|
return new ArrayList<>(map.values());
|
}
|
return result;
|
|
}
|
|
private void makeNext(WorkApprovalStepInfoBO headStep, Map<Long, WorkApprovalStepInfoBO> map,Map<Long, Long> idMap) {
|
// 获取下一个节点
|
WorkApprovalStepInfoBO nextStep = map.get(headStep.getOriginalId());
|
headStep.setNextStepId(nextStep.getId());
|
headStep.setPreStepId(idMap.get(headStep.getOriginalPreStepId()));
|
headStep = nextStep;
|
if (map.get(headStep.getOriginalId()) != null) {
|
makeNext(headStep, map,idMap);
|
}else{
|
// 尾部 特殊处理
|
headStep.setPreStepId(idMap.get(headStep.getOriginalPreStepId()));
|
}
|
|
}
|
|
|
private boolean judge(BigDecimal actualVal, BigDecimal comparedVal, RuleStandMatchingTypeEnum matchPattern) {
|
boolean result = false;
|
switch (matchPattern) {
|
case EQUAL:
|
if (actualVal.compareTo(comparedVal) == 0) {
|
result = true;
|
}
|
break;
|
case LESS_THAN:
|
if (actualVal.compareTo(comparedVal) < 0) {
|
result = true;
|
}
|
break;
|
case GREATER_THAN:
|
if (actualVal.compareTo(comparedVal) > 0) {
|
result = true;
|
}
|
break;
|
case LESS_THAN_AND_EQUAL:;
|
if (actualVal.compareTo(comparedVal) < 0 || actualVal.compareTo(comparedVal) == 0) {
|
result = true;
|
}
|
break;
|
case GREATER_THAN_AND_EQUAL:
|
if (actualVal.compareTo(comparedVal) > 0 || actualVal.compareTo(comparedVal) == 0) {
|
result = true;
|
}
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
/**
|
* @Description: 根据 RuleContinueTimeUnitEnum 获取秒数
|
* @date 2022/8/23 16:14
|
*/
|
private long generateSeconds(RuleContinueTimeUnitEnum unit, int continueTime) {
|
long result = 0;
|
if (continueTime > 0) {
|
switch (unit) {
|
case TYPE_DAY:
|
result = continueTime * 60 * 60 * 24;
|
break;
|
case TYPE_HOUR:
|
result = continueTime * 60 * 60;
|
break;
|
case TYPE_MINUTE:
|
result = continueTime * 60;
|
break;
|
case TYPE_SECOND:
|
result = continueTime;
|
break;
|
}
|
}
|
|
return result;
|
}
|
|
/**
|
* 生成作业证编号
|
*/
|
private String generateWorkCode(int workCount){
|
if(workCount < 0){
|
return null;
|
}
|
String code = null;
|
String prefix = "ZT-";
|
String serialCode = null;
|
if(workCount >= 1000000){
|
serialCode = "" + (workCount+1);
|
}else if(workCount >=0){
|
String countStr = String.valueOf(workCount+1);
|
serialCode = "0000000".substring(0,(7 - countStr.length()))+countStr;
|
}
|
if(serialCode != null && !serialCode.isEmpty()){
|
code = prefix+serialCode;
|
}
|
return code;
|
}
|
|
private Date conversionTimeType(LocalDateTime localDateTime){
|
ZoneId zoneId = ZoneId.systemDefault();
|
ZonedDateTime zdt = localDateTime.atZone(zoneId);
|
Date date = Date.from(zdt.toInstant());
|
return date;
|
}
|
|
}
|
