package com.gk.hotwork.doublePrevention.service.impl;
|
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.gk.hotwork.Domain.DepartmentInfo;
|
import com.gk.hotwork.Domain.Vo.PageQuery;
|
import com.gk.hotwork.Domain.Vo.SearchResultVO;
|
import com.gk.hotwork.Domain.co.ContextCacheUser;
|
import com.gk.hotwork.Domain.dto.DepInfoRPCRespDTO;
|
import com.gk.hotwork.Domain.dto.UserRPCRespDTO;
|
import com.gk.hotwork.Service.DepartmentService;
|
import com.gk.hotwork.Service.Middle.AccountAuthService;
|
import com.gk.hotwork.Service.Middle.AccountDepartmentService;
|
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.doublePrevention.entity.dto.query.OwnRectifyPageQuery;
|
import com.gk.hotwork.doublePrevention.entity.dto.query.db.OwnRectifyPageDBQuery;
|
import com.gk.hotwork.doublePrevention.entity.dto.resp.*;
|
import com.gk.hotwork.doublePrevention.enums.DataConvertEnum;
|
import com.gk.hotwork.doublePrevention.enums.ImageTypeEnum;
|
import com.gk.hotwork.doublePrevention.utils.BeanCopyUtils;
|
import com.gk.hotwork.doublePrevention.utils.SnowFlow;
|
import com.gk.hotwork.Domain.Vo.ResultVO;
|
import com.gk.hotwork.doublePrevention.entity.*;
|
import com.gk.hotwork.doublePrevention.entity.dto.req.*;
|
import com.gk.hotwork.doublePrevention.enums.StatusEnum;
|
import com.gk.hotwork.doublePrevention.enums.SyncEnum;
|
import com.gk.hotwork.doublePrevention.repository.param.*;
|
import com.gk.hotwork.doublePrevention.service.RectifyService;
|
import com.gk.hotwork.doublePrevention.service.baseService.*;
|
import org.apache.commons.lang3.ObjectUtils;
|
|
import org.apache.commons.lang3.StringUtils;
|
import org.redisson.api.RLock;
|
import org.redisson.api.RedissonClient;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.LocalTime;
|
import java.time.ZoneId;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.UUID;
|
import java.util.concurrent.TimeUnit;
|
import java.util.stream.Collectors;
|
|
@Service
|
public class RectifyServiceImpl implements RectifyService {
|
|
@Autowired
|
private AccountAuthService accountAuthService;
|
@Autowired
|
private AccountDepartmentService accountDepartmentService;
|
@Autowired
|
private RedissonClient redissonClient;
|
|
@Autowired
|
private PreventDangerManageService preventDangerManageService;
|
@Autowired
|
private PreventDangerRectifyService preventDangerRectifyService;
|
@Autowired
|
private PreventDangerCheckTaskService preventDangerCheckTaskService;
|
@Autowired
|
private PreventProduceDeviceService preventProduceDeviceService;
|
@Autowired
|
private PreventDangerCheckTaskUnitService preventDangerCheckTaskUnitService;
|
@Autowired
|
private PreventReportConfigService preventReportConfigService;
|
@Autowired
|
private PreventRiskAnaUnitService preventRiskAnaUnitService;
|
@Autowired
|
private DepartmentService departmentService;
|
@Autowired
|
private PreventDangerManageTimeoutService preventDangerManageTimeoutService;
|
@Autowired
|
private PreventDangerImageService preventDangerImageService;
|
|
//隐患治理清单
|
/**
|
* 隐患治理清单-分页查询
|
*/
|
@Override
|
public ResultVO<PreventDangerManage> getDangerManagePage(Long userId, PreventDangerManageQueryReqDTO manageQueryReqDTO) {
|
|
ResultVO resultVO = new ResultVO<>();
|
resultVO.setCode("200");
|
resultVO.setMsg("查询成功");
|
|
List<PreventDangerManageQueryRespDTO> list = new ArrayList<>();
|
Integer pageIndex = manageQueryReqDTO.getPageIndex();
|
Integer pageSize = manageQueryReqDTO.getPageSize();
|
|
//获取用户信息
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
|
if (rpcResult == null) {
|
throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
|
}
|
if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
|
throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
|
}
|
if (rpcResult.getData() == null) {
|
throw new BusinessException(ResultCodes.RPC_DATA_NULL);
|
}
|
if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
|
throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
|
}
|
UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();
|
if (ObjectUtils.isEmpty(userById)) {
|
throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
|
}
|
PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
|
//获取到所有符合条件的隐患治理清单信息
|
IPage<PreventDangerManage> page =
|
preventDangerManageService.getDangerManagePage(new Page<>(pageIndex, pageSize), manageQueryReqDTO);
|
if (ObjectUtils.isEmpty(page)){
|
resultVO.setMsg("查询成功,无数据");
|
return resultVO;
|
}
|
//遍历结果集，封装数据
|
for (PreventDangerManage record : page.getRecords()) {
|
PreventDangerManageQueryRespDTO respDTO = BeanCopyUtils.copyBean(record, PreventDangerManageQueryRespDTO.class);
|
respDTO.setPageIndex((int) page.getCurrent());
|
respDTO.setPageSize((int) page.getSize());
|
PreventProduceDevice deviceById = preventProduceDeviceService.getDeviceById(record.getProduceDeviceId());
|
if (ObjectUtils.isNotEmpty(deviceById)){
|
respDTO.setProduceDeviceName(deviceById.getProduceDeviceName());
|
}
|
|
PreventRiskAnaUnit riskUnitById = preventRiskAnaUnitService.getRiskUnitById(record.getRiskUnitId());
|
if (ObjectUtils.isNotEmpty(riskUnitById)){
|
respDTO.setRiskUnitName(riskUnitById.getRiskUnitName());
|
}
|
PreventDangerRectify rectifyByManageId = preventDangerRectifyService.getRectifyByManageId(record.getId());
|
// 上报图片
|
List<PreventDangerImage> images = preventDangerImageService.listImagesByParentId(record.getId());
|
if (ObjectUtils.isNotEmpty(rectifyByManageId)){
|
//获取责任人信息
|
ResultVO<UserRPCRespDTO> liablePersonResult = accountAuthService.getUserById(rectifyByManageId.getLiablePersonId());
|
UserRPCRespDTO liablePerson = (UserRPCRespDTO)liablePersonResult.getData();
|
if (rectifyByManageId.getCost() != null){
|
respDTO.setCost(rectifyByManageId.getCost());
|
}
|
if (rectifyByManageId.getRectifyDesc() != null){
|
respDTO.setRectifyDesc(rectifyByManageId.getRectifyDesc());
|
}
|
if (rectifyByManageId.getRectifyInfo() != null){
|
respDTO.setRectifyInfo(rectifyByManageId.getRectifyInfo());
|
}
|
if (rectifyByManageId.getCheckAcceptPersonId() != null){
|
respDTO.setCheckAcceptTime(rectifyByManageId.getCheckAcceptTime());
|
respDTO.setCheckAcceptPerson(rectifyByManageId.getCheckAcceptPerson());
|
respDTO.setCheckAcceptDesc(rectifyByManageId.getCheckAcceptDesc());
|
respDTO.setLiablePersonId(rectifyByManageId.getLiablePersonId());
|
}
|
DepartmentInfo departmentInfo = departmentService.getDepartmentInfoById(rectifyByManageId.getRectifyDepId());
|
if (departmentInfo != null) {
|
respDTO.setRectifyDepName(departmentInfo.getDepartment());
|
}
|
respDTO.setCheckAcceptPersonId(rectifyByManageId.getCheckAcceptPersonId());
|
respDTO.setRectifyTime(rectifyByManageId.getRectifyTime());
|
respDTO.setRectifyType(rectifyByManageId.getRectifyType());
|
respDTO.setRectifyDepId(rectifyByManageId.getRectifyDepId());
|
respDTO.setLiablePersonId(rectifyByManageId.getLiablePersonId());
|
respDTO.setLastEditUserName(rectifyByManageId.getLiablePerson());
|
respDTO.setRectifyDepId(rectifyByManageId.getRectifyDepId());
|
respDTO.setTimeOutDesc(respDTO.getTimeOutDesc());
|
respDTO.setRectifyId(rectifyByManageId.getId());
|
|
List<PreventDangerManageImageRespDTO> imageRespDTOs = new ArrayList<>(images.size());
|
PreventDangerManageImageRespDTO reportImage;
|
if (images.size() > 0) {
|
for (PreventDangerImage image : images) {
|
reportImage = new PreventDangerManageImageRespDTO();
|
reportImage.setId(image.getId());
|
reportImage.setImagePath(image.getImagePath());
|
reportImage.setParentId(image.getParentId());
|
reportImage.setType(image.getType());
|
imageRespDTOs.add(reportImage);
|
}
|
}
|
List<String> reportList = imageRespDTOs.stream().filter(item -> item.getType().equals(ImageTypeEnum.REPORT.getCode())).map(PreventDangerManageImageRespDTO::getImagePath).collect(Collectors.toList());
|
List<String> rectifyList = imageRespDTOs.stream().filter(item -> item.getType().equals(ImageTypeEnum.RECTIFY.getCode())).map(PreventDangerManageImageRespDTO::getImagePath).collect(Collectors.toList());
|
List<String> acceptList = imageRespDTOs.stream().filter(item -> item.getType().equals(ImageTypeEnum.ACCEPT.getCode())).map(PreventDangerManageImageRespDTO::getImagePath).collect(Collectors.toList());
|
respDTO.setReportImages(reportList);
|
respDTO.setRectifyImages(rectifyList);
|
respDTO.setAcceptImages(acceptList);
|
}
|
DepartmentInfo departmentInfo1 = departmentService.getDepartmentInfoById(record.getDepId());
|
respDTO.setReportState(reportConfigById.getReportState());
|
respDTO.setReportType(reportConfigById.getReportType());
|
respDTO.setDepName(departmentInfo1.getDepartment());
|
list.add(respDTO);
|
}
|
resultVO.setData(list);
|
resultVO.setCount((int) page.getTotal());
|
|
return resultVO;
|
}
|
/**
|
* 隐患治理清单-列表
|
*/
|
@Override
|
public ResultVO<PreventDangerManage> listDangerManage(Long valueOf) {
|
ResultVO resultVO = new ResultVO<>();
|
resultVO.setCode("200");
|
resultVO.setMsg("查询成功");
|
|
List<PreventDangerManage> dangerManages = preventDangerManageService.listDangerManage();
|
List<PreventDangerManageListQueryRespDTO> respDTOS =
|
BeanCopyUtils.copyBeanList(dangerManages, PreventDangerManageListQueryRespDTO.class);
|
|
resultVO.setData(respDTOS);
|
return resultVO;
|
}
|
/**
|
* 隐患管理-手工上报-配置
|
*/
|
@Override
|
public ResultVO<PreventRiskAnaUnit> updateDangerManagerReport(Long userId, PreventHandReportConfigReqDTO preventHandReportConfigReqDTO) {
|
|
ResultVO resultVO = new ResultVO<>();
|
resultVO.setCode("200");
|
resultVO.setMsg("修改上报数据成功");
|
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
|
if (rpcResult == null) {
|
throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
|
}
|
if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
|
throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
|
}
|
if (rpcResult.getData() == null) {
|
throw new BusinessException(ResultCodes.RPC_DATA_NULL);
|
}
|
if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
|
throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
|
}
|
if (preventHandReportConfigReqDTO.getId() == null){
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "传参非法");
|
}
|
if (preventHandReportConfigReqDTO.getReportSwitch() == null){
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "传参非法");
|
}
|
//查询当前隐患的配置
|
PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(preventHandReportConfigReqDTO.getId());
|
//配置相同，做处理
|
if (dangerManageById.getReportSwitch() == preventHandReportConfigReqDTO.getReportSwitch()){
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "与当前配置相同");
|
}
|
int result ;
|
//读取主配置信息
|
PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
|
//只有当开启上报，且类型为手动上报时，可以修改
|
if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
|
&& reportConfigById.getReportType() == SyncEnum.REPORT_AUTO_EXEC_CONFIG.getCode()){
|
result = preventDangerManageService.updateDangerManagerReport(preventHandReportConfigReqDTO);
|
|
}else {
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "当前上报配置，不支持对单条数据操作");
|
}
|
resultVO.setCount(result);
|
return resultVO;
|
}
|
|
/**
|
* 隐患治理清单-新增
|
*/
|
@Transactional
|
@Override
|
public ResultVO<PreventDangerManage> saveDangerManage(Long userId, PreventDangerManageSaveReqDTO manageSaveReqDTO) {
|
|
ResultVO resultVO = new ResultVO<>();
|
resultVO.setCode("200");
|
resultVO.setMsg("新增成功");
|
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
|
if (rpcResult == null) {
|
throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
|
}
|
if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
|
throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
|
}
|
if (rpcResult.getData() == null) {
|
throw new BusinessException(ResultCodes.RPC_DATA_NULL);
|
}
|
if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
|
throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
|
}
|
UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();
|
|
if (ObjectUtils.isEmpty(userById)) {
|
throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
|
}
|
//校验参数
|
if (manageSaveReqDTO.getDangerLevel() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "隐患等级不能为空");
|
}
|
if (manageSaveReqDTO.getDangerType() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "隐患类型不能为空");
|
}
|
if (manageSaveReqDTO.getDepId() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "隐患所属部门不能为空");
|
}
|
if (manageSaveReqDTO.getDangerCode() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "隐患名称不能为空");
|
}
|
// 图片
|
if (manageSaveReqDTO.getReportImages() == null || manageSaveReqDTO.getReportImages().size() < 1) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "图片上传不能为空");
|
}
|
for (String path : manageSaveReqDTO.getReportImages()) {
|
if (StringUtils.isBlank(path)) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "图片上传不能为空路径");
|
}
|
}
|
// 图片
|
if (manageSaveReqDTO.getReportImages().size() > 3) {
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "图片上传不能超过三张");
|
}
|
//校验部门是否存在
|
// ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(userId, manageSaveReqDTO.getDepId());
|
DepartmentInfo departmentInfo = departmentService.getDepartmentInfoById(manageSaveReqDTO.getDepId());
|
if(ObjectUtils.isEmpty(departmentInfo)){
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确责任部门");
|
}
|
if (manageSaveReqDTO.getRiskUnitId() != null){
|
PreventRiskAnaUnit riskUnitById = preventRiskAnaUnitService.getRiskUnitById(manageSaveReqDTO.getRiskUnitId());
|
if(ObjectUtils.isEmpty(riskUnitById)){
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确的风险分析单元");
|
}
|
}
|
|
if (manageSaveReqDTO.getProduceDeviceId() != null){
|
PreventProduceDevice deviceById =
|
preventProduceDeviceService.getDeviceById(manageSaveReqDTO.getProduceDeviceId());
|
if (ObjectUtils.isEmpty(deviceById)){
|
throw new BusinessException(E.DATA_PARAM_NULL, "请填写正确的生产装置");
|
}
|
PreventRiskAnaUnit riskUnitById = preventRiskAnaUnitService.getRiskUnitById(manageSaveReqDTO.getRiskUnitId());
|
if (ObjectUtils.isNotEmpty(riskUnitById)){
|
if (!riskUnitById.getProduceDeviceId().equals(manageSaveReqDTO.getProduceDeviceId())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "请填写生产装置对应的分析单元");
|
}
|
}else if (ObjectUtils.isEmpty(riskUnitById)){
|
throw new BusinessException(E.DATA_PARAM_NULL, "请填写生产装置对应的分析单元");
|
}
|
}
|
if (manageSaveReqDTO.getRectifyType() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改类型不能为空");
|
}
|
if (manageSaveReqDTO.getDangerResult() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "隐患可能造成的后果不能为空");
|
}
|
if (manageSaveReqDTO.getLiablePersonId() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改责任人不能为空");
|
}
|
//责任人信息
|
ResultVO<UserRPCRespDTO> execUserResult = accountAuthService.getUserById(manageSaveReqDTO.getLiablePersonId());
|
UserRPCRespDTO liableUser = (UserRPCRespDTO)execUserResult.getData();
|
if (ObjectUtils.isEmpty(liableUser)){
|
throw new BusinessException(E.DATA_PARAM_NULL, "该责任人不存在或已被删除，请选择正确的责任人");
|
}
|
if (manageSaveReqDTO.getRectifyTime() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改期限不能为空");
|
}
|
if (manageSaveReqDTO.getRectifyDepId() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改部门不能为空");
|
}
|
if (!manageSaveReqDTO.getRectifyDepId().equals(liableUser.getDepartment().getDepId())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改人不属于该部门");
|
}
|
|
//获取需要填充的信息
|
SnowFlow snowFlow = new SnowFlow();//雪花算法生成器
|
String uuid = UUID.randomUUID().toString();
|
Date date = new Date();
|
long dangerManagerId = snowFlow.nextId();
|
//读取上报主配置
|
PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
|
/**设置隐患管理表参数*/
|
PreventDangerManage dangerManage = BeanCopyUtils.copyBean(manageSaveReqDTO, PreventDangerManage.class);
|
dangerManage.setId(dangerManagerId);
|
dangerManage.setUuid(uuid);
|
dangerManage.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());
|
dangerManage.setGmtCreate(date);
|
dangerManage.setGmtModitify(date);
|
dangerManage.setCreateByUserName(userById.getRealName());
|
dangerManage.setLastEditUserName(userById.getRealName());
|
dangerManage.setEnterpriseId((long) 1);
|
dangerManage.setEnterpriseUuid("123124134");
|
dangerManage.setDangerStatus(StatusEnum.DANGER_MANAGER_RECTIFY.getCode());
|
dangerManage.setDangerReview(StatusEnum.DANGER_RECTIFY_WAIT.getCode());
|
dangerManage.setDangerCode(manageSaveReqDTO.getDangerCode());
|
dangerManage.setDangerCloseReason(null);
|
//这暂时不用字段
|
dangerManage.setTaskId(null);
|
dangerManage.setRegistantId(null);
|
dangerManage.setRegisterTime(null);
|
dangerManage.setRegistantName(null);
|
|
/**设置隐患整改验收表的参数*/
|
//获取需要填充的信息
|
String RectifyUuid = UUID.randomUUID().toString();
|
long rectifyId = snowFlow.nextId();
|
//封装参数
|
PreventDangerRectify dangerRectify = BeanCopyUtils.copyBean(manageSaveReqDTO, PreventDangerRectify.class);
|
dangerRectify.setId(rectifyId);
|
dangerRectify.setUuid(RectifyUuid);
|
dangerRectify.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());
|
dangerRectify.setGmtCreate(date);
|
dangerRectify.setCreateByUserName(userById.getRealName());
|
dangerRectify.setGmtModitify(date);
|
dangerRectify.setLastEditUserName(userById.getRealName());
|
dangerRectify.setEnterpriseId((long) 1);
|
dangerRectify.setEnterpriseUuid("1564wq");
|
dangerRectify.setDangerManagerUuid(uuid);
|
dangerRectify.setDangerManagerId(dangerManagerId);
|
dangerRectify.setLiablePerson(liableUser.getRealName());
|
dangerRectify.setDangerCode(null);
|
dangerRectify.setApplyTime(null);
|
dangerRectify.setTimeOutDesc(null);
|
dangerRectify.setRectifyInfo(null);
|
dangerRectify.setCheckAcceptPerson(userById.getRealName());
|
dangerRectify.setRectifyDepId(manageSaveReqDTO.getRectifyDepId());
|
dangerRectify.setDangerReview(StatusEnum.DANGER_RECTIFY_WAIT.getCode());
|
dangerRectify.setCheckAcceptPersonId(userId);
|
dangerRectify.setCheckAcceptPerson(userById.getRealName());
|
// 不确定是否需要的字段
|
dangerRectify.setCheckAcceptTime(null);
|
dangerRectify.setCheckAcceptDesc(null);
|
//TODO
|
//设置上报时间为空，以隐患管理表为主，同时设置上报
|
dangerManage.setReportTime(null);
|
dangerRectify.setReportTime(null);
|
//设置本条数据上报更新时间
|
dangerManage.setUpdateReportDataTime(new Date());
|
dangerRectify.setUpdateReportDataTime(new Date());
|
//读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置
|
if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
|
&& reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
|
//设置上报状态为-等待上报
|
dangerManage.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
dangerRectify.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
//设置本条数据上报开关为-开启
|
dangerManage.setReportSwitch(SyncEnum.REPORT_ON.getCode());
|
//其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作
|
}else {
|
//设置上报状态为-不上报
|
dangerManage.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
|
dangerRectify.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
|
//设置本条数据上报开关为-关闭
|
dangerManage.setReportSwitch(SyncEnum.REPORT_OFF.getCode());
|
}
|
//生成隐患编码
|
LocalDateTime t = dangerManage.getGmtCreate().toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
|
LocalDate localDate = t.toLocalDate();
|
LocalDateTime startTime = LocalDateTime.of(localDate, LocalTime.of(0,0,0));
|
LocalDateTime endTime = LocalDateTime.of(localDate, LocalTime.of(23,59,59));
|
Date start = Date.from(startTime.atZone(ZoneId.systemDefault()).toInstant());
|
Date end = Date.from(endTime.atZone(ZoneId.systemDefault()).toInstant());
|
//1、加分布式锁
|
String lockName = "LOCK_DANGER_CODE_GENERATE";
|
RLock lock = redissonClient.getLock(lockName);
|
lock.lock(3, TimeUnit.SECONDS);
|
int count = -1;
|
try {
|
count = preventDangerManageService.countByCreateTime(start,end);
|
} catch (Exception e) {
|
lock.unlock();
|
throw new BusinessException(E.ADD_FAIL, "保存隐患整改信息失败");
|
}
|
//2、生成编码
|
String serialCode = generateDangerSerialCode(dangerManage.getGmtCreate(),count);
|
if(serialCode == null || serialCode.isEmpty()){
|
throw new BusinessException(E.ADD_FAIL, "保存隐患整改信息失败");
|
}
|
dangerManage.setSerialCode(serialCode);
|
|
|
// 图片
|
List<PreventDangerImage> images = new ArrayList<>();
|
PreventDangerImage image;
|
for (String path : manageSaveReqDTO.getReportImages()) {
|
image = new PreventDangerImage();
|
image.setId(snowFlow.nextId());
|
image.setImagePath(path);
|
image.setParentId(dangerManage.getId());
|
image.setStatus(DataConvertEnum.DELETE_STATUS_USE.getCode());
|
image.setType(ImageTypeEnum.REPORT.getCode());
|
images.add(image);
|
}
|
preventDangerImageService.saveBatch(images);
|
|
|
|
int step = 1;
|
//保存隐患管理信息
|
if (step == 1){
|
int resultManage = preventDangerManageService.saveDangerManage(dangerManage);
|
if (resultManage < 1){
|
throw new BusinessException(E.ADD_FAIL, "保存隐患管理信息失败");
|
}else {
|
step = 2;
|
}
|
}
|
//保存隐患整改信息
|
if (step == 2){
|
int resultRectify = preventDangerRectifyService.saveDangerRectify(dangerRectify);
|
if (resultRectify < 1){
|
throw new BusinessException(E.ADD_FAIL, "保存隐患整改信息失败");
|
}
|
}
|
|
return resultVO;
|
}
|
|
/**
|
* 隐患管理清单-修改
|
*/
|
@Transactional
|
@Override
|
public ResultVO<PreventDangerManage> updateDangerManage(Long userId, PreventDangerManageUpdateReqDTO manageUpdateReqDTO) {
|
ResultVO resultVO = new ResultVO<>();
|
resultVO.setCode("200");
|
resultVO.setMsg("修改成功");
|
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
|
if (rpcResult == null) {
|
throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
|
}
|
if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
|
throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
|
}
|
if (rpcResult.getData() == null) {
|
throw new BusinessException(ResultCodes.RPC_DATA_NULL);
|
}
|
if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
|
throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
|
}
|
UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();
|
|
if (ObjectUtils.isEmpty(userById)) {
|
throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
|
}
|
//校验参数
|
if (manageUpdateReqDTO.getId() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "传参非法");
|
}
|
if (manageUpdateReqDTO.getDangerLevel() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "隐患等级不能为空");
|
}
|
if (manageUpdateReqDTO.getDangerType() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "隐患类型不能为空");
|
}
|
if (manageUpdateReqDTO.getDangerSource() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "隐患来源不能为空");
|
}
|
if (manageUpdateReqDTO.getDepId() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "隐患所属部门不能为空");
|
}
|
// 图片
|
if (manageUpdateReqDTO.getReportImages() == null || manageUpdateReqDTO.getReportImages().size() < 1) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "图片上传不能为空");
|
}
|
for (String path : manageUpdateReqDTO.getReportImages()) {
|
if (StringUtils.isBlank(path)) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "图片上传不能为空路径");
|
}
|
}
|
// 图片
|
if (manageUpdateReqDTO.getReportImages().size() > 3) {
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "图片上传不能超过三张");
|
}
|
//校验部门是否存在
|
// ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(userId, manageUpdateReqDTO.getDepId());
|
DepartmentInfo departmentInfo = departmentService.getDepartmentInfoById(manageUpdateReqDTO.getDepId());
|
if(ObjectUtils.isEmpty(departmentInfo)){
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确责任部门");
|
}
|
if (manageUpdateReqDTO.getRiskUnitId() != null){
|
PreventRiskAnaUnit riskUnitById = preventRiskAnaUnitService.getRiskUnitById(manageUpdateReqDTO.getRiskUnitId());
|
if(ObjectUtils.isEmpty(riskUnitById)){
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确的风险分析单元");
|
}
|
}
|
if (manageUpdateReqDTO.getProduceDeviceId() != null){
|
PreventProduceDevice deviceById =
|
preventProduceDeviceService.getDeviceById(manageUpdateReqDTO.getProduceDeviceId());
|
if (ObjectUtils.isEmpty(deviceById)){
|
throw new BusinessException(E.DATA_PARAM_NULL, "请填写正确的生产装置");
|
}
|
PreventRiskAnaUnit riskUnitById = preventRiskAnaUnitService.getRiskUnitById(manageUpdateReqDTO.getRiskUnitId());
|
if (!riskUnitById.getProduceDeviceId().equals(manageUpdateReqDTO.getProduceDeviceId())){
|
throw new BusinessException(E.DATA_PARAM_NULL, "请填写生产装置对应的分析单元");
|
}
|
}
|
if (manageUpdateReqDTO.getRectifyType() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改类型不能为空");
|
}
|
if (manageUpdateReqDTO.getLiablePersonId() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改责任人不能为空");
|
}
|
if (manageUpdateReqDTO.getRectifyDepId() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改部门不能为空");
|
}
|
//责任人信息
|
ResultVO<UserRPCRespDTO> execUserResult = accountAuthService.getUserById(manageUpdateReqDTO.getLiablePersonId());
|
UserRPCRespDTO liableUser = (UserRPCRespDTO)execUserResult.getData();
|
|
Date date = new Date();
|
//读取上报主配置
|
PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
|
//封装隐患管理参数
|
PreventDangerRectify rectifyByManageId = preventDangerRectifyService.getRectifyByManageId(manageUpdateReqDTO.getId());
|
PreventDangerManageUpdateParams updateParams = BeanCopyUtils.copyBean(manageUpdateReqDTO, PreventDangerManageUpdateParams.class);
|
updateParams.setLastEditUserName(userById.getRealName());
|
updateParams.setGmtModitify(date);
|
//封装隐患整改参数
|
//PreventDangerRectifyUpdateParams rectifyUpdateParams = new PreventDangerRectifyUpdateParams();
|
PreventDangerRectifyUpdateParams rectifyUpdateParams = BeanCopyUtils.copyBean(manageUpdateReqDTO, PreventDangerRectifyUpdateParams.class);
|
rectifyUpdateParams.setLastEditUserName(userById.getRealName());
|
rectifyUpdateParams.setGmtModitify(date);
|
rectifyUpdateParams.setLiablePerson(liableUser.getRealName());
|
rectifyUpdateParams.setId(rectifyByManageId.getId());
|
|
//设置本条数据上报更新时间
|
rectifyUpdateParams.setUpdateReportDataTime(date);
|
updateParams.setUpdateReportDataTime(date);
|
//读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置
|
if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
|
&& reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
|
//设置上报状态为-等待上报
|
updateParams.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
rectifyUpdateParams.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
//设置本条数据上报开关为-开启
|
updateParams.setReportSwitch(SyncEnum.REPORT_ON.getCode());
|
//其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作
|
}else {
|
//设置上报状态为-不上报
|
updateParams.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
|
rectifyUpdateParams.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
|
//设置本条数据上报开关为-关闭
|
updateParams.setReportSwitch(SyncEnum.REPORT_OFF.getCode());
|
}
|
int rectifyResult = preventDangerRectifyService.updateDangerRectify(rectifyUpdateParams);
|
if (rectifyResult < 1){
|
throw new BusinessException(E.UPDATE_FAIL, "修改隐患整改信息失败");
|
}
|
preventDangerImageService.deleteImageByParentId(manageUpdateReqDTO.getId(), ImageTypeEnum.REPORT);
|
// 图片
|
SnowFlow snowFlow = new SnowFlow();
|
List<PreventDangerImage> images = new ArrayList<>();
|
PreventDangerImage image;
|
for (String path : manageUpdateReqDTO.getReportImages()) {
|
image = new PreventDangerImage();
|
image.setId(snowFlow.nextId());
|
image.setImagePath(path);
|
image.setParentId(manageUpdateReqDTO.getId());
|
image.setStatus(DataConvertEnum.DELETE_STATUS_USE.getCode());
|
image.setType(ImageTypeEnum.REPORT.getCode());
|
images.add(image);
|
}
|
preventDangerImageService.saveBatch(images);
|
|
|
int result = preventDangerManageService.updateDangerManage(updateParams);
|
if (rectifyResult < 1){
|
throw new BusinessException(E.UPDATE_FAIL, "修改管理整改信息失败");
|
}
|
resultVO.setCount(result);
|
return resultVO;
|
}
|
|
/**
|
* 隐患治理清单-删除
|
*/
|
@Override
|
public ResultVO<PreventDangerManage> deleteDangerManage(Long userId, PreventDangerManageDeleteReqDTO manageDeleteReqDTO) {
|
|
ResultVO resultVO = new ResultVO<>();
|
resultVO.setCode("200");
|
resultVO.setMsg("删除成功");
|
PreventDeleteParams deleteParams = new PreventDeleteParams();
|
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
|
if (rpcResult == null) {
|
throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
|
}
|
if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
|
throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
|
}
|
if (rpcResult.getData() == null) {
|
throw new BusinessException(ResultCodes.RPC_DATA_NULL);
|
}
|
if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
|
throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
|
}
|
UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();
|
|
if (ObjectUtils.isEmpty(userById)) {
|
throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
|
}
|
//校验参数
|
if (manageDeleteReqDTO.getId() == null ){
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "请选择正确的删除内容");
|
}
|
PreventDangerRectify rectifyByManageId = preventDangerRectifyService.getRectifyByManageId(manageDeleteReqDTO.getId());
|
if (ObjectUtils.isNotEmpty(rectifyByManageId)){
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "需要先删除对应的隐患整改");
|
}
|
//获取需要填充的信息
|
Date date = new Date();
|
//封装删除需要的参数
|
deleteParams.setId(manageDeleteReqDTO.getId());
|
deleteParams.setGmtModitify(date);
|
deleteParams.setLastEditUserName(userById.getRealName());
|
deleteParams.setUpdateReportDataTime(date);
|
|
int result = preventDangerManageService.deleteDangerManage(deleteParams);
|
|
resultVO.setCount(result);
|
|
return resultVO;
|
}
|
|
//隐患整改清单
|
/**
|
* 隐患整改清单-分页查询
|
*/
|
@Override
|
public ResultVO<PreventDangerRectify> getDangerRectifyPage(Long userId, PreventDangerRectifyQueryReqDTO rectifyQueryReqDTO) {
|
|
ResultVO resultVO = new ResultVO<>();
|
resultVO.setCode("200");
|
resultVO.setMsg("查询成功");
|
|
List<PreventDangerRectifyQueryRespDTO> list = new ArrayList<>();
|
Integer pageIndex = rectifyQueryReqDTO.getPageIndex();
|
Integer pageSize = rectifyQueryReqDTO.getPageSize();
|
|
//获取用户信息
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
|
if (rpcResult == null) {
|
throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
|
}
|
if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
|
throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
|
}
|
if (rpcResult.getData() == null) {
|
throw new BusinessException(ResultCodes.RPC_DATA_NULL);
|
}
|
if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
|
throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
|
}
|
UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();
|
|
if (ObjectUtils.isEmpty(userById)) {
|
throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
|
}
|
|
//读取上报主配置
|
PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_ANA_UNIT.getCode());
|
//获取到所有符合条件的隐患治理清单信息
|
Page pageInfo = new Page<>(pageIndex, pageSize);
|
pageInfo.setOptimizeCountSql(false);
|
IPage<PreventDangerRectify> page =
|
preventDangerRectifyService.getDangerRectifyPage(pageInfo, rectifyQueryReqDTO);
|
if (ObjectUtils.isEmpty(page)){
|
resultVO.setMsg("查询成功,无数据");
|
return resultVO;
|
}
|
// //遍历结果集，封装数据
|
// //List<PreventDangerRectifyQueryRespDTO> respDTO = BeanCopyUtils.copyBeanList(page.getRecords(), PreventDangerRectifyQueryRespDTO.class);
|
// for (PreventDangerRectify record : page.getRecords()) {
|
// PreventDangerRectifyQueryRespDTO respDTO = BeanCopyUtils.copyBean(record, PreventDangerRectifyQueryRespDTO.class);
|
// PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(record.getDangerManagerId());
|
// //添加部门名称
|
// DepartmentInfo departmentInfo = departmentService.selectSafety(respDTO.getRectifyDepId());
|
// respDTO.setRectifyDepName(departmentInfo.getDepartment());
|
// respDTO.setDangerStatus(dangerManageById.getDangerStatus());
|
// respDTO.setPageIndex((int) page.getCurrent());
|
// respDTO.setPageSize((int) page.getSize());
|
// respDTO.setDangerManagerId(dangerManageById.getId());
|
// respDTO.setReportState(reportConfigById.getReportState());
|
// respDTO.setReportType(reportConfigById.getReportType());
|
// list.add(respDTO);
|
// }
|
//遍历结果集，封装数据
|
for (PreventDangerRectify record : page.getRecords()) {
|
PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(record.getDangerManagerId());
|
|
List<PreventDangerImage> images = preventDangerImageService.listImagesByParentId(record.getDangerManagerId());
|
List<PreventDangerManageImageRespDTO> imageRespDTOs = new ArrayList<>(images.size());
|
PreventDangerManageImageRespDTO reportImage;
|
if (images.size() > 0) {
|
for (PreventDangerImage image : images) {
|
reportImage = new PreventDangerManageImageRespDTO();
|
reportImage.setId(image.getId());
|
reportImage.setImagePath(image.getImagePath());
|
reportImage.setParentId(image.getParentId());
|
reportImage.setType(image.getType());
|
imageRespDTOs.add(reportImage);
|
}
|
}
|
|
if (rectifyQueryReqDTO.getDangerStatus() != null){
|
if(dangerManageById.getDangerStatus().equals(rectifyQueryReqDTO.getDangerStatus())){
|
PreventDangerManageTimeout timeoutResult = preventDangerManageTimeoutService.getByRectifyId(record.getId());
|
PreventDangerRectifyQueryRespDTO respDTO = BeanCopyUtils.copyBean(record, PreventDangerRectifyQueryRespDTO.class);
|
//添加部门名称
|
DepartmentInfo departmentInfo = departmentService.getDepartmentInfoById(respDTO.getRectifyDepId());
|
respDTO.setRectifyDepName(departmentInfo.getDepartment());
|
if (ObjectUtils.isNotEmpty(timeoutResult)){
|
respDTO.setTimeoutStatus(timeoutResult.getTimeoutStatus());
|
}
|
respDTO.setSerialCode(dangerManageById.getSerialCode());
|
respDTO.setRectifyDepName(departmentInfo.getDepartment());
|
respDTO.setDangerStatus(dangerManageById.getDangerStatus());
|
respDTO.setDangerManagerId(dangerManageById.getId());
|
respDTO.setReportState(reportConfigById.getReportState());
|
respDTO.setReportType(reportConfigById.getReportType());
|
respDTO.setDangerCode(dangerManageById.getDangerCode());
|
|
List<String> reportList = imageRespDTOs.stream().filter(item -> item.getType().equals(ImageTypeEnum.REPORT.getCode())).map(PreventDangerManageImageRespDTO::getImagePath).collect(Collectors.toList());
|
List<String> rectifyList = imageRespDTOs.stream().filter(item -> item.getType().equals(ImageTypeEnum.RECTIFY.getCode())).map(PreventDangerManageImageRespDTO::getImagePath).collect(Collectors.toList());
|
List<String> acceptList = imageRespDTOs.stream().filter(item -> item.getType().equals(ImageTypeEnum.ACCEPT.getCode())).map(PreventDangerManageImageRespDTO::getImagePath).collect(Collectors.toList());
|
respDTO.setReportImages(reportList);
|
respDTO.setRectifyImages(rectifyList);
|
respDTO.setAcceptImages(acceptList);
|
|
list.add(respDTO);
|
respDTO.setPageIndex(list.indexOf(respDTO));
|
respDTO.setPageSize(pageSize);
|
}
|
}else {
|
PreventDangerManageTimeout timeoutResult = preventDangerManageTimeoutService.getByRectifyId(record.getId());
|
PreventDangerRectifyQueryRespDTO respDTO = BeanCopyUtils.copyBean(record, PreventDangerRectifyQueryRespDTO.class);
|
//添加部门名称
|
DepartmentInfo departmentInfo = departmentService.getDepartmentInfoById(respDTO.getRectifyDepId());
|
respDTO.setRectifyDepName(departmentInfo.getDepartment());
|
if (ObjectUtils.isNotEmpty(timeoutResult)){
|
respDTO.setTimeoutStatus(timeoutResult.getTimeoutStatus());
|
}
|
respDTO.setSerialCode(dangerManageById.getSerialCode());
|
if (departmentInfo != null) {
|
respDTO.setRectifyDepName(departmentInfo.getDepartment());
|
}
|
respDTO.setDangerStatus(dangerManageById.getDangerStatus());
|
respDTO.setPageIndex(pageSize);
|
respDTO.setPageSize((int) page.getCurrent());
|
respDTO.setDangerManagerId(dangerManageById.getId());
|
respDTO.setReportState(reportConfigById.getReportState());
|
respDTO.setReportType(reportConfigById.getReportType());
|
|
List<String> reportList = imageRespDTOs.stream().filter(item -> item.getType().equals(ImageTypeEnum.REPORT.getCode())).map(PreventDangerManageImageRespDTO::getImagePath).collect(Collectors.toList());
|
List<String> rectifyList = imageRespDTOs.stream().filter(item -> item.getType().equals(ImageTypeEnum.RECTIFY.getCode())).map(PreventDangerManageImageRespDTO::getImagePath).collect(Collectors.toList());
|
List<String> acceptList = imageRespDTOs.stream().filter(item -> item.getType().equals(ImageTypeEnum.ACCEPT.getCode())).map(PreventDangerManageImageRespDTO::getImagePath).collect(Collectors.toList());
|
respDTO.setReportImages(reportList);
|
respDTO.setRectifyImages(rectifyList);
|
respDTO.setAcceptImages(acceptList);
|
list.add(respDTO);
|
resultVO.setCount((int) page.getTotal());
|
}
|
}
|
|
resultVO.setData(list);
|
resultVO.setCount((int) page.getTotal());
|
|
return resultVO;
|
}
|
|
|
/**
|
* 隐患整改清单-查询:待验收与已验收
|
*/
|
@Override
|
public ResultVO<PreventDangerRectify> getRectifyOverPage(Long userId, PreventRectifyOverQueryReqDTO rectifyOverQueryReqDTO) {
|
|
ResultVO resultVO = new ResultVO<>();
|
resultVO.setCode("200");
|
resultVO.setMsg("查询成功");
|
|
List<PreventDangerRectifyQueryRespDTO> list = new ArrayList<>();
|
Integer pageIndex = rectifyOverQueryReqDTO.getPageIndex();
|
Integer pageSize = rectifyOverQueryReqDTO.getPageSize();
|
|
//获取用户信息
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
|
if (rpcResult == null) {
|
throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
|
}
|
if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
|
throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
|
}
|
if (rpcResult.getData() == null) {
|
throw new BusinessException(ResultCodes.RPC_DATA_NULL);
|
}
|
if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
|
throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
|
}
|
UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();
|
|
if (ObjectUtils.isEmpty(userById)) {
|
throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
|
}
|
if (ObjectUtils.isEmpty(rectifyOverQueryReqDTO.getDangerStatus())){
|
rectifyOverQueryReqDTO.setStatus(StatusEnum.DELETE_STATUS_USE.getCode());
|
}else {
|
rectifyOverQueryReqDTO.setStatus(null);
|
}
|
|
//TODO 后续改为连表查询，现为临时用
|
//读取上报主配置
|
PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_ANA_UNIT.getCode());
|
Page pageInfo = new Page<>(pageIndex, pageSize);
|
pageInfo.setOptimizeCountSql(false);
|
IPage<PreventDangerRectify> page =
|
preventDangerRectifyService.getDangerRectifyPageToOverRectify(pageInfo, rectifyOverQueryReqDTO);
|
for (PreventDangerRectify record : page.getRecords()) {
|
PreventDangerRectifyQueryRespDTO respDTO = BeanCopyUtils.copyBean(record, PreventDangerRectifyQueryRespDTO.class);
|
PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(record.getDangerManagerId());
|
PreventDangerManageTimeout timeoutResult = preventDangerManageTimeoutService.getByRectifyId(record.getId());
|
//添加部门名称
|
ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(userId, respDTO.getRectifyDepId());
|
if (ObjectUtils.isNotEmpty(timeoutResult)){
|
respDTO.setTimeoutStatus(timeoutResult.getTimeoutStatus());
|
}
|
//添加部门名称
|
DepartmentInfo departmentInfo = departmentService.getDepartmentInfoById(respDTO.getRectifyDepId());
|
DepInfoRPCRespDTO data = (DepInfoRPCRespDTO)depInfoByDepId.getData();
|
respDTO.setRectifyDepName(departmentInfo.getDepartment());
|
respDTO.setSerialCode(dangerManageById.getSerialCode());
|
respDTO.setDangerStatus(dangerManageById.getDangerStatus());
|
respDTO.setDangerManagerId(record.getDangerManagerId());
|
respDTO.setReportState(reportConfigById.getReportState());
|
respDTO.setReportType(reportConfigById.getReportType());
|
respDTO.setPageIndex((int) page.getCurrent());
|
respDTO.setPageSize((int) page.getSize());
|
|
List<PreventDangerImage> images = preventDangerImageService.listImagesByParentId(record.getDangerManagerId());
|
List<PreventDangerManageImageRespDTO> imageRespDTOs = new ArrayList<>(images.size());
|
PreventDangerManageImageRespDTO reportImage;
|
if (images.size() > 0) {
|
for (PreventDangerImage image : images) {
|
reportImage = new PreventDangerManageImageRespDTO();
|
reportImage.setId(image.getId());
|
reportImage.setImagePath(image.getImagePath());
|
reportImage.setParentId(image.getParentId());
|
reportImage.setType(image.getType());
|
imageRespDTOs.add(reportImage);
|
}
|
}
|
List<String> reportList = imageRespDTOs.stream().filter(item -> item.getType().equals(ImageTypeEnum.REPORT.getCode())).map(PreventDangerManageImageRespDTO::getImagePath).collect(Collectors.toList());
|
List<String> rectifyList = imageRespDTOs.stream().filter(item -> item.getType().equals(ImageTypeEnum.RECTIFY.getCode())).map(PreventDangerManageImageRespDTO::getImagePath).collect(Collectors.toList());
|
List<String> acceptList = imageRespDTOs.stream().filter(item -> item.getType().equals(ImageTypeEnum.ACCEPT.getCode())).map(PreventDangerManageImageRespDTO::getImagePath).collect(Collectors.toList());
|
respDTO.setReportImages(reportList);
|
respDTO.setRectifyImages(rectifyList);
|
respDTO.setAcceptImages(acceptList);
|
|
|
list.add(respDTO);
|
}
|
|
resultVO.setData(list);
|
resultVO.setCount(list.size());
|
|
return resultVO;
|
}
|
|
/**
|
* 隐患整改清单-新增 ---不要了--20220727
|
*/
|
@Override
|
public ResultVO<PreventDangerRectify> saveDangerRectify(Long userId, PreventDangerRectifySaveReqDTO rectifySaveReqDTO) {
|
|
ResultVO resultVO = new ResultVO<>();
|
resultVO.setCode("200");
|
resultVO.setMsg("新增成功");
|
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
|
if (rpcResult == null) {
|
throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
|
}
|
if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
|
throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
|
}
|
if (rpcResult.getData() == null) {
|
throw new BusinessException(ResultCodes.RPC_DATA_NULL);
|
}
|
if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
|
throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
|
}
|
UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();
|
|
if (ObjectUtils.isEmpty(userById)) {
|
throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
|
}
|
if (rectifySaveReqDTO.getDangerManagerId() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "隐患管理单不能为空");
|
}
|
PreventDangerManage dangerManageById =
|
preventDangerManageService.getDangerManageById(rectifySaveReqDTO.getDangerManagerId());
|
if (ObjectUtils.isEmpty(dangerManageById)){
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "请填写正确的隐患管理单");
|
}
|
//每个隐患管理单，只能有一个整改清单 TODO
|
PreventDangerRectify rectifyByCode =
|
preventDangerRectifyService.getRectifyByCode(dangerManageById.getDangerCode());
|
if (ObjectUtils.isNotEmpty(rectifyByCode)){
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "每个隐患管理单只能有一个整改任务单");
|
}
|
if (rectifySaveReqDTO.getRectifyTime() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改期限不能为空");
|
}
|
|
if (rectifySaveReqDTO.getLiablePersonId() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改责任人不能为空");
|
}
|
//获取责任人信息
|
ResultVO<UserRPCRespDTO> liablePersonResult = accountAuthService.getUserById(rectifySaveReqDTO.getLiablePersonId());
|
UserRPCRespDTO liablePerson = (UserRPCRespDTO)liablePersonResult.getData();
|
if (ObjectUtils.isEmpty(liablePerson)){
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "请正确填写整改责任人");
|
}
|
if (rectifySaveReqDTO.getRectifyDesc() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改内容说明");
|
}
|
if (rectifySaveReqDTO.getRectifyTime() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改类型不能为空");
|
}
|
|
//获取需要填充的信息
|
SnowFlow snowFlow = new SnowFlow();//雪花算法生成器
|
String uuid = UUID.randomUUID().toString();
|
Date date = new Date();
|
long rectifyId = snowFlow.nextId();
|
//读取上报主配置
|
PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
|
//封装参数
|
PreventDangerRectify dangerRectify = BeanCopyUtils.copyBean(rectifySaveReqDTO, PreventDangerRectify.class);
|
dangerRectify.setId(rectifyId);
|
dangerRectify.setUuid(uuid);
|
dangerRectify.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());
|
|
dangerRectify.setGmtCreate(date);
|
dangerRectify.setCreateByUserName(userById.getRealName());
|
dangerRectify.setGmtModitify(date);
|
dangerRectify.setLastEditUserName(userById.getRealName());
|
dangerRectify.setEnterpriseId((long) 1);
|
dangerRectify.setEnterpriseUuid("1564wq");
|
dangerRectify.setCheckAcceptPerson(userById.getRealName());
|
dangerRectify.setCheckAcceptPersonId(null);
|
dangerRectify.setRectifyDepId(null);
|
|
dangerRectify.setDangerManagerUuid(dangerManageById.getUuid());
|
dangerRectify.setDangerManagerId(rectifySaveReqDTO.getDangerManagerId());
|
dangerRectify.setDangerCode(dangerManageById.getDangerCode());
|
dangerRectify.setLiablePerson(liablePerson.getRealName());
|
|
//设置上报时间为空
|
dangerRectify.setReportTime(null);
|
//设置本条数据上报更新时间
|
dangerRectify.setUpdateReportDataTime(new Date());
|
//读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置
|
//本模块是否上报，通过DangerManager表的配置进行管理
|
if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
|
&& reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
|
//设置上报状态为-等待上报
|
dangerRectify.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
//其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作
|
}else {
|
//设置上报状态为-不上报
|
dangerRectify.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
|
}
|
//不确定是否需要的字段
|
dangerRectify.setCheckAcceptTime(null);
|
dangerRectify.setCheckAcceptDesc(null);
|
|
int result = preventDangerRectifyService.saveDangerRectify(dangerRectify);
|
|
resultVO.setCount(result);
|
return resultVO;
|
}
|
|
/**
|
* 隐患整改--延期
|
*/
|
@Override
|
public ResultVO<PreventDangerRectify> timeOutRectify(Long userId, PreventDangerRectifyUpdateReqDTO updateReqDTO) {
|
|
ResultVO resultVO = new ResultVO<>();
|
resultVO.setCode("200");
|
resultVO.setMsg("整改已延期");
|
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
|
if (rpcResult == null) {
|
throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
|
}
|
if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
|
throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
|
}
|
if (rpcResult.getData() == null) {
|
throw new BusinessException(ResultCodes.RPC_DATA_NULL);
|
}
|
if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
|
throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
|
}
|
UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();
|
|
if (ObjectUtils.isEmpty(userById)) {
|
throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
|
}
|
if (updateReqDTO.getId() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "传参非法");
|
}
|
if (updateReqDTO.getDangerManagerId() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "隐患管理单不能为空");
|
}
|
if (updateReqDTO.getRectifyTime() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "延期的时间不能为空");
|
}
|
if (updateReqDTO.getTimeOutDesc() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "延期说明不能为空");
|
}
|
PreventDangerRectify rectify = preventDangerRectifyService.getRectifyById(updateReqDTO.getId());
|
if (updateReqDTO.getRectifyTime().getTime() - rectify.getRectifyTime().getTime() <= 0){
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "延期时间必须大于整改期限");
|
}
|
PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(rectify.getDangerManagerId());
|
if (ObjectUtils.isEmpty(dangerManageById)){
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "传参错误");
|
}
|
if (dangerManageById.getDangerStatus() == StatusEnum.DANGER_MANAGER_NOT_ACCEPT.getCode()){
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "超期未整改任务无法延期");
|
}
|
|
//读取上报主配置
|
PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
|
//封装修改参数
|
PreventDangerRectifyUpdateParams updateParams = new PreventDangerRectifyUpdateParams();
|
updateParams.setId(updateReqDTO.getId());
|
updateParams.setRectifyTime(updateReqDTO.getRectifyTime());
|
updateParams.setLastEditUserName(userById.getRealName());
|
updateParams.setGmtModitify(new Date());
|
updateParams.setTimeOutDesc(updateReqDTO.getTimeOutDesc());
|
|
//设置本条数据上报更新时间 ,上报开关依赖于dangerManager
|
updateParams.setUpdateReportDataTime(new Date());
|
//读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置
|
if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
|
&& reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
|
//设置上报状态为-等待上报
|
updateParams.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
//其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作
|
}else {
|
//设置上报状态为-不上报
|
updateParams.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
|
}
|
//整改单延期成功
|
int resultRectify = preventDangerRectifyService.updateRectifyTime(updateParams);
|
if (resultRectify < 1){
|
throw new BusinessException(E.UPDATE_FAIL, "延期操作失败");
|
}
|
//管理单变更状态成功
|
//封装修改参数
|
UpdateRectifyResultParams updateRectifyParams = new UpdateRectifyResultParams();
|
updateRectifyParams.setDangerStatus(StatusEnum.DANGER_MANAGER_TIMEOUT_RECTIFY.getCode());
|
updateRectifyParams.setDangerManagerId(updateReqDTO.getDangerManagerId());
|
updateRectifyParams.setUpdateReportDataTime(new Date());
|
|
int resultManager = preventDangerManageService.updateRectifyResult(updateRectifyParams);
|
if (resultManager < 1){
|
throw new BusinessException(E.UPDATE_FAIL, "隐患管理状态变更失败");
|
}
|
|
return resultVO;
|
}
|
|
/**
|
* 隐患整改清单-修改
|
*/
|
@Override
|
public ResultVO<PreventDangerRectify> updateDangerRectify(Long userId, PreventDangerRectifyUpdateReqDTO rectifyUpdateReqDTO) {
|
|
ResultVO resultVO = new ResultVO<>();
|
resultVO.setCode("200");
|
resultVO.setMsg("修改成功");
|
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
|
if (rpcResult == null) {
|
throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
|
}
|
if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
|
throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
|
}
|
if (rpcResult.getData() == null) {
|
throw new BusinessException(ResultCodes.RPC_DATA_NULL);
|
}
|
if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
|
throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
|
}
|
UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();
|
|
if (ObjectUtils.isEmpty(userById)) {
|
throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
|
}
|
|
if (rectifyUpdateReqDTO.getDangerManagerId() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "参数非法");
|
}
|
PreventDangerManage dangerManageById =
|
preventDangerManageService.getDangerManageById(rectifyUpdateReqDTO.getDangerManagerId());
|
if (ObjectUtils.isEmpty(dangerManageById)){
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "请填写正确的隐患管理单");
|
}
|
if (rectifyUpdateReqDTO.getRectifyTime() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改期限不能为空");
|
}
|
if (rectifyUpdateReqDTO.getLiablePersonId() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改责任人不能为空");
|
}
|
//获取责任人信息
|
ResultVO<UserRPCRespDTO> liablePersonResult = accountAuthService.getUserById(rectifyUpdateReqDTO.getLiablePersonId());
|
UserRPCRespDTO liablePerson = (UserRPCRespDTO)liablePersonResult.getData();
|
if (ObjectUtils.isEmpty(liablePerson)){
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "请正确填写整改责任人");
|
}
|
if (rectifyUpdateReqDTO.getRectifyDesc() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改内容说明不能为空");
|
}
|
if (rectifyUpdateReqDTO.getRectifyType() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改类型不能为空");
|
}
|
if (rectifyUpdateReqDTO.getCost() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改资金不能为空");
|
}
|
|
//获取需要填充的信息
|
Date date = new Date();
|
//读取上报主配置
|
PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
|
//封装参数
|
PreventDangerRectifyUpdateParams updateParams
|
= BeanCopyUtils.copyBean(rectifyUpdateReqDTO, PreventDangerRectifyUpdateParams.class);
|
|
updateParams.setGmtModitify(date);
|
updateParams.setLastEditUserName(userById.getRealName());
|
updateParams.setDangerManagerUuid(dangerManageById.getUuid());
|
updateParams.setLiablePerson(liablePerson.getRealName());
|
|
//设置本条数据上报更新时间 ,上报开关依赖于dangerManager
|
updateParams.setUpdateReportDataTime(date);
|
//读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置
|
if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
|
&& reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
|
//设置上报状态为-等待上报
|
updateParams.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
//其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作
|
}else {
|
//设置上报状态为-不上报
|
updateParams.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
|
}
|
|
int result = preventDangerRectifyService.updateDangerRectify(updateParams);
|
|
resultVO.setCount(result);
|
return resultVO;
|
}
|
|
/**
|
* 隐患整改清单-验收情况填报-整改
|
*/
|
@Override
|
public ResultVO<PreventDangerRectify> applyReport(Long userId, PreventDangerReportRectifyReqDTO reportRectify) {
|
|
ResultVO resultVO = new ResultVO<>();
|
resultVO.setCode("200");
|
resultVO.setMsg("填报成功");
|
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
|
if (rpcResult == null) {
|
throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
|
}
|
if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
|
throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
|
}
|
if (rpcResult.getData() == null) {
|
throw new BusinessException(ResultCodes.RPC_DATA_NULL);
|
}
|
if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
|
throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
|
}
|
UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();
|
|
if (ObjectUtils.isEmpty(userById)) {
|
throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
|
}
|
if (reportRectify.getId() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "参数为空");
|
}
|
if (reportRectify.getRectifyImages() == null || reportRectify.getRectifyImages().size() < 1){
|
throw new BusinessException(E.DATA_PARAM_NULL, "上传图片为空");
|
}
|
// 图片
|
if (reportRectify.getRectifyImages().size() > 3) {
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "图片上传不能超过三张");
|
}
|
for (String path : reportRectify.getRectifyImages()) {
|
if (StringUtils.isBlank(path)) {
|
throw new BusinessException(E.DATA_PARAM_NULL, "图片上传不能为空路径");
|
}
|
}
|
//获取验收责任人信息
|
// ResultVO<UserRPCRespDTO> checkAcceptPersonResult = accountAuthService.getUserById(reportRectify.getCheckAcceptPersonId());
|
// UserRPCRespDTO checkAcceptPerson = (UserRPCRespDTO)checkAcceptPersonResult.getData();
|
|
PreventDangerRectify rectifyById = preventDangerRectifyService.getRectifyById(reportRectify.getId());
|
|
if (!userId.equals(rectifyById.getLiablePersonId())){
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "非整改责任人，无法操作");
|
}
|
|
PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(reportRectify.getDangerManagerId());
|
|
if (dangerManageById.getDangerStatus().equals(StatusEnum.DANGER_MANAGER_NOT_ACCEPT.getCode())
|
|| dangerManageById.getDangerStatus().equals(StatusEnum.DANGER_MANAGER_WAIT_ACCEPT.getCode())
|
|| dangerManageById.getDangerStatus().equals(StatusEnum.DANGER_MANAGER_ACCEPT.getCode())){
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "该整改单不是整改中状态，只有在整改的单据才可以申请验收");
|
}
|
if (reportRectify.getRectifyInfo() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "整改说明不能为空");
|
}
|
|
if (dangerManageById.getDangerReview() == StatusEnum.DANGER_RECTIFY_REVIEW.getCode()){
|
throw new BusinessException(E.DATA_PARAM_NULL, "隐患已关闭，无法处理");
|
}
|
|
|
|
//获取需要填充的信息
|
Date date = new Date();
|
//读取上报主配置
|
PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
|
//封装参数
|
PreventDangerReportRectifyUpdayeParams reportParams
|
= BeanCopyUtils.copyBean(reportRectify, PreventDangerReportRectifyUpdayeParams.class);
|
|
reportParams.setGmtModitify(date);
|
reportParams.setLastEditUserName(userById.getRealName());
|
reportParams.setApplyTime(reportRectify.getApplyTime());
|
reportParams.setRectifyInfo(reportRectify.getRectifyInfo());
|
|
//设置本条数据上报更新时间 ,上报开关依赖于dangerManager
|
reportParams.setUpdateReportDataTime(date);
|
//读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置
|
if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
|
&& reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
|
//设置上报状态为-等待上报
|
reportParams.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
//其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作
|
}else {
|
//设置上报状态为-不上报
|
reportParams.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
|
}
|
//提交数据
|
int result = preventDangerRectifyService.applyReport(reportParams);
|
|
if (result < 1) {
|
throw new BusinessException(E.UPDATE_FAIL, "提交验收失败");
|
}
|
//封装修改参数
|
UpdateRectifyResultParams updateParams = new UpdateRectifyResultParams();
|
updateParams.setDangerStatus(StatusEnum.DANGER_MANAGER_WAIT_ACCEPT.getCode());
|
updateParams.setDangerManagerId(reportRectify.getDangerManagerId());
|
updateParams.setUpdateReportDataTime(date);
|
//设置为待验收
|
int manageResult = preventDangerManageService.updateRectifyResult(updateParams);
|
if (manageResult < 1) {
|
throw new BusinessException(E.UPDATE_FAIL, "状态变更失败");
|
}
|
// 图片
|
List<PreventDangerImage> images = new ArrayList<>();
|
PreventDangerImage image;
|
SnowFlow snowFlow = new SnowFlow();
|
for (String path : reportRectify.getRectifyImages()) {
|
image = new PreventDangerImage();
|
image.setId(snowFlow.nextId());
|
image.setImagePath(path);
|
image.setParentId(reportRectify.getDangerManagerId());
|
image.setStatus(DataConvertEnum.DELETE_STATUS_USE.getCode());
|
image.setType(ImageTypeEnum.RECTIFY.getCode());
|
images.add(image);
|
}
|
preventDangerImageService.saveBatch(images);
|
|
|
resultVO.setCount(result);
|
return resultVO;
|
}
|
/**
|
* 隐患管理-关闭隐患单
|
*/
|
@Transactional
|
@Override
|
public ResultVO<PreventRiskAnaUnit> closeDanger(Long userId, PreventCloseDangerReqDTO closeDangerReqDTO) {
|
|
ResultVO resultVO = new ResultVO<>();
|
resultVO.setCode("200");
|
resultVO.setMsg("关闭成功");
|
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
|
if (rpcResult == null) {
|
throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
|
}
|
if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
|
throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
|
}
|
if (rpcResult.getData() == null) {
|
throw new BusinessException(ResultCodes.RPC_DATA_NULL);
|
}
|
if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
|
throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
|
}
|
UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();
|
|
if (ObjectUtils.isEmpty(userById)) {
|
throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
|
}
|
//TODO 只有没有处理过的隐患，才能关闭
|
//封装参数
|
CloseDangerParams closeDangerParams = BeanCopyUtils.copyBean(closeDangerReqDTO, CloseDangerParams.class);
|
|
closeDangerParams.setDangerReview(StatusEnum.DANGER_RECTIFY_REVIEW.getCode());
|
closeDangerParams.setGmtModitify(new Date());
|
closeDangerParams.setLastEditUserName(userById.getRealName());
|
closeDangerParams.setUpdateReportDataTime(new Date());
|
|
int resultManage = preventDangerManageService.closeDanger(closeDangerParams);
|
if (resultManage < 1){
|
throw new BusinessException(E.UPDATE_FAIL, "关闭隐患管理信息失败");
|
}
|
//当做删除-进行同步
|
int resultRectify = preventDangerRectifyService.closeDanger(closeDangerParams);
|
if (resultRectify < 1){
|
throw new BusinessException(E.UPDATE_FAIL, "关闭隐患整改信息失败");
|
}
|
|
resultVO.setCount(resultManage);
|
|
return resultVO;
|
}
|
|
/**
|
* 隐患整改清单--验收
|
*/
|
@Override
|
public ResultVO<PreventDangerRectify> reportRectify(Long userId, PreventDangerReportRectifyReqDTO reportRectify) {
|
|
ResultVO resultVO = new ResultVO<>();
|
resultVO.setCode("200");
|
resultVO.setMsg("验收成功");
|
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
|
if (rpcResult == null) {
|
throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
|
}
|
if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
|
throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
|
}
|
if (rpcResult.getData() == null) {
|
throw new BusinessException(ResultCodes.RPC_DATA_NULL);
|
}
|
if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
|
throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
|
}
|
UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();
|
|
if (ObjectUtils.isEmpty(userById)) {
|
throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
|
}
|
if (reportRectify.getId() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "参数为空");
|
}
|
if (reportRectify.getDangerManagerId() == null ){
|
throw new BusinessException(E.DATA_PARAM_NULL, "参数为空");
|
}
|
if (reportRectify.getCheckAcceptDesc() == null){
|
throw new BusinessException(E.DATA_PARAM_NULL, "验收意见不能为空");
|
}
|
PreventDangerRectify rectifyById = preventDangerRectifyService.getRectifyById(reportRectify.getId());
|
if(!rectifyById.getCheckAcceptPersonId().equals(userId)){
|
throw new BusinessException(E.DATA_PARAM_NULL, "非验收人，无权操作");
|
}
|
// if (reportRectify.getAcceptImages() == null || reportRectify.getAcceptImages().size() < 1) {
|
// throw new BusinessException(E.DATA_PARAM_NULL, "上传图片为空");
|
// }
|
// 图片
|
// if (reportRectify.getAcceptImages().size() > 3) {
|
// throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "图片上传不能超过三张");
|
// }
|
// for (String path : reportRectify.getAcceptImages()) {
|
// if (StringUtils.isBlank(path)) {
|
// throw new BusinessException(E.DATA_PARAM_NULL, "图片上传不能为空路径");
|
// }
|
// }
|
PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(reportRectify.getDangerManagerId());
|
if (dangerManageById.getDangerStatus() != StatusEnum.DANGER_MANAGER_WAIT_ACCEPT.getCode()){
|
throw new BusinessException(E.DATA_PARAM_CHECK_INVALID, "该整改单不是待验收状态，只有待验收的单据才可以同意验收");
|
}
|
|
//获取需要填充的信息
|
Date date = new Date();
|
//读取上报主配置
|
PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
|
//封装参数
|
PreventDangerReportRectifyUpdayeParams reportParams = new PreventDangerReportRectifyUpdayeParams();
|
|
reportParams.setId(reportRectify.getId());
|
reportParams.setGmtModitify(date);
|
reportParams.setLastEditUserName(userById.getRealName());
|
reportParams.setCheckAcceptTime(date);
|
reportParams.setCheckAcceptDesc(reportRectify.getCheckAcceptDesc());
|
reportParams.setUpdateReportDataTime(date);
|
|
//设置本条数据上报更新时间 ,上报开关依赖于dangerManager
|
reportParams.setUpdateReportDataTime(date);
|
//读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置
|
if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
|
&& reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
|
//设置上报状态为-等待上报
|
reportParams.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
//其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作
|
}else {
|
//设置上报状态为-不上报
|
reportParams.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
|
}
|
|
int result = preventDangerRectifyService.reportRectify(reportParams);
|
if (result < 1) {
|
throw new BusinessException(E.UPDATE_FAIL, "验收信息提交失败");
|
}
|
//封装修改参数
|
UpdateRectifyResultParams updateParams = new UpdateRectifyResultParams();
|
updateParams.setDangerStatus(StatusEnum.DANGER_MANAGER_ACCEPT.getCode());
|
updateParams.setDangerManagerId(reportRectify.getDangerManagerId());
|
updateParams.setUpdateReportDataTime(date);
|
//设置为待验收
|
int RectifyResult= preventDangerManageService.updateRectifyResult(updateParams);
|
if (result < 1) {
|
throw new BusinessException(E.UPDATE_FAIL, "验收状态变更失败");
|
}
|
// 图片
|
// List<PreventDangerImage> images = new ArrayList<>();
|
// PreventDangerImage image;
|
// SnowFlow snowFlow = new SnowFlow();
|
// for (String path : reportRectify.getAcceptImages()) {
|
// image = new PreventDangerImage();
|
// image.setId(snowFlow.nextId());
|
// image.setImagePath(path);
|
// image.setParentId(reportRectify.getDangerManagerId());
|
// image.setStatus(DataConvertEnum.DELETE_STATUS_USE.getCode());
|
// image.setType(ImageTypeEnum.ACCEPT.getCode());
|
// images.add(image);
|
// }
|
// preventDangerImageService.saveBatch(images);
|
resultVO.setCount(result);
|
return resultVO;
|
}
|
|
/**
|
* 隐患整改清单-删除
|
*/
|
@Override
|
public ResultVO<PreventDangerRectify> deleteDangerRectify(Long userId, PreventDangerRectifyDeleteReqDTO rectifyDeleteReqDTO) {
|
|
ResultVO resultVO = new ResultVO<>();
|
resultVO.setCode("200");
|
resultVO.setMsg("删除成功");
|
PreventDeleteParams deleteParams = new PreventDeleteParams();
|
|
ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
|
if (rpcResult == null) {
|
throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
|
}
|
if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
|
throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
|
}
|
if (rpcResult.getData() == null) {
|
throw new BusinessException(ResultCodes.RPC_DATA_NULL);
|
}
|
if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
|
throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
|
}
|
UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();
|
|
if (ObjectUtils.isEmpty(userById)) {
|
throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
|
}
|
//校验参数
|
if (rectifyDeleteReqDTO.getId() == null ){
|
throw new BusinessException(E.DATA_DATABASE_NO_EXISTENT, "请选择正确的删除内容");
|
}
|
//获取需要填充的信息
|
Date date = new Date();
|
//封装删除需要的参数
|
deleteParams.setId(rectifyDeleteReqDTO.getId());
|
deleteParams.setGmtModitify(date);
|
deleteParams.setLastEditUserName(userById.getRealName());
|
deleteParams.setUpdateReportDataTime(date);
|
|
int result = preventDangerRectifyService.deleteDangerRectify(deleteParams);
|
|
resultVO.setCount(result);
|
return resultVO;
|
}
|
|
|
@Override
|
public ResultVO countDangerByDate(LocalDate date) {
|
ResultVO resultVO = new ResultVO<>();
|
resultVO.setCode(ResultCodes.OK.getCode());
|
LocalDateTime startTime = LocalDateTime.of(date, LocalTime.of(0,0,0));
|
LocalDateTime endTime = LocalDateTime.of(date, LocalTime.of(23,59,59));
|
Date start = Date.from(startTime.atZone(ZoneId.systemDefault()).toInstant());
|
Date end = Date.from(endTime.atZone(ZoneId.systemDefault()).toInstant());
|
resultVO.setData(preventDangerManageService.countByCreateTime(start,end));
|
return resultVO;
|
}
|
|
@Override
|
public ResultVO<PreventDangerManageQueryRespDTO> findByDangerSerialCode(String serialCode) {
|
ResultVO<PreventDangerManageQueryRespDTO> resultVO = new ResultVO<>();
|
resultVO.setCode(ResultCodes.OK.getCode());
|
PreventDangerManage dangerManage = preventDangerManageService.findByDangerSerialCode(serialCode);
|
if(dangerManage != null){
|
PreventDangerManageQueryRespDTO respDTO = new PreventDangerManageQueryRespDTO();
|
BeanUtils.copyProperties(dangerManage,respDTO);
|
resultVO.setData(respDTO);
|
}
|
return resultVO;
|
}
|
|
@Override
|
public SearchResultVO<List<PreventDangerCheckTaskRectifyRespDTO>> listOwnRectifyPage(ContextCacheUser currentUser, PageQuery<OwnRectifyPageQuery> pageQuery) {
|
|
OwnRectifyPageDBQuery dbQuery = new OwnRectifyPageDBQuery();
|
dbQuery.setCurrentUid(currentUser.getUid());
|
Page<PreventDangerCheckTaskRectifyDO> page = new Page<>(pageQuery.getPageIndex(), pageQuery.getPageSize());
|
List<PreventDangerCheckTaskRectifyDO> dbData = preventDangerManageService.listOwnRectifyPage(page, dbQuery);
|
List<PreventDangerCheckTaskRectifyRespDTO> result = new ArrayList<>(dbData.size());
|
if (dbData.size() > 0) {
|
for (PreventDangerCheckTaskRectifyDO rectifyDO : dbData) {
|
PreventDangerCheckTaskRectifyRespDTO respDTO = new PreventDangerCheckTaskRectifyRespDTO();
|
|
respDTO.setManageId(rectifyDO.getManageId());
|
respDTO.setManageUuid(rectifyDO.getManageUuid());
|
respDTO.setRegisterTime(rectifyDO.getRegisterTime());
|
respDTO.setDangerLevel(rectifyDO.getDangerLevel());
|
respDTO.setDangerType(rectifyDO.getDangerType());
|
respDTO.setDangerSource(rectifyDO.getDangerSource());
|
respDTO.setDangerStatus(rectifyDO.getDangerStatus());
|
respDTO.setRegistantId(rectifyDO.getRegistantId());
|
respDTO.setProduceDeviceId(rectifyDO.getProduceDeviceId());
|
respDTO.setDangerCode(rectifyDO.getDangerCode());
|
respDTO.setRegistantName(rectifyDO.getRegistantName());
|
respDTO.setDangerDesc(rectifyDO.getDangerDesc());
|
respDTO.setDangerReason(rectifyDO.getDangerReason());
|
respDTO.setDangerResult(rectifyDO.getDangerResult());
|
respDTO.setDepId(rectifyDO.getDepId());
|
respDTO.setRiskUnitId(rectifyDO.getRiskUnitId());
|
respDTO.setDangerReview(rectifyDO.getDangerReview());
|
respDTO.setDangerCloseReason(rectifyDO.getDangerCloseReason());
|
respDTO.setRectifyId(rectifyDO.getRectifyId());
|
respDTO.setRectifyType(rectifyDO.getRectifyType());
|
respDTO.setRectifyTime(rectifyDO.getRectifyTime());
|
respDTO.setLiablePersonId(rectifyDO.getLiablePersonId());
|
respDTO.setCheckAcceptTime(rectifyDO.getCheckAcceptTime());
|
respDTO.setCheckAcceptPersonId(rectifyDO.getCheckAcceptPersonId());
|
respDTO.setLiablePerson(rectifyDO.getLiablePerson());
|
respDTO.setCheckAcceptPerson(rectifyDO.getCheckAcceptPerson());
|
respDTO.setRectifyDepId(rectifyDO.getRectifyDepId());
|
respDTO.setRectifyDesc(rectifyDO.getRectifyDesc());
|
respDTO.setCost(rectifyDO.getCost());
|
respDTO.setRectifyApplyTime(rectifyDO.getRectifyApplyTime());
|
respDTO.setTimeOutDesc(rectifyDO.getTimeOutDesc());
|
respDTO.setRectifyInfo(rectifyDO.getRectifyInfo());
|
result.add(respDTO);
|
}
|
}
|
|
return new SearchResultVO<>(
|
true,
|
page.getCurrent(),
|
page.getSize(),
|
page.getPages(),
|
page.getTotal(),
|
result, ResultCodes.OK);
|
}
|
|
/**
|
* 生成隐患编码
|
* @param time
|
* @param existCount
|
* @return
|
*/
|
private String generateDangerSerialCode(Date time,int existCount){
|
LocalDateTime t = time.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
|
LocalDate d = t.toLocalDate();
|
StringBuilder stringBuilder = new StringBuilder("");
|
stringBuilder.append(d.getYear());
|
int mon = d.getMonthValue();
|
if(mon < 10){
|
stringBuilder.append("0");
|
stringBuilder.append(mon);
|
}else {
|
stringBuilder.append(mon);
|
}
|
stringBuilder.append(d.getDayOfMonth());
|
stringBuilder.append('-');
|
int nowSerial = 0;
|
if(existCount > 0)
|
nowSerial = existCount + 1;
|
else
|
nowSerial = 1;
|
if(nowSerial < 10000){
|
if(nowSerial<10){
|
stringBuilder.append("000");
|
}else if(nowSerial>=10 && nowSerial<100){
|
stringBuilder.append("00");
|
}else if(nowSerial>=100 && nowSerial<1000){
|
stringBuilder.append("0");
|
}
|
stringBuilder.append(nowSerial);
|
}else {
|
stringBuilder.append(nowSerial);
|
}
|
return stringBuilder.toString();
|
}
|
}
|
