package com.gkhy.safePlatform.specialWork.service.impl;
|
|
import cn.hutool.core.util.IdUtil;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.gkhy.safePlatform.commons.co.ContextCacheUser;
|
import com.gkhy.safePlatform.commons.enums.E;
|
import com.gkhy.safePlatform.commons.enums.ResultCodes;
|
import com.gkhy.safePlatform.commons.enums.UserTypeEnum;
|
import com.gkhy.safePlatform.commons.exception.AusinessException;
|
import com.gkhy.safePlatform.commons.exception.BusinessException;
|
import com.gkhy.safePlatform.commons.query.PageQuery;
|
import com.gkhy.safePlatform.commons.utils.RequestContextHolder;
|
import com.gkhy.safePlatform.commons.utils.StringUtils;
|
import com.gkhy.safePlatform.commons.vo.ResultVO;
|
import com.gkhy.safePlatform.commons.vo.SearchResultVO;
|
import com.gkhy.safePlatform.specialWork.entity.*;
|
import com.gkhy.safePlatform.specialWork.enums.*;
|
import com.gkhy.safePlatform.specialWork.model.dto.req.*;
|
import com.gkhy.safePlatform.specialWork.model.dto.resp.*;
|
import com.gkhy.safePlatform.specialWork.model.query.*;
|
import com.gkhy.safePlatform.specialWork.model.query.db.*;
|
import com.gkhy.safePlatform.specialWork.mq.msg.AnalysisExpireMsg;
|
import com.gkhy.safePlatform.specialWork.mq.service.WorkAnalysisProducerService;
|
import com.gkhy.safePlatform.specialWork.service.WorkService;
|
import com.gkhy.safePlatform.specialWork.service.baseService.*;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.math.BigDecimal;
|
import java.time.LocalDateTime;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
|
@Service("workService")
|
public class WorkServiceImpl implements WorkService {
|
|
@Autowired
|
private WorkInfoService workInfoService;
|
@Autowired
|
private WorkApplyInfoService workApplyInfoService;
|
@Autowired
|
private WorkApplyOperatorInfoService workApplyOperatorInfoService;
|
@Autowired
|
private WorkApprovalStepInfoService workApprovalStepInfoService;
|
@Autowired
|
private WorkAnalysisRecordInfoService workAnalysisRecordInfoService;
|
@Autowired
|
private WorkApprovalUnitInfoService workApprovalUnitInfoService;
|
@Autowired
|
private WorkApprovalItemStandInfoService workApprovalItemStandInfoService;
|
@Autowired
|
private WorkAnalysisRecordValInfoService workAnalysisRecordValInfoService;
|
@Autowired
|
private WorkApprovalItemInfoService workApprovalItemInfoService;
|
@Autowired
|
private WorkApprovalFilledItemInfoService workApprovalFilledItemInfoService;
|
@Autowired
|
private WorkAnalysisProducerService workAnalysisProducerService;
|
|
/** 开始作业 开始作业人 必须是 监护人 **/
|
@Override
|
public void startWork(WorkStartReqDTO reqDTO) {
|
// 当前用户
|
ContextCacheUser currentUser = RequestContextHolder.contextUserLocal.get();
|
if (reqDTO.getWorkId() == null) {
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
// 1.校验相关数据是否存在
|
WorkInfo workInfo = workInfoService.getById(reqDTO.getWorkId());
|
if (workInfo == null) {
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "查询不到相关记录");
|
}
|
Long workApplyId = workInfo.getWorkApplyId();
|
WorkApplyInfo workApplyInfo = workApplyInfoService.getById(workApplyId);
|
if (workApplyInfo == null) {
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "查询不到相关申请记录记录");
|
}
|
// 2.校验业务数据状态
|
List<WorkApprovalStepInfo> workApprovalStepInfos = workApprovalStepInfoService.listApprovalRuleStepByWorkApplyId(workApplyId);
|
// 校验监护人
|
List<WorkApprovalStepInfo> guardianStepInfos = workApprovalStepInfos.stream().filter(workApprovalStepInfo ->
|
// 监护人
|
workApprovalStepInfo.getPersonType().equals(ApprovalStepPersonTypeEnum.TYPE_GUARDIAN.getType()))
|
// 集合
|
.collect(Collectors.toList());
|
if (guardianStepInfos.size() != 1) {
|
throw new AusinessException(E.DATA_STATUS_CHECK_INVALID, "监护人层级限制约束");
|
}
|
List<WorkApprovalUnitInfo> guardianUnits = workApprovalUnitInfoService.listApprovalRuleUnitByStepId(guardianStepInfos.get(0).getId());
|
|
// 操作人员匹配
|
long count = guardianUnits.stream()
|
// 监护人 匹配 当前操作人
|
.filter(unit -> unit.getApprovalUid().equals(currentUser.getUid()))
|
// 个数
|
.count();
|
if (count < 1) {
|
throw new AusinessException(E.DATA_STATUS_CHECK_INVALID, "当前操作人非作业监护人");
|
}
|
|
// 作业申请状态判断
|
if (!workApplyInfo.getStatus().equals(WorkApplyStatusEnum.STATU_FINISH.getStatus())) {
|
throw new AusinessException(E.DATA_STATUS_CHECK_INVALID, "当前作业审批流未结束");
|
}
|
// 分析状态判断
|
if (!workInfo.getWorkAnalysisStatus().equals(WorkingAnalysisStatusEnum.ANALYSIS_QUALIFIED.code)) {
|
WorkingAnalysisStatusEnum statusEnum = WorkingAnalysisStatusEnum.parse(workInfo.getWorkAnalysisStatus());
|
throw new AusinessException(E.DATA_STATUS_CHECK_INVALID, "当前作业状态:" + statusEnum.value);
|
}
|
// 作业状态判断 不是未开始的作业不能开始
|
if (!workInfo.getWorkStatus().equals(WorkingStatusEnum.WAIT_TO_START.code)) {
|
throw new AusinessException(E.DATA_STATUS_CHECK_INVALID, "当前作业状态不能开始");
|
}
|
|
// exc
|
WorkInfo workInfoEntity = new WorkInfo();
|
workInfoEntity.setId(workInfo.getId());
|
workInfoEntity.setWorkStatus(WorkingStatusEnum.WORKING_AND_WAITED_TO_FINISH.code);
|
workInfoEntity.setStartUid(currentUser.getUid());
|
workInfoEntity.setStartUname(currentUser.getRealName());
|
workInfoEntity.setWorkStartTime(LocalDateTime.now());
|
workInfoService.updateWorkInfoById(workInfoEntity);
|
}
|
|
private boolean isAllPassed(List<WorkApprovalStepInfo> analystStepInfos) {
|
boolean result = true;
|
for (WorkApprovalStepInfo stepInfo : analystStepInfos) {
|
if (!stepInfo.getType().equals(WorkApprovalStepResultEnum.RESULT_SUCCESS.getResult())) {
|
result = false;
|
break;
|
}
|
}
|
return result;
|
}
|
|
|
/** 结束作业 结束人 必须是 作业人**/
|
@Override
|
public void finishWork(WorkFinishReqDTO reqDTO) {
|
if (reqDTO.getWorkId() == null) {
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
// 1.校验相关数据是否存在
|
WorkInfo workInfo = workInfoService.getById(reqDTO.getWorkId());
|
if (workInfo == null) {
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "查询不到相关记录");
|
}
|
// 2.校验业务数据状态
|
// 审批结束 才能开始
|
if (!workInfo.getWorkStatus().equals(WorkingStatusEnum.WORKING_AND_WAITED_TO_FINISH.code)) {
|
WorkingStatusEnum workingStatusEnum = WorkingStatusEnum.parse(workInfo.getWorkStatus());
|
throw new AusinessException(E.DATA_STATUS_CHECK_INVALID, "当前作业状态:" + workingStatusEnum.value);
|
}
|
// 3.开始人 => 申请单的作业人
|
List<WorkApplyOperatorInfo> workOperators = workApplyOperatorInfoService.listWorkOperatorByWorkApplyId(workInfo.getWorkApplyId());
|
assert workOperators.size() > 0;
|
ContextCacheUser currentUser = RequestContextHolder.contextUserLocal.get();
|
long count = workOperators.stream()
|
// id相同
|
.filter(workApplyOperatorInfo -> workApplyOperatorInfo.getOperatorUid().equals(currentUser.getUid()))
|
// 个数
|
.count();
|
if (count < 1) {
|
throw new AusinessException(E.DATA_STATUS_CHECK_INVALID, "当前操作人非作业人，无法执行");
|
}
|
|
// exc
|
WorkInfo workInfoEntity = new WorkInfo();
|
workInfoEntity.setId(workInfo.getId());
|
// 作业状态: 作业中 => 作业结束
|
workInfoEntity.setWorkStatus(WorkingStatusEnum.ALREADY_FINISHED.code);
|
// 作业异常标识状态: 正常结束
|
workInfoEntity.setAbortStatus(WorkingAbortStatusEnum.NORMAL.code);
|
// 作业验收状态: 未开始 => 等待验收
|
workInfoEntity.setWorkAcceptStatus(WorkingAcceptStatusEnum.WAITED_TO_ACCEPT.code);
|
workInfoEntity.setFinishUid(currentUser.getUid());
|
workInfoEntity.setFinishUname(currentUser.getRealName());
|
workInfoEntity.setWorkFinishTime(LocalDateTime.now());
|
workInfoService.updateWorkInfoById(workInfoEntity);
|
}
|
|
/** 验收作业 验收人 必须是 审批规则的监护人**/
|
@Override
|
public void acceptWork(WorkAcceptReqDTO reqDTO) {
|
if (reqDTO.getWorkId() == null) {
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
// 1.校验相关数据是否存在
|
WorkInfo workInfo = workInfoService.getById(reqDTO.getWorkId());
|
if (workInfo == null) {
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "查询不到相关记录");
|
}
|
// 作业状态: 作业中
|
if (!workInfo.getWorkStatus().equals(WorkingStatusEnum.ALREADY_FINISHED.code)) {
|
WorkingStatusEnum workingStatusEnum = WorkingStatusEnum.parse(workInfo.getWorkStatus());
|
throw new AusinessException(E.DATA_STATUS_CHECK_INVALID, "当前作业状态:" + workingStatusEnum.value);
|
}
|
// 作业是否异常结束
|
if (workInfo.getAbortStatus() != null && !workInfo.getAbortStatus().equals(WorkingAbortStatusEnum.NORMAL.code)) {
|
WorkingAbortStatusEnum abortStatusEnum = WorkingAbortStatusEnum.parse(workInfo.getAbortStatus());
|
throw new AusinessException(E.DATA_STATUS_CHECK_INVALID, "作业异常结束-无法验收:" + abortStatusEnum.value);
|
}
|
// 作业验收状态: 等待验收状态
|
if (!workInfo.getWorkAnalysisStatus().equals(WorkingAcceptStatusEnum.WAITED_TO_ACCEPT.code)) {
|
WorkingAcceptStatusEnum workingAcceptStatusEnum = WorkingAcceptStatusEnum.parse(workInfo.getWorkAnalysisStatus());
|
throw new AusinessException(E.DATA_STATUS_CHECK_INVALID, "当前作业验收状态:" + workingAcceptStatusEnum.value);
|
}
|
// 2.验收人 <=> 当前人
|
ContextCacheUser currentUser = RequestContextHolder.contextUserLocal.get();
|
List<WorkApprovalStepInfo> workApprovalStepInfos = workApprovalStepInfoService.listApprovalRuleStepByWorkApplyId(workInfo.getWorkApplyId());
|
List<WorkApprovalStepInfo> guardianStepInfos = workApprovalStepInfos.stream()
|
// 监护人类型
|
.filter(workApprovalStepInfo -> workApprovalStepInfo.getPersonType().equals(ApprovalStepPersonTypeEnum.TYPE_GUARDIAN.getType()))
|
// 集合
|
.collect(Collectors.toList());
|
assert guardianStepInfos.size() == 1;
|
List<WorkApprovalUnitInfo> guardianUnits = workApprovalUnitInfoService.listApprovalRuleUnitByStepId(guardianStepInfos.get(0).getId());
|
long count = guardianUnits.stream()
|
// 单元 = 当前id
|
.filter(unit -> unit.getApprovalUid().equals(currentUser.getUid()))
|
// 个数
|
.count();
|
if (count < 1) {
|
throw new AusinessException(E.DATA_STATUS_CHECK_INVALID, "当前用户不为作业监护人无法验收作业");
|
}
|
|
// exc
|
WorkInfo workInfoEntity = new WorkInfo();
|
workInfoEntity.setId(workInfo.getId());
|
workInfoEntity.setWorkAcceptStatus(WorkingAcceptStatusEnum.ALREADY_ACCEPTED.code);
|
workInfoEntity.setWorkAcceptContent(reqDTO.getAcceptContent());
|
workInfoEntity.setAcceptUid(currentUser.getUid());
|
workInfoEntity.setAcceptUname(currentUser.getRealName());
|
workInfoEntity.setWorkAcceptTime(LocalDateTime.now());
|
workInfoService.updateWorkInfoById(workInfoEntity);
|
|
|
}
|
|
@Override
|
public ResultVO<List<WorkPageRespDTO>> listWorkByPage(PageQuery<WorkPageQuery> pageQuery) {
|
WorkPageQuery query = pageQuery.getSearchParams();
|
WorkPageDBQuery dbQuery = new WorkPageDBQuery();
|
if (query != null) {
|
// 时间区间
|
dbQuery.setStartTime(query.getStartTime());
|
dbQuery.setEndTime(query.getEndTime());
|
// 分析状态
|
dbQuery.setWorkAnalysisStatus(query.getWorkAnalysisStatus());
|
// 验收状态
|
dbQuery.setAcceptStatus(query.getAcceptStatus());
|
// 作业状态
|
dbQuery.setWorkStatus(query.getWorkStatus());
|
// 作业编号
|
dbQuery.setWorkPermitNo(query.getWorkPermitNo());
|
// 作业类型
|
dbQuery.setWorkType(query.getWorkType());
|
// 作业等级
|
dbQuery.setWorkLevel(query.getWorkLevel());
|
// 作业部门(申请人所属部门)
|
dbQuery.setWorkDepId(query.getWorkDepId());
|
}
|
// 管理员可见所有
|
ContextCacheUser currentUser = RequestContextHolder.contextUserLocal.get();
|
if (currentUser.getType().equals(UserTypeEnum.STAFF.getCode())) {
|
dbQuery.setDepId(currentUser.getDepId());
|
}
|
|
Page<WorkInfoDO> page = new Page<>(pageQuery.getPageIndex(), pageQuery.getPageSize(),false);
|
long total = workInfoService.countWorkInfo(dbQuery);
|
page.setTotal(total);
|
List<WorkInfoDO> data = workInfoService.listWorkInfoByPage(page, dbQuery);
|
List<WorkPageRespDTO> resData = new ArrayList<>(data.size());
|
if (data.size() > 0) {
|
WorkingAnalysisStatusEnum workingAnalysisStatusEnum;
|
WorkingStatusEnum workingStatusEnum;
|
WorkingAcceptStatusEnum acceptStatusEnum;
|
WorkTypeEnum workTypeEnum;
|
WorkLevelEnum workLevelEnum;
|
WorkingAbortStatusEnum workAbortStatusEnum;
|
WorkPageRespDTO respDTO;
|
for (WorkInfoDO workInfoDO : data) {
|
respDTO = new WorkPageRespDTO();
|
respDTO.setWorkId(workInfoDO.getWorkId());
|
respDTO.setWorkStartTime(workInfoDO.getWorkStartTime());
|
respDTO.setWorkFinishTime(workInfoDO.getWorkFinishTime());
|
respDTO.setStartUname(workInfoDO.getStartUname());
|
respDTO.setStartUid(workInfoDO.getStartUid());
|
respDTO.setFinishUname(workInfoDO.getFinishUname());
|
respDTO.setFinishUid(workInfoDO.getFinishUid());
|
respDTO.setAcceptUname(workInfoDO.getAcceptUname());
|
respDTO.setAcceptUid(workInfoDO.getAcceptUid());
|
respDTO.setWorkStatus(workInfoDO.getWorkStatus());
|
respDTO.setWorkAcceptStatus(workInfoDO.getWorkAcceptStatus());
|
respDTO.setWorkAnalysisStatus(workInfoDO.getWorkAnalysisStatus());
|
acceptStatusEnum = WorkingAcceptStatusEnum.parse(workInfoDO.getWorkAcceptStatus());
|
respDTO.setWorkAcceptStatusDesc(acceptStatusEnum.value);
|
workingStatusEnum = WorkingStatusEnum.parse(workInfoDO.getWorkAcceptStatus());
|
respDTO.setWorkStatusDesc(workingStatusEnum.value);
|
workingAnalysisStatusEnum = WorkingAnalysisStatusEnum.parse(workInfoDO.getWorkAnalysisStatus());
|
respDTO.setWorkAnalysisStatusDesc(workingAnalysisStatusEnum.value);
|
respDTO.setWorkAcceptContent(workInfoDO.getWorkAcceptContent());
|
respDTO.setWorkAcceptTime(workInfoDO.getWorkAcceptTime());
|
respDTO.setWorkApplyId(workInfoDO.getWorkApplyId());
|
respDTO.setWorkPermitNo(workInfoDO.getWorkPermitNo());
|
respDTO.setDepId(workInfoDO.getDepId());
|
respDTO.setDepName(workInfoDO.getDepName());
|
respDTO.setGmtCreate(workInfoDO.getGmtCreate());
|
respDTO.setWorkType(workInfoDO.getWorkType());
|
workTypeEnum = WorkTypeEnum.parse(workInfoDO.getWorkType());
|
respDTO.setWorkTypeDesc(workTypeEnum.getName());
|
workLevelEnum = WorkLevelEnum.parse(workInfoDO.getWorkLevel());
|
respDTO.setWorkLevelDesc(workLevelEnum.getTitle());
|
respDTO.setAbortStatus(workInfoDO.getAbortStatus());
|
respDTO.setAbortReason(workInfoDO.getAbortReason());
|
workAbortStatusEnum = WorkingAbortStatusEnum.parse(workInfoDO.getAbortStatus());
|
if (workAbortStatusEnum != null) {
|
respDTO.setAbortStatusDesc(workAbortStatusEnum.value);
|
}
|
resData.add(respDTO);
|
}
|
|
}
|
return new SearchResultVO<>(
|
true,
|
page.getCurrent(),
|
page.getSize(),
|
page.getPages(),
|
page.getTotal(),
|
resData,
|
ResultCodes.OK);
|
}
|
|
@Override
|
public ResultVO<List<WorkMyRefPageRespDTO>> listWorkMyRefByPage(PageQuery<WorkMyRefPageQuery> pageQuery) {
|
|
WorkMyRefPageQuery query = pageQuery.getSearchParams();
|
WorkMyRefPageDBQuery dbQuery = new WorkMyRefPageDBQuery();
|
if (query != null) {
|
// 时间区间
|
dbQuery.setStartTime(query.getStartTime());
|
dbQuery.setEndTime(query.getEndTime());
|
// 分析状态
|
dbQuery.setWorkAnalysisStatus(query.getWorkAnalysisStatus());
|
// 验收状态
|
dbQuery.setAcceptStatus(query.getAcceptStatus());
|
// 作业状态
|
dbQuery.setWorkStatus(query.getWorkStatus());
|
// 作业编号
|
dbQuery.setWorkPermitNo(query.getWorkPermitNo());
|
}
|
ContextCacheUser currentUser = RequestContextHolder.contextUserLocal.get();
|
dbQuery.setCurrentUid(currentUser.getUid());
|
Page<WorkInfoDO> page = new Page<>(pageQuery.getPageIndex(), pageQuery.getPageSize(),false);
|
// 总数
|
long total = workInfoService.countWorkInfoMyRef(dbQuery);
|
page.setTotal(total);
|
List<WorkInfoDO> data = workInfoService.listWorkInfoMyRefByPage(page, dbQuery);
|
List<WorkMyRefPageRespDTO> resData = new ArrayList<>(data.size());
|
if (data.size() > 0) {
|
WorkingAnalysisStatusEnum workingAnalysisStatusEnum;
|
WorkingStatusEnum workingStatusEnum;
|
WorkingAcceptStatusEnum acceptStatusEnum;
|
WorkTypeEnum workTypeEnum;
|
WorkLevelEnum workLevelEnum;
|
WorkingAbortStatusEnum workAbortStatusEnum;
|
WorkMyRefPageRespDTO respDTO;
|
for (WorkInfoDO workInfoDO : data) {
|
respDTO = new WorkMyRefPageRespDTO();
|
respDTO.setWorkId(workInfoDO.getWorkId());
|
respDTO.setWorkStartTime(workInfoDO.getWorkStartTime());
|
respDTO.setWorkFinishTime(workInfoDO.getWorkFinishTime());
|
respDTO.setStartUname(workInfoDO.getStartUname());
|
respDTO.setStartUid(workInfoDO.getStartUid());
|
respDTO.setFinishUname(workInfoDO.getFinishUname());
|
respDTO.setFinishUid(workInfoDO.getFinishUid());
|
respDTO.setAcceptUname(workInfoDO.getAcceptUname());
|
respDTO.setAcceptUid(workInfoDO.getAcceptUid());
|
respDTO.setWorkStatus(workInfoDO.getWorkStatus());
|
respDTO.setWorkAcceptStatus(workInfoDO.getWorkAcceptStatus());
|
respDTO.setWorkAnalysisStatus(workInfoDO.getWorkAnalysisStatus());
|
acceptStatusEnum = WorkingAcceptStatusEnum.parse(workInfoDO.getWorkAcceptStatus());
|
respDTO.setWorkAcceptStatusDesc(acceptStatusEnum.value);
|
workingStatusEnum = WorkingStatusEnum.parse(workInfoDO.getWorkAcceptStatus());
|
respDTO.setWorkStatusDesc(workingStatusEnum.value);
|
workingAnalysisStatusEnum = WorkingAnalysisStatusEnum.parse(workInfoDO.getWorkAnalysisStatus());
|
respDTO.setWorkAnalysisStatusDesc(workingAnalysisStatusEnum.value);
|
respDTO.setWorkAcceptContent(workInfoDO.getWorkAcceptContent());
|
respDTO.setWorkAcceptTime(workInfoDO.getWorkAcceptTime());
|
respDTO.setWorkApplyId(workInfoDO.getWorkApplyId());
|
respDTO.setWorkPermitNo(workInfoDO.getWorkPermitNo());
|
respDTO.setDepId(workInfoDO.getDepId());
|
respDTO.setDepName(workInfoDO.getDepName());
|
respDTO.setGmtCreate(workInfoDO.getGmtCreate());
|
respDTO.setWorkType(workInfoDO.getWorkType());
|
workTypeEnum = WorkTypeEnum.parse(workInfoDO.getWorkType());
|
respDTO.setWorkTypeDesc(workTypeEnum.getName());
|
workLevelEnum = WorkLevelEnum.parse(workInfoDO.getWorkLevel());
|
respDTO.setWorkLevelDesc(workLevelEnum.getTitle());
|
respDTO.setAbortStatus(workInfoDO.getAbortStatus());
|
respDTO.setAbortReason(workInfoDO.getAbortReason());
|
workAbortStatusEnum = WorkingAbortStatusEnum.parse(workInfoDO.getAbortStatus());
|
if (workAbortStatusEnum != null) {
|
respDTO.setAbortStatusDesc(workAbortStatusEnum.value);
|
}
|
resData.add(respDTO);
|
}
|
|
}
|
return new SearchResultVO<>(
|
true,
|
page.getCurrent(),
|
page.getSize(),
|
page.getPages(),
|
page.getTotal(),
|
resData,
|
ResultCodes.OK);
|
}
|
|
@Override
|
@Transactional
|
public void analysisWork(WorkAnalysisReqDTO reqDTO) {
|
if (reqDTO.getWorkId() == null) {
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
if (reqDTO.getAnalysisData() == null || reqDTO.getAnalysisData().size() == 0) {
|
throw new AusinessException(E.DATA_PARAM_NULL, "分析数据为空");
|
}
|
if (StringUtils.isBlank(reqDTO.getAnalysisLocation())) {
|
throw new AusinessException(E.DATA_PARAM_NULL, "分析地点为空");
|
}
|
// 重复提交判断
|
Set<Long> paramsItemIdSet = new HashSet<>();
|
for (WorkAnalysisValReqDTO analysisValReqDTO : reqDTO.getAnalysisData()) {
|
if (analysisValReqDTO.getItemId() == null || analysisValReqDTO.getVal() == null) {
|
throw new AusinessException(E.DATA_PARAM_NULL, "分析数据为空");
|
}
|
paramsItemIdSet.add(analysisValReqDTO.getItemId());
|
}
|
if (paramsItemIdSet.size() != reqDTO.getAnalysisData().size()) {
|
throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "不可以重复提交分析项");
|
}
|
|
// 1.校验相关数据是否存在
|
WorkInfo workInfo = workInfoService.getById(reqDTO.getWorkId());
|
if (workInfo == null) {
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "查询不到相关记录");
|
}
|
if (!workInfo.getWorkType().equals(WorkTypeEnum.WORK_FIRE.getType()) &&
|
!workInfo.getWorkType().equals(WorkTypeEnum.WORK_CLOSE_SPACE.getType())) {
|
throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "动火和受限需要分析数据");
|
}
|
Long workApplyId = workInfo.getWorkApplyId();
|
WorkApplyInfo workApplyInfo = workApplyInfoService.getById(workApplyId);
|
if (workApplyInfo == null) {
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "查询不到相关申请记录记录");
|
}
|
|
// 分析项
|
List<WorkApprovalItemInfo> workApprovalItemInfos = workApprovalItemInfoService.listWorkApprovalItemByWorkApplyId(workApplyId);
|
// 标准
|
List<WorkApprovalItemStandInfo> standInfos = workApprovalItemStandInfoService.listWorkApprovalItemStandByWorkApplyId(workApplyId);
|
// 填报项
|
List<WorkApprovalFilledItemInfo> filledItemsContent = workApprovalFilledItemInfoService.listApprovalFilledItemInfoByWorkApplyId(workApplyId);
|
// 提交的分析项id 包含在 层级的分析项id 之中
|
List<WorkAnalysisValReqDTO> analysisData = reqDTO.getAnalysisData();
|
for (WorkAnalysisValReqDTO analysisValReqDTO : analysisData) {
|
// 入参是否匹配数据库数据
|
boolean paramIsContain = false;
|
// 是否涉及当前
|
boolean isInvolved = false;
|
for (WorkApprovalFilledItemInfo filledItemInfo : filledItemsContent) {
|
if (filledItemInfo.getItemId().equals(analysisValReqDTO.getItemId())) {
|
paramIsContain = true;
|
if (filledItemInfo.getFillType().equals(ApprovalFilledItemType.INVOLVED.code)) {
|
isInvolved = true;
|
}
|
}
|
|
}
|
|
if (!paramIsContain) {
|
throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "不可以提交分析层级选定外的分析项目");
|
}
|
if (!isInvolved) {
|
throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "不可以提交分析层级不涉及的分析项目");
|
}
|
|
}
|
|
// 2.校验业务数据状态
|
// 已经结束
|
if (workInfo.getWorkStatus().equals(WorkingStatusEnum.ALREADY_FINISHED.code)) {
|
if (workInfo.getWorkAnalysisStatus().equals(WorkingAnalysisStatusEnum.ANALYSIS_EXPIRED.code)) {
|
throw new AusinessException(E.DATA_STATUS_CHECK_INVALID, "作业分析已超期");
|
}
|
if (workInfo.getWorkAnalysisStatus().equals(WorkingAnalysisStatusEnum.ANALYSIS_UNQUALIFIED.code)) {
|
throw new AusinessException(E.DATA_STATUS_CHECK_INVALID, "作业分析已经不合格，无法再次提交分析数据");
|
}
|
throw new AusinessException(E.DATA_STATUS_CHECK_INVALID, "作业已经结束");
|
}
|
|
|
// 3.获取层级
|
List<WorkApprovalStepInfo> stepInfos = workApprovalStepInfoService.listApprovalRuleStepByWorkApplyId(workApplyId);
|
Optional<WorkApprovalStepInfo> optional = stepInfos.stream().filter(step ->
|
// 分析层级
|
step.getPersonType().equals(ApprovalStepPersonTypeEnum.TYPE_ANALYST.getType()))
|
// 获取一个
|
.findFirst();
|
|
ContextCacheUser currentUser = RequestContextHolder.contextUserLocal.get();
|
// 4.层级判断
|
if (optional.isPresent()) {
|
WorkApprovalStepInfo stepInfo = optional.get();
|
List<WorkApprovalUnitInfo> approvalUnitInfos = workApprovalUnitInfoService.listApprovalRuleUnitByStepId(stepInfo.getId());
|
assert approvalUnitInfos.size() > 0;
|
// 分析人校验
|
long count = approvalUnitInfos.stream()
|
// 当前人是分析人
|
.filter(unit -> unit.getApprovalUid().equals(currentUser.getUid()))
|
// 个数
|
.count();
|
|
if (count < 1) {
|
throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "分析人必须指定为审批流程中的分析人操作");
|
}
|
}else{
|
throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "分析层级异常");
|
}
|
|
WorkApprovalStepInfo analysisStep = optional.get();
|
long distance = generateAnalysisDeadline(analysisStep.getContinueTime(), RuleContinueTimeUnitEnum.parse(analysisStep.getContinueTimeUnit()));
|
LocalDateTime deadline = LocalDateTime.now().plusSeconds(distance);
|
// exc
|
// 分析
|
WorkAnalysisRecordInfo analysisRecordInfo = new WorkAnalysisRecordInfo();
|
analysisRecordInfo.setId(IdUtil.getSnowflake(0, 0).nextId());
|
analysisRecordInfo.setAnalystUid(currentUser.getUid());
|
analysisRecordInfo.setAnalystUname(currentUser.getRealName());
|
analysisRecordInfo.setWorkId(reqDTO.getWorkId());
|
analysisRecordInfo.setWorkApplyId(workApplyId);
|
analysisRecordInfo.setExpirationTime(deadline);
|
analysisRecordInfo.setGmtCreate(LocalDateTime.now());
|
analysisRecordInfo.setWorkPermitNo(workApplyInfo.getWorkPermitNo());
|
analysisRecordInfo.setAnalysisLocation(reqDTO.getAnalysisLocation());
|
|
|
// 分析结果
|
AnalysisRecordResultEnum analysisResult = AnalysisRecordResultEnum.QUALIFIED;
|
// 分析数据
|
List<WorkAnalysisRecordValInfo> analysisRecordValInfos = new ArrayList<>(reqDTO.getAnalysisData().size());
|
WorkAnalysisRecordValInfo analysisRecordValInfo;
|
for (WorkAnalysisValReqDTO analysisValReqDTO : reqDTO.getAnalysisData()) {
|
// 获取标准对应项
|
Optional<WorkApprovalItemInfo> first = workApprovalItemInfos.stream()
|
// 标准id
|
.filter(item -> analysisValReqDTO.getItemId().equals(item.getId()))
|
// 获取对象
|
.findFirst();
|
|
assert first.isPresent();
|
WorkApprovalItemInfo itemInfo = first.get();
|
// 标准判断
|
boolean judgeByStand = judgeByStand(itemInfo.getStandId(), analysisValReqDTO.getVal(), standInfos);
|
analysisRecordValInfo = new WorkAnalysisRecordValInfo();
|
analysisRecordValInfo.setId(IdUtil.getSnowflake(0, 0).nextId());
|
analysisRecordValInfo.setRecordId(analysisRecordInfo.getId());
|
analysisRecordValInfo.setStandId(itemInfo.getStandId());
|
analysisRecordValInfo.setVal(analysisValReqDTO.getVal());
|
analysisRecordValInfo.setWorkId(workInfo.getId());
|
analysisRecordValInfo.setItemId(itemInfo.getId());
|
analysisRecordValInfo.setItemName(itemInfo.getItemName());
|
analysisRecordValInfo.setResult(judgeByStand ? AnalysisRecordValResultEnum.QUALIFIED.code
|
: AnalysisRecordValResultEnum.UNQUALIFIED.code);
|
analysisRecordValInfos.add(analysisRecordValInfo);
|
|
// 如果存在单条不合格 分析结果为不合格
|
if (!judgeByStand) {
|
analysisResult = AnalysisRecordResultEnum.UNQUALIFIED;
|
}
|
}
|
// 设置分析结果
|
analysisRecordInfo.setAnalysisResult(analysisResult.code);
|
// exc
|
// 分析
|
workAnalysisRecordInfoService.save(analysisRecordInfo);
|
// 分析数据
|
workAnalysisRecordValInfoService.saveBatchVal(analysisRecordValInfos);
|
// 当前作业分析状态更新
|
WorkingAnalysisStatusEnum workingAnalysisStatusEnum = WorkingAnalysisStatusEnum.ANALYSIS_QUALIFIED;
|
if (analysisResult == AnalysisRecordResultEnum.UNQUALIFIED) {
|
workingAnalysisStatusEnum = WorkingAnalysisStatusEnum.ANALYSIS_UNQUALIFIED;
|
}
|
workInfoService.updateWorkAnalysisStatusByWorkId(workInfo.getId(), workingAnalysisStatusEnum);
|
// 填报数据合格
|
if (analysisResult == AnalysisRecordResultEnum.QUALIFIED) {
|
// 发送同步消息
|
AnalysisExpireMsg analysisExpireMsg = new AnalysisExpireMsg();
|
analysisExpireMsg.setExpireTime(analysisRecordInfo.getExpirationTime());
|
analysisExpireMsg.setWorkId(workInfo.getId());
|
analysisExpireMsg.setWorkPermitNo(workApplyInfo.getWorkPermitNo());
|
analysisExpireMsg.setAnalysisId(analysisRecordInfo.getId());
|
workAnalysisProducerService.syncSendWorkExpireMsg(analysisExpireMsg);
|
}else{
|
// 分析不合格
|
// 作业状态 ->结束 异常状态->分析不合格
|
workInfoService.updateWorkStatusAndAbortStatusByWorkId(workInfo.getId(),
|
// 作业结束
|
WorkingStatusEnum.ALREADY_FINISHED,
|
// 分析不合格
|
WorkingAbortStatusEnum.ANALYSIS_FAILURE);
|
|
|
}
|
|
|
|
}
|
|
@Override
|
public ResultVO<List<WorkAnalysisRecordRespDTO>> listWorkAnalysisRecordByPage(PageQuery<WorkAnalysisRecordPageQuery> pageQuery) {
|
// todo 人物信息查看校验
|
List<WorkAnalysisRecordRespDTO> result = null;
|
WorkAnalysisRecordPageQuery query = pageQuery.getSearchParams();
|
WorkAnalysisRecordPageDBQuery dbQuery = new WorkAnalysisRecordPageDBQuery();
|
if (query != null) {
|
dbQuery.setWorkId(query.getWorkId());
|
}
|
|
Page<WorkAnalysisRecordInfo> page = new Page<>(pageQuery.getPageIndex(), pageQuery.getPageSize());
|
// 关闭自动优化
|
page.setOptimizeCountSql(false);
|
if (dbQuery.getWorkId() != null) {
|
List<WorkAnalysisRecordInfo> dbData = workAnalysisRecordInfoService.listRecordInfoByPage(dbQuery, page);
|
if (dbData.size() > 0) {
|
result = new ArrayList<>(dbData.size());
|
WorkAnalysisRecordRespDTO respDTO;
|
AnalysisRecordResultEnum analysisRecordResultEnum;
|
for (WorkAnalysisRecordInfo recordInfo : dbData) {
|
respDTO = new WorkAnalysisRecordRespDTO();
|
respDTO.setWorkAnalysisRecordId(recordInfo.getId());
|
respDTO.setWorkPermitNo(recordInfo.getWorkPermitNo());
|
respDTO.setWorkApplyId(recordInfo.getWorkApplyId());
|
respDTO.setWorkId(recordInfo.getWorkId());
|
respDTO.setAnalysisUid(recordInfo.getAnalystUid());
|
respDTO.setAnalysisUname(recordInfo.getAnalystUname());
|
respDTO.setAnalysisResult(recordInfo.getAnalysisResult());
|
respDTO.setGmtCreate(recordInfo.getGmtCreate());
|
respDTO.setExpirationTime(recordInfo.getExpirationTime());
|
analysisRecordResultEnum = AnalysisRecordResultEnum.parse(recordInfo.getAnalysisResult());
|
respDTO.setAnalysisResultDesc(analysisRecordResultEnum.value);
|
respDTO.setAnalysisLocation(recordInfo.getAnalysisLocation());
|
result.add(respDTO);
|
}
|
}
|
|
}else{
|
result = Collections.emptyList();
|
}
|
|
|
|
|
return new SearchResultVO<>(
|
true,
|
page.getCurrent(),
|
page.getSize(),
|
page.getPages(),
|
page.getTotal(),
|
result,
|
ResultCodes.OK);
|
}
|
|
@Override
|
public WorkAnalysisRecordDetailRespDTO listAnalysisDataByRecordId(Long workAnalysisRecordId) {
|
if (workAnalysisRecordId == null) {
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
// 数据状态校验
|
WorkAnalysisRecordInfo workAnalysisRecordInfo = workAnalysisRecordInfoService.getById(workAnalysisRecordId);
|
if (workAnalysisRecordInfo == null) {
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "分析记录不存在");
|
}
|
// todo 人物信息查看校验
|
List<WorkAnalysisRecordValInfo> dbData = workAnalysisRecordValInfoService.listRecordValByAnalysisRecordId(workAnalysisRecordId);
|
List<WorkAnalysisRecordValRespDTO> valRecords = new ArrayList<>(dbData.size());
|
WorkAnalysisRecordDetailRespDTO result = new WorkAnalysisRecordDetailRespDTO();
|
if (dbData.size() > 0) {
|
WorkAnalysisRecordValRespDTO respDTO;
|
AnalysisRecordResultEnum recordResultEnum;
|
Set<Long> itemIdSet = new HashSet<>(dbData.size());
|
for (WorkAnalysisRecordValInfo recordValInfo : dbData) {
|
respDTO = new WorkAnalysisRecordValRespDTO();
|
respDTO.setId(recordValInfo.getId());
|
respDTO.setItemId(recordValInfo.getItemId());
|
respDTO.setItemName(recordValInfo.getItemName());
|
respDTO.setResult(recordValInfo.getResult());
|
recordResultEnum = AnalysisRecordResultEnum.parse(recordValInfo.getResult());
|
respDTO.setResultDesc(recordResultEnum.value);
|
respDTO.setVal(recordValInfo.getVal());
|
respDTO.setStandId(recordValInfo.getStandId());
|
itemIdSet.add(recordValInfo.getItemId());
|
valRecords.add(respDTO);
|
}
|
result.setValRecords(valRecords);
|
// 分析项
|
List<WorkApprovalStandItemDO> dbItemInfos = workApprovalItemInfoService.listItemInfoByIds(itemIdSet);
|
Set<Long> standIdSet = new HashSet<>(dbItemInfos.size());
|
for (WorkApprovalStandItemDO itemInfo : dbItemInfos) {
|
standIdSet.add(itemInfo.getStandId());
|
}
|
// 标准
|
List<WorkApprovalItemStandInfo> dbItemStandInfos = workApprovalItemStandInfoService.listItemStandByIds(standIdSet);
|
List<WorkAnalysisRecordItemRespDTO> items = new ArrayList<>();
|
WorkAnalysisRecordItemRespDTO item;
|
WorkStandTypeEnum workStandTypeEnum;
|
RuleStandMatchingTypeEnum matchingTypeEnum;
|
for (WorkApprovalStandItemDO standItemDO : dbItemInfos) {
|
item = new WorkAnalysisRecordItemRespDTO();
|
item.setItemId(standItemDO.getId());
|
item.setItemName(standItemDO.getItemName());
|
item.setWorkApplyId(standItemDO.getWorkApplyId());
|
item.setStepId(standItemDO.getStepId());
|
item.setUnitId(standItemDO.getUnitId());
|
item.setStandId(standItemDO.getStandId());
|
List<WorkApprovalItemStandInfo> stands = dbItemStandInfos.stream()
|
// 标准id 匹配
|
.filter(itemStand -> itemStand.getId().equals(standItemDO.getStandId()))
|
// 集合
|
.collect(Collectors.toList());
|
assert stands.size() == 1;
|
WorkApprovalItemStandInfo currentStand = stands.get(0);
|
item.setType(currentStand.getType());
|
workStandTypeEnum = WorkStandTypeEnum.parse(currentStand.getType());
|
item.setTypeDesc(workStandTypeEnum.getDesc());
|
item.setDepId(currentStand.getDepId());
|
item.setDepName(currentStand.getDepName());
|
item.setMinVal(currentStand.getMinVal());
|
item.setMinValMatchPattern(currentStand.getMinValMatchPattern());
|
matchingTypeEnum = RuleStandMatchingTypeEnum.parse(currentStand.getMinValMatchPattern());
|
item.setMinValMatchPatternDesc(matchingTypeEnum.getValue());
|
item.setMaxVal(currentStand.getMaxVal());
|
item.setMaxValMatchPattern(currentStand.getMaxValMatchPattern());
|
matchingTypeEnum = RuleStandMatchingTypeEnum.parse(currentStand.getMaxValMatchPattern());
|
item.setMaxValMatchPatternDesc(matchingTypeEnum.getValue());
|
item.setTitle(currentStand.getTitle());
|
items.add(item);
|
}
|
result.setItems(items);
|
|
}
|
|
return result;
|
}
|
|
@Override
|
public SearchResultVO<List<WorkGuardianPageRespDTO>> listWorkGuardianByPage(PageQuery<WorkGuardianPageQuery> pageQuery) {
|
WorkGuardianPageDBQuery dbQuery = new WorkGuardianPageDBQuery();
|
if (pageQuery.getSearchParams() != null) {
|
// 验收状态
|
dbQuery.setAcceptStatus(pageQuery.getSearchParams().getAcceptStatus());
|
// 结束时间
|
dbQuery.setEndTime(pageQuery.getSearchParams().getEndTime());
|
// 开始时间
|
dbQuery.setStartTime(pageQuery.getSearchParams().getStartTime());
|
// 作业分析状态
|
dbQuery.setWorkAnalysisStatus(pageQuery.getSearchParams().getWorkAnalysisStatus());
|
// 作业编号
|
dbQuery.setWorkPermitNo(pageQuery.getSearchParams().getWorkPermitNo());
|
// 作业状态
|
dbQuery.setWorkStatus(pageQuery.getSearchParams().getWorkStatus());
|
}
|
ContextCacheUser currentUser = RequestContextHolder.contextUserLocal.get();
|
// 当前人是监护人的作业
|
dbQuery.setCurrentUid(currentUser.getUid());
|
Page<WorkInfo> page = new Page<>(pageQuery.getPageIndex(), pageQuery.getPageSize());
|
// 关闭自动优化
|
page.setOptimizeCountSql(false);
|
List<WorkInfoDO> dbData = workInfoService.listWorkInfoGuardianByPage(page, dbQuery);
|
List<WorkGuardianPageRespDTO> resultData = Collections.emptyList();
|
if (dbData.size() > 0) {
|
resultData = new ArrayList<>(dbData.size());
|
WorkGuardianPageRespDTO respDTO;
|
WorkingAnalysisStatusEnum workingAnalysisStatusEnum;
|
WorkingStatusEnum workingStatusEnum;
|
WorkingAcceptStatusEnum acceptStatusEnum;
|
WorkTypeEnum workTypeEnum;
|
WorkLevelEnum workLevelEnum;
|
WorkingAbortStatusEnum workAbortStatusEnum;
|
for (WorkInfoDO workInfoDo : dbData) {
|
respDTO = new WorkGuardianPageRespDTO();
|
respDTO.setWorkId(workInfoDo.getWorkId());
|
respDTO.setWorkStartTime(workInfoDo.getWorkStartTime());
|
respDTO.setWorkFinishTime(workInfoDo.getWorkFinishTime());
|
respDTO.setStartUname(workInfoDo.getStartUname());
|
respDTO.setStartUid(workInfoDo.getStartUid());
|
respDTO.setFinishUname(workInfoDo.getFinishUname());
|
respDTO.setFinishUid(workInfoDo.getFinishUid());
|
respDTO.setAcceptUname(workInfoDo.getAcceptUname());
|
respDTO.setAcceptUid(workInfoDo.getAcceptUid());
|
respDTO.setWorkStatus(workInfoDo.getWorkStatus());
|
respDTO.setWorkAcceptStatus(workInfoDo.getWorkAcceptStatus());
|
respDTO.setWorkAcceptContent(workInfoDo.getWorkAcceptContent());
|
respDTO.setWorkAcceptTime(workInfoDo.getWorkAcceptTime());
|
respDTO.setWorkApplyId(workInfoDo.getWorkApplyId());
|
respDTO.setWorkPermitNo(workInfoDo.getWorkPermitNo());
|
respDTO.setGmtCreate(workInfoDo.getGmtCreate());
|
workingStatusEnum = WorkingStatusEnum.parse(workInfoDo.getWorkStatus());
|
respDTO.setWorkStatusDesc(workingStatusEnum.value);
|
acceptStatusEnum = WorkingAcceptStatusEnum.parse(workInfoDo.getWorkAcceptStatus());
|
respDTO.setWorkAcceptStatusDesc(acceptStatusEnum.value);
|
respDTO.setWorkType(workInfoDo.getWorkType());
|
workTypeEnum = WorkTypeEnum.parse(workInfoDo.getWorkType());
|
respDTO.setWorkTypeDesc(workTypeEnum.getName());
|
respDTO.setWorkLevel(workInfoDo.getWorkLevel());
|
workLevelEnum = WorkLevelEnum.parse(workInfoDo.getWorkLevel());
|
respDTO.setWorkLevelDesc(workLevelEnum.getTitle());
|
respDTO.setDepId(workInfoDo.getDepId());
|
respDTO.setDepName(workInfoDo.getDepName());
|
workingAnalysisStatusEnum = WorkingAnalysisStatusEnum.parse(workInfoDo.getWorkAnalysisStatus());
|
respDTO.setWorkAnalysisStatusDesc(workingAnalysisStatusEnum.value);
|
respDTO.setWorkAnalysisStatus(workInfoDo.getWorkAnalysisStatus());
|
respDTO.setAbortStatus(workInfoDo.getAbortStatus());
|
respDTO.setAbortReason(workInfoDo.getAbortReason());
|
workAbortStatusEnum = WorkingAbortStatusEnum.parse(workInfoDo.getAbortStatus());
|
if (workAbortStatusEnum != null) {
|
respDTO.setAbortStatusDesc(workAbortStatusEnum.value);
|
}
|
resultData.add(respDTO);
|
}
|
}
|
return new SearchResultVO<>(
|
true,
|
page.getCurrent(),
|
page.getSize(),
|
page.getPages(),
|
page.getTotal(),
|
resultData,
|
ResultCodes.OK);
|
}
|
|
@Override
|
public ResultVO<List<WorkAcceptPageRespDTO>> listWorkAcceptByPage(PageQuery<WorkAcceptPageQuery> pageQuery) {
|
WorkAcceptPageDBQuery dbQuery = new WorkAcceptPageDBQuery();
|
if (pageQuery.getSearchParams() != null) {
|
// 验收状态
|
dbQuery.setAcceptStatus(pageQuery.getSearchParams().getAcceptStatus());
|
// 结束时间
|
dbQuery.setEndTime(pageQuery.getSearchParams().getEndTime());
|
// 开始时间
|
dbQuery.setStartTime(pageQuery.getSearchParams().getStartTime());
|
// 作业分析状态
|
dbQuery.setWorkAnalysisStatus(pageQuery.getSearchParams().getWorkAnalysisStatus());
|
// 作业编号
|
dbQuery.setWorkPermitNo(pageQuery.getSearchParams().getWorkPermitNo());
|
// 作业状态
|
dbQuery.setWorkStatus(pageQuery.getSearchParams().getWorkStatus());
|
}
|
ContextCacheUser currentUser = RequestContextHolder.contextUserLocal.get();
|
// 对作业所处部门可见
|
dbQuery.setCurrentDepId(currentUser.getDepId());
|
Page<WorkInfo> page = new Page<>(pageQuery.getPageIndex(), pageQuery.getPageSize());
|
// 关闭自动优化
|
page.setOptimizeCountSql(false);
|
List<WorkInfoDO> dbData = workInfoService.listWorkInfoAcceptByPage(page, dbQuery);
|
|
List<WorkAcceptPageRespDTO> resultData = Collections.emptyList();
|
if (dbData.size() > 0) {
|
resultData = new ArrayList<>(dbData.size());
|
WorkAcceptPageRespDTO respDTO;
|
WorkingAnalysisStatusEnum workingAnalysisStatusEnum;
|
WorkingStatusEnum workingStatusEnum;
|
WorkingAcceptStatusEnum acceptStatusEnum;
|
WorkTypeEnum workTypeEnum;
|
WorkLevelEnum workLevelEnum;
|
WorkingAbortStatusEnum workAbortStatusEnum;
|
for (WorkInfoDO workInfoDo : dbData) {
|
respDTO = new WorkAcceptPageRespDTO();
|
respDTO.setWorkId(workInfoDo.getWorkId());
|
respDTO.setWorkStartTime(workInfoDo.getWorkStartTime());
|
respDTO.setWorkFinishTime(workInfoDo.getWorkFinishTime());
|
respDTO.setStartUname(workInfoDo.getStartUname());
|
respDTO.setStartUid(workInfoDo.getStartUid());
|
respDTO.setFinishUname(workInfoDo.getFinishUname());
|
respDTO.setFinishUid(workInfoDo.getFinishUid());
|
respDTO.setAcceptUname(workInfoDo.getAcceptUname());
|
respDTO.setAcceptUid(workInfoDo.getAcceptUid());
|
respDTO.setWorkStatus(workInfoDo.getWorkStatus());
|
respDTO.setWorkAcceptStatus(workInfoDo.getWorkAcceptStatus());
|
respDTO.setWorkAcceptContent(workInfoDo.getWorkAcceptContent());
|
respDTO.setWorkAcceptTime(workInfoDo.getWorkAcceptTime());
|
respDTO.setWorkApplyId(workInfoDo.getWorkApplyId());
|
respDTO.setWorkPermitNo(workInfoDo.getWorkPermitNo());
|
respDTO.setGmtCreate(workInfoDo.getGmtCreate());
|
workingStatusEnum = WorkingStatusEnum.parse(workInfoDo.getWorkStatus());
|
respDTO.setWorkStatusDesc(workingStatusEnum.value);
|
acceptStatusEnum = WorkingAcceptStatusEnum.parse(workInfoDo.getWorkAcceptStatus());
|
respDTO.setWorkAcceptStatusDesc(acceptStatusEnum.value);
|
respDTO.setWorkType(workInfoDo.getWorkType());
|
workTypeEnum = WorkTypeEnum.parse(workInfoDo.getWorkType());
|
respDTO.setWorkTypeDesc(workTypeEnum.getName());
|
respDTO.setWorkLevel(workInfoDo.getWorkLevel());
|
workLevelEnum = WorkLevelEnum.parse(workInfoDo.getWorkLevel());
|
respDTO.setWorkLevelDesc(workLevelEnum.getTitle());
|
respDTO.setDepId(workInfoDo.getDepId());
|
respDTO.setDepName(workInfoDo.getDepName());
|
workingAnalysisStatusEnum = WorkingAnalysisStatusEnum.parse(workInfoDo.getWorkAnalysisStatus());
|
respDTO.setWorkAnalysisStatusDesc(workingAnalysisStatusEnum.value);
|
respDTO.setWorkAnalysisStatus(workInfoDo.getWorkAnalysisStatus());
|
respDTO.setAbortStatus(workInfoDo.getAbortStatus());
|
respDTO.setAbortReason(workInfoDo.getAbortReason());
|
workAbortStatusEnum = WorkingAbortStatusEnum.parse(workInfoDo.getAbortStatus());
|
if (workAbortStatusEnum != null) {
|
respDTO.setAbortStatusDesc(workAbortStatusEnum.value);
|
}
|
resultData.add(respDTO);
|
}
|
}
|
return new SearchResultVO<>(
|
true,
|
page.getCurrent(),
|
page.getSize(),
|
page.getPages(),
|
page.getTotal(),
|
resultData,
|
ResultCodes.OK);
|
}
|
|
@Override
|
public ResultVO<List<WorkAnalysisPageRespDTO>> listWorkAnalysisByPage(PageQuery<WorkAnalysisPageQuery> pageQuery) {
|
WorkAnalysisPageDBQuery dbQuery = new WorkAnalysisPageDBQuery();
|
if (pageQuery.getSearchParams() != null) {
|
// 验收状态
|
dbQuery.setAcceptStatus(pageQuery.getSearchParams().getAcceptStatus());
|
// 结束时间
|
dbQuery.setEndTime(pageQuery.getSearchParams().getEndTime());
|
// 开始时间
|
dbQuery.setStartTime(pageQuery.getSearchParams().getStartTime());
|
// 作业分析状态
|
dbQuery.setWorkAnalysisStatus(pageQuery.getSearchParams().getWorkAnalysisStatus());
|
// 作业编号
|
dbQuery.setWorkPermitNo(pageQuery.getSearchParams().getWorkPermitNo());
|
// 作业状态
|
dbQuery.setWorkStatus(pageQuery.getSearchParams().getWorkStatus());
|
}
|
ContextCacheUser currentUser = RequestContextHolder.contextUserLocal.get();
|
// 展示当前人是作业分析人的作业
|
dbQuery.setCurrentUid(currentUser.getUid());
|
Page<WorkInfo> page = new Page<>(pageQuery.getPageIndex(), pageQuery.getPageSize());
|
// 关闭自动优化
|
page.setOptimizeCountSql(false);
|
List<WorkInfoDO> dbData = workInfoService.listWorkInfoAnalysisByPage(page, dbQuery);
|
|
List<WorkAnalysisPageRespDTO> resultData = Collections.emptyList();
|
if (dbData.size() > 0) {
|
resultData = new ArrayList<>(dbData.size());
|
WorkAnalysisPageRespDTO respDTO;
|
WorkingAnalysisStatusEnum workingAnalysisStatusEnum;
|
WorkingStatusEnum workingStatusEnum;
|
WorkingAcceptStatusEnum acceptStatusEnum;
|
WorkTypeEnum workTypeEnum;
|
WorkLevelEnum workLevelEnum;
|
WorkingAbortStatusEnum workAbortStatusEnum;
|
for (WorkInfoDO workInfoDo : dbData) {
|
respDTO = new WorkAnalysisPageRespDTO();
|
respDTO.setWorkId(workInfoDo.getWorkId());
|
respDTO.setWorkStartTime(workInfoDo.getWorkStartTime());
|
respDTO.setWorkFinishTime(workInfoDo.getWorkFinishTime());
|
respDTO.setStartUname(workInfoDo.getStartUname());
|
respDTO.setStartUid(workInfoDo.getStartUid());
|
respDTO.setFinishUname(workInfoDo.getFinishUname());
|
respDTO.setFinishUid(workInfoDo.getFinishUid());
|
respDTO.setAcceptUname(workInfoDo.getAcceptUname());
|
respDTO.setAcceptUid(workInfoDo.getAcceptUid());
|
respDTO.setWorkStatus(workInfoDo.getWorkStatus());
|
respDTO.setWorkAcceptStatus(workInfoDo.getWorkAcceptStatus());
|
respDTO.setWorkAcceptContent(workInfoDo.getWorkAcceptContent());
|
respDTO.setWorkAcceptTime(workInfoDo.getWorkAcceptTime());
|
respDTO.setWorkApplyId(workInfoDo.getWorkApplyId());
|
respDTO.setWorkPermitNo(workInfoDo.getWorkPermitNo());
|
respDTO.setGmtCreate(workInfoDo.getGmtCreate());
|
workingStatusEnum = WorkingStatusEnum.parse(workInfoDo.getWorkStatus());
|
respDTO.setWorkStatusDesc(workingStatusEnum.value);
|
acceptStatusEnum = WorkingAcceptStatusEnum.parse(workInfoDo.getWorkAcceptStatus());
|
respDTO.setWorkAcceptStatusDesc(acceptStatusEnum.value);
|
respDTO.setWorkType(workInfoDo.getWorkType());
|
workTypeEnum = WorkTypeEnum.parse(workInfoDo.getWorkType());
|
respDTO.setWorkTypeDesc(workTypeEnum.getName());
|
respDTO.setWorkLevel(workInfoDo.getWorkLevel());
|
workLevelEnum = WorkLevelEnum.parse(workInfoDo.getWorkLevel());
|
respDTO.setWorkLevelDesc(workLevelEnum.getTitle());
|
respDTO.setDepId(workInfoDo.getDepId());
|
respDTO.setDepName(workInfoDo.getDepName());
|
workingAnalysisStatusEnum = WorkingAnalysisStatusEnum.parse(workInfoDo.getWorkAnalysisStatus());
|
respDTO.setWorkAnalysisStatusDesc(workingAnalysisStatusEnum.value);
|
respDTO.setWorkAnalysisStatus(workInfoDo.getWorkAnalysisStatus());
|
respDTO.setAbortStatus(workInfoDo.getAbortStatus());
|
respDTO.setAbortReason(workInfoDo.getAbortReason());
|
workAbortStatusEnum = WorkingAbortStatusEnum.parse(workInfoDo.getAbortStatus());
|
if (workAbortStatusEnum != null) {
|
respDTO.setAbortStatusDesc(workAbortStatusEnum.value);
|
}
|
resultData.add(respDTO);
|
}
|
}
|
return new SearchResultVO<>(
|
true,
|
page.getCurrent(),
|
page.getSize(),
|
page.getPages(),
|
page.getTotal(),
|
resultData,
|
ResultCodes.OK);
|
}
|
|
@Override
|
public List<WorkInvolvedAnalysisItemRespDTO> listWorkAnalysisItem(Long workId) {
|
if (workId == null) {
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
// 1.校验相关数据是否存在
|
WorkInfo workInfo = workInfoService.getById(workId);
|
if (workInfo == null) {
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "查询不到相关记录");
|
}
|
// 作业的所有审批项
|
List<WorkApprovalItemInfo> workApprovalItemInfos = workApprovalItemInfoService.listWorkApprovalItemByWorkApplyId(workInfo.getWorkApplyId());
|
// 填报信息
|
List<WorkApprovalFilledItemInfo> workApprovalFilledItemInfos = workApprovalFilledItemInfoService.listApprovalFilledItemInfoByWorkApplyId(workInfo.getWorkApplyId());
|
// 作业的所有标准
|
List<WorkApprovalItemStandInfo> standInfos = workApprovalItemStandInfoService.listWorkApprovalItemStandByWorkApplyId(workInfo.getWorkApplyId());
|
// 所有数值类型的都是分析层级的分析项
|
List<WorkApprovalItemInfo> analysisItems = workApprovalItemInfos.stream().filter(itemInfo ->
|
// 数值类型
|
itemInfo.getType().equals(RuleItemTypeEnum.NUMERIC.getCode()))
|
// 集合
|
.collect(Collectors.toList());
|
|
// 筛选涉及的分析项
|
List<WorkApprovalItemInfo> involvedAnalysisItems = analysisItems.stream().filter(itemInfo -> {
|
boolean involved = false;
|
for (WorkApprovalFilledItemInfo filledItem : workApprovalFilledItemInfos) {
|
if (filledItem.getItemId().equals(itemInfo.getId())
|
// 涉及
|
&& filledItem.getFillType().equals(ApprovalFilledItemType.INVOLVED.code)) {
|
involved = true;
|
break;
|
}
|
}
|
return involved;
|
}).collect(Collectors.toList());
|
|
// 分析项 匹配 分析标准 & 封装返回对象
|
List<WorkInvolvedAnalysisItemRespDTO> result = Collections.emptyList();
|
if (involvedAnalysisItems.size() > 0) {
|
result = new ArrayList<>(involvedAnalysisItems.size());
|
WorkInvolvedAnalysisItemStandRespDTO standRespDTO;
|
WorkInvolvedAnalysisItemRespDTO itemRespDTO;
|
WorkStandTypeEnum standTypeEnum;
|
RuleItemTypeEnum itemType;
|
RuleStandMatchingTypeEnum matchingTypeEnum;
|
for (WorkApprovalItemInfo involvedAnalysisItem : involvedAnalysisItems) {
|
itemRespDTO = new WorkInvolvedAnalysisItemRespDTO();
|
itemRespDTO.setItemId(involvedAnalysisItem.getId());
|
itemRespDTO.setItemName(involvedAnalysisItem.getItemName());
|
itemRespDTO.setWorkApplyId(involvedAnalysisItem.getWorkApplyId());
|
itemRespDTO.setStepId(involvedAnalysisItem.getStepId());
|
itemRespDTO.setUnitId(involvedAnalysisItem.getUnitId());
|
itemRespDTO.setType(involvedAnalysisItem.getType());
|
itemType = RuleItemTypeEnum.parse(involvedAnalysisItem.getType());
|
if (itemType != null) {
|
itemRespDTO.setTypeDesc(itemType.getValue());
|
}
|
Optional<WorkApprovalItemStandInfo> firstOptional = standInfos.stream().filter(standInfo ->
|
// 标准
|
standInfo.getId().equals(involvedAnalysisItem.getStandId()))
|
// 一条
|
.findFirst();
|
if (firstOptional.isPresent()) {
|
WorkApprovalItemStandInfo standInfo = firstOptional.get();
|
standRespDTO = new WorkInvolvedAnalysisItemStandRespDTO();
|
standRespDTO.setStandId(standInfo.getId());
|
standRespDTO.setStandType(standInfo.getType());
|
standTypeEnum = WorkStandTypeEnum.parse(standInfo.getType());
|
if (standTypeEnum != null) {
|
standRespDTO.setStandTypeDesc(standTypeEnum.getDesc());
|
}
|
standRespDTO.setMinVal(standInfo.getMinVal());
|
standRespDTO.setMinValMatchPattern(standInfo.getMinValMatchPattern());
|
matchingTypeEnum = RuleStandMatchingTypeEnum.parse(standInfo.getMinValMatchPattern());
|
if (matchingTypeEnum != null) {
|
standRespDTO.setMinValMatchPatternDesc(matchingTypeEnum.getValue());
|
}
|
standRespDTO.setMaxVal(standInfo.getMaxVal());
|
standRespDTO.setMaxValMatchPattern(standInfo.getMaxValMatchPattern());
|
matchingTypeEnum = RuleStandMatchingTypeEnum.parse(standInfo.getMaxValMatchPattern());
|
if (matchingTypeEnum != null) {
|
standRespDTO.setMaxValMatchPatternDesc(matchingTypeEnum.getValue());
|
}
|
standRespDTO.setTitle(standInfo.getTitle());
|
// 标准设置
|
itemRespDTO.setStand(standRespDTO);
|
}
|
// addList
|
result.add(itemRespDTO);
|
|
}
|
}
|
|
return result;
|
|
}
|
|
@Override
|
public void abortWork(WorkAbortReqDTO reqDTO) {
|
if (reqDTO.getWorkId() == null) {
|
throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
|
}
|
if (StringUtils.isBlank(reqDTO.getAbortReason())) {
|
throw new AusinessException(E.DATA_PARAM_NULL, "请填写作业中止原因");
|
}
|
// 1.校验相关数据是否存在
|
WorkInfo workInfo = workInfoService.getById(reqDTO.getWorkId());
|
if (workInfo == null) {
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "查询不到相关记录");
|
}
|
|
// 2.中止人 <=> 当前人
|
ContextCacheUser currentUser = RequestContextHolder.contextUserLocal.get();
|
List<WorkApprovalStepInfo> workApprovalStepInfos = workApprovalStepInfoService.listApprovalRuleStepByWorkApplyId(workInfo.getWorkApplyId());
|
List<WorkApprovalStepInfo> guardianStepInfos = workApprovalStepInfos.stream()
|
// 监护人类型
|
.filter(workApprovalStepInfo -> workApprovalStepInfo.getPersonType().equals(ApprovalStepPersonTypeEnum.TYPE_GUARDIAN.getType()))
|
// 集合
|
.collect(Collectors.toList());
|
assert guardianStepInfos.size() == 1;
|
List<WorkApprovalUnitInfo> guardianUnits = workApprovalUnitInfoService.listApprovalRuleUnitByStepId(guardianStepInfos.get(0).getId());
|
long count = guardianUnits.stream()
|
// 单元 = 当前id
|
.filter(unit -> unit.getApprovalUid().equals(currentUser.getUid()))
|
// 个数
|
.count();
|
if (count < 1) {
|
throw new AusinessException(E.DATA_STATUS_CHECK_INVALID, "当前用户不为作业监护人无法中止作业");
|
}
|
|
// exc
|
WorkInfo workInfoEntity = new WorkInfo();
|
workInfoEntity.setId(workInfo.getId());
|
workInfoEntity.setWorkStatus(WorkingStatusEnum.ALREADY_FINISHED.code);
|
workInfoEntity.setAbortStatus(WorkingAbortStatusEnum.EXCEPTION_SUBMISSION.code);
|
workInfoEntity.setAbortReason(reqDTO.getAbortReason());
|
workInfoService.updateWorkInfoById(workInfoEntity);
|
|
}
|
|
private long generateAnalysisDeadline(Integer continueTime, RuleContinueTimeUnitEnum continueTimeUnit) {
|
long result = 0;
|
switch (continueTimeUnit) {
|
case TYPE_SECOND:
|
result = (long) continueTime;
|
break;
|
case TYPE_MINUTE:
|
result = (long) continueTime * 60;
|
break;
|
case TYPE_HOUR:
|
result = (long) continueTime * 60 * 60;
|
break;
|
case TYPE_DAY:
|
result = (long) continueTime * 60 * 60 * 60;
|
break;
|
}
|
return result;
|
}
|
|
// 根据标准判断值是否符合情况
|
// 前提:standId 一定在 standInfos 之中
|
private boolean judgeByStand(Long standId, BigDecimal val, List<WorkApprovalItemStandInfo> standInfos) {
|
|
// 计算过滤
|
Optional<WorkApprovalItemStandInfo> first = standInfos.stream().filter(stand -> stand.getId().equals(standId)).findFirst();
|
assert first.isPresent();
|
WorkApprovalItemStandInfo standInfo = first.get();
|
boolean minJudge = judge(val, standInfo.getMinVal(), RuleStandMatchingTypeEnum.parse(standInfo.getMinValMatchPattern()));
|
boolean maxJudge = judge(val, standInfo.getMaxVal(), RuleStandMatchingTypeEnum.parse(standInfo.getMaxValMatchPattern()));
|
return minJudge && maxJudge;
|
|
}
|
|
|
|
|
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;
|
|
}
|
|
}
|
