package com.gkhy.safePlatform.doublePrevention.service.impl;
|
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.gkhy.safePlatform.account.rpc.apimodel.AccountAuthService;
|
import com.gkhy.safePlatform.account.rpc.apimodel.AccountDepartmentService;
|
import com.gkhy.safePlatform.account.rpc.apimodel.model.resp.DepInfoRPCRespDTO;
|
import com.gkhy.safePlatform.account.rpc.apimodel.model.resp.UserRPCRespDTO;
|
import com.gkhy.safePlatform.commons.enums.E;
|
import com.gkhy.safePlatform.commons.enums.ResultCodes;
|
import com.gkhy.safePlatform.commons.exception.AusinessException;
|
import com.gkhy.safePlatform.commons.exception.BusinessException;
|
import com.gkhy.safePlatform.commons.utils.BeanCopyUtils;
|
import com.gkhy.safePlatform.commons.utils.idService.SnowFlow;
|
import com.gkhy.safePlatform.commons.vo.ResultVO;
|
import com.gkhy.safePlatform.doublePrevention.entity.*;
|
import com.gkhy.safePlatform.doublePrevention.entity.dto.req.*;
|
import com.gkhy.safePlatform.doublePrevention.entity.dto.resp.PreventDangerManageListQueryRespDTO;
|
import com.gkhy.safePlatform.doublePrevention.entity.dto.resp.PreventDangerManageQueryRespDTO;
|
import com.gkhy.safePlatform.doublePrevention.entity.dto.resp.PreventDangerRectifyQueryRespDTO;
|
import com.gkhy.safePlatform.doublePrevention.enums.StatusEnum;
|
import com.gkhy.safePlatform.doublePrevention.enums.SyncEnum;
|
import com.gkhy.safePlatform.doublePrevention.enums.WorkStatusEnum;
|
import com.gkhy.safePlatform.doublePrevention.repository.param.*;
|
import com.gkhy.safePlatform.doublePrevention.service.RectifyService;
|
import com.gkhy.safePlatform.doublePrevention.service.baseService.*;
|
import org.apache.commons.lang3.ObjectUtils;
|
import org.apache.dubbo.config.annotation.DubboReference;
|
import org.redisson.api.RLock;
|
import org.redisson.api.RedissonClient;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.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;
|
|
@Service
|
public class RectifyServiceImpl implements RectifyService {
|
|
@DubboReference(check = false)
|
private AccountAuthService accountAuthService;
|
@DubboReference(check = false)
|
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 PreventDangerManageTimeoutService preventDangerManageTimeoutService;
|
|
//隐患治理清单
|
/**
|
* 隐患治理清单-分页查询
|
*/
|
@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.getRecords())){
|
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());
|
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.setCheckAcceptPersonId(rectifyByManageId.getCheckAcceptPersonId());
|
respDTO.setCheckAcceptTime(rectifyByManageId.getCheckAcceptTime());
|
respDTO.setCheckAcceptPerson(rectifyByManageId.getCheckAcceptPerson());
|
respDTO.setCheckAcceptDesc(rectifyByManageId.getCheckAcceptDesc());
|
respDTO.setLiablePersonId(rectifyByManageId.getLiablePersonId());
|
}
|
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.setRectifyDepName(liablePerson.getDepartment().getDepName());
|
respDTO.setRectifyId(rectifyByManageId.getId());
|
}
|
PreventDangerManageTimeout timeoutResult = preventDangerManageTimeoutService.getByManageId(record.getId());
|
if (ObjectUtils.isNotEmpty(timeoutResult)){
|
respDTO.setTimeoutStatus(timeoutResult.getTimeoutStatus());
|
}
|
respDTO.setReportState(reportConfigById.getReportState());
|
respDTO.setReportType(reportConfigById.getReportType());
|
respDTO.setDepName(userById.getDepartment().getDepName());
|
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 AusinessException(E.DATA_PARAM_CHECK_INVALID, "传参非法");
|
}
|
if (preventHandReportConfigReqDTO.getReportSwitch() == null){
|
throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "传参非法");
|
}
|
//查询当前隐患的配置
|
PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(preventHandReportConfigReqDTO.getId());
|
//配置相同，做处理
|
if (dangerManageById.getReportSwitch() == preventHandReportConfigReqDTO.getReportSwitch()){
|
throw new AusinessException(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 AusinessException(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 AusinessException(E.DATA_PARAM_NULL, "隐患等级不能为空");
|
}
|
if (manageSaveReqDTO.getDangerType() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "隐患类型不能为空");
|
}
|
if (manageSaveReqDTO.getDepId() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "隐患所属部门不能为空");
|
}
|
if (manageSaveReqDTO.getDangerCode() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "隐患名称不能为空");
|
}
|
//校验部门是否存在
|
ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(userId, manageSaveReqDTO.getDepId());
|
if(ObjectUtils.isEmpty(depInfoByDepId)){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确责任部门");
|
}
|
if (manageSaveReqDTO.getRiskUnitId() != null){
|
PreventRiskAnaUnit riskUnitById = preventRiskAnaUnitService.getRiskUnitById(manageSaveReqDTO.getRiskUnitId());
|
if(ObjectUtils.isEmpty(riskUnitById)){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确的风险分析单元");
|
}
|
}
|
|
if (manageSaveReqDTO.getProduceDeviceId() != null){
|
PreventProduceDevice deviceById =
|
preventProduceDeviceService.getDeviceById(manageSaveReqDTO.getProduceDeviceId());
|
if (ObjectUtils.isEmpty(deviceById)){
|
throw new AusinessException(E.DATA_PARAM_NULL, "请填写正确的生产装置");
|
}
|
PreventRiskAnaUnit riskUnitById = preventRiskAnaUnitService.getRiskUnitById(manageSaveReqDTO.getRiskUnitId());
|
if (ObjectUtils.isNotEmpty(riskUnitById)){
|
if (!riskUnitById.getProduceDeviceId().equals(manageSaveReqDTO.getProduceDeviceId())){
|
throw new AusinessException(E.DATA_PARAM_NULL, "请填写生产装置对应的分析单元");
|
}
|
}else if (ObjectUtils.isEmpty(riskUnitById)){
|
throw new AusinessException(E.DATA_PARAM_NULL, "请填写生产装置对应的分析单元");
|
}
|
}
|
if (manageSaveReqDTO.getRectifyType() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "整改类型不能为空");
|
}
|
if (manageSaveReqDTO.getDangerResult() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "隐患可能造成的后果不能为空");
|
}
|
if (manageSaveReqDTO.getLiablePersonId() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "整改责任人不能为空");
|
}
|
//责任人信息
|
ResultVO<UserRPCRespDTO> execUserResult = accountAuthService.getUserById(manageSaveReqDTO.getLiablePersonId());
|
UserRPCRespDTO liableUser = (UserRPCRespDTO)execUserResult.getData();
|
if (ObjectUtils.isEmpty(liableUser)){
|
throw new AusinessException(E.DATA_PARAM_NULL, "该责任人不存在或已被删除，请选择正确的责任人");
|
}
|
if (manageSaveReqDTO.getRectifyTime() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "整改期限不能为空");
|
}
|
if (manageSaveReqDTO.getRectifyDepId() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "整改部门不能为空");
|
}
|
if (!manageSaveReqDTO.getRectifyDepId().equals(liableUser.getDepartment().getDepId())){
|
throw new AusinessException(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);
|
//设置上报时间为空，以隐患管理表为主，同时设置上报
|
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());
|
}
|
|
/**设置是否延期状态参数*/
|
PreventDangerManageTimeout manageTimeout = new PreventDangerManageTimeout();
|
manageTimeout.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());
|
manageTimeout.setTimeoutStatus(StatusEnum.DANGER_ON_TIME_RECTIFY.getCode());
|
manageTimeout.setDangerRectifyId(rectifyId);
|
manageTimeout.setDangerManagerId(dangerManagerId);
|
|
//生成隐患编码
|
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 AusinessException(E.ADD_FAIL, "保存隐患整改信息失败");
|
}
|
//2、生成编码
|
String serialCode = generateDangerSerialCode(dangerManage.getGmtCreate(),count);
|
if(serialCode == null || serialCode.isEmpty()){
|
throw new AusinessException(E.ADD_FAIL, "保存隐患整改信息失败");
|
}
|
dangerManage.setSerialCode(serialCode);
|
|
int step = 1;
|
//保存隐患管理信息
|
if (step == 1){
|
int resultManage = preventDangerManageService.saveDangerManage(dangerManage);
|
if (resultManage < 1){
|
throw new AusinessException(E.ADD_FAIL, "保存隐患管理信息失败");
|
}else {
|
step = 2;
|
}
|
}
|
//保存隐患整改信息
|
if (step == 2){
|
int resultRectify = preventDangerRectifyService.saveDangerRectify(dangerRectify);
|
if (resultRectify < 1){
|
throw new AusinessException(E.ADD_FAIL, "保存隐患整改信息失败");
|
}else {
|
step = 3;
|
}
|
}
|
//保存延期状态
|
if (step == 3){
|
int resultTimeout = preventDangerManageTimeoutService.insert(manageTimeout);
|
if (resultTimeout < 1){
|
throw new AusinessException(E.ADD_FAIL, "保存隐患整改信息失败");
|
}
|
}
|
//3、释放生成编码锁
|
lock.unlock();
|
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 AusinessException(E.DATA_PARAM_NULL, "传参非法");
|
}
|
if (manageUpdateReqDTO.getDangerLevel() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "隐患等级不能为空");
|
}
|
if (manageUpdateReqDTO.getDangerType() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "隐患类型不能为空");
|
}
|
if (manageUpdateReqDTO.getDangerSource() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "隐患来源不能为空");
|
}
|
if (manageUpdateReqDTO.getDepId() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "隐患所属部门不能为空");
|
}
|
//校验部门是否存在
|
ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(userId, manageUpdateReqDTO.getDepId());
|
if(ObjectUtils.isEmpty(depInfoByDepId)){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确责任部门");
|
}
|
if (manageUpdateReqDTO.getRiskUnitId() != null){
|
PreventRiskAnaUnit riskUnitById = preventRiskAnaUnitService.getRiskUnitById(manageUpdateReqDTO.getRiskUnitId());
|
if(ObjectUtils.isEmpty(riskUnitById)){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确的风险分析单元");
|
}
|
}
|
if (manageUpdateReqDTO.getProduceDeviceId() != null){
|
PreventProduceDevice deviceById =
|
preventProduceDeviceService.getDeviceById(manageUpdateReqDTO.getProduceDeviceId());
|
if (ObjectUtils.isEmpty(deviceById)){
|
throw new AusinessException(E.DATA_PARAM_NULL, "请填写正确的生产装置");
|
}
|
PreventRiskAnaUnit riskUnitById = preventRiskAnaUnitService.getRiskUnitById(manageUpdateReqDTO.getRiskUnitId());
|
if (!riskUnitById.getProduceDeviceId().equals(manageUpdateReqDTO.getProduceDeviceId())){
|
throw new AusinessException(E.DATA_PARAM_NULL, "请填写生产装置对应的分析单元");
|
}
|
}
|
if (manageUpdateReqDTO.getRectifyType() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "整改类型不能为空");
|
}
|
if (manageUpdateReqDTO.getLiablePersonId() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "整改责任人不能为空");
|
}
|
if (manageUpdateReqDTO.getRectifyDepId() == null){
|
throw new AusinessException(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 AusinessException(E.UPDATE_FAIL, "修改隐患整改信息失败");
|
}
|
|
int result = preventDangerManageService.updateDangerManage(updateParams);
|
if (rectifyResult < 1){
|
throw new AusinessException(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 AusinessException(E.DATA_DATABASE_NO_EXISTENT, "请选择正确的删除内容");
|
}
|
PreventDangerRectify rectifyByManageId = preventDangerRectifyService.getRectifyByManageId(manageDeleteReqDTO.getId());
|
if (ObjectUtils.isNotEmpty(rectifyByManageId)){
|
throw new AusinessException(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.getRecords())){
|
resultVO.setMsg("查询成功,无数据");
|
return resultVO;
|
}
|
//遍历结果集，封装数据
|
for (PreventDangerRectify record : page.getRecords()) {
|
PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(record.getDangerManagerId());
|
if (rectifyQueryReqDTO.getDangerStatus() != null){
|
if(dangerManageById.getDangerStatus().equals(rectifyQueryReqDTO.getDangerStatus())){
|
PreventDangerManageTimeout timeoutResult = preventDangerManageTimeoutService.getByRectifyId(record.getId());
|
PreventDangerRectifyQueryRespDTO respDTO = BeanCopyUtils.copyBean(record, PreventDangerRectifyQueryRespDTO.class);
|
//添加部门名称
|
ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(userId, respDTO.getRectifyDepId());
|
DepInfoRPCRespDTO data = (DepInfoRPCRespDTO)depInfoByDepId.getData();
|
if (ObjectUtils.isNotEmpty(timeoutResult)){
|
respDTO.setTimeoutStatus(timeoutResult.getTimeoutStatus());
|
}
|
respDTO.setSerialCode(dangerManageById.getSerialCode());
|
respDTO.setRectifyDepName(data.getDepName());
|
respDTO.setDangerStatus(dangerManageById.getDangerStatus());
|
respDTO.setDangerManagerId(dangerManageById.getId());
|
respDTO.setReportState(reportConfigById.getReportState());
|
respDTO.setReportType(reportConfigById.getReportType());
|
respDTO.setDangerCode(dangerManageById.getDangerCode());
|
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);
|
//添加部门名称
|
ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(userId, respDTO.getRectifyDepId());
|
DepInfoRPCRespDTO data = (DepInfoRPCRespDTO)depInfoByDepId.getData();
|
if (ObjectUtils.isNotEmpty(timeoutResult)){
|
respDTO.setTimeoutStatus(timeoutResult.getTimeoutStatus());
|
}
|
if (ObjectUtils.isNotEmpty(dangerManageById.getSerialCode())){
|
respDTO.setSerialCode(dangerManageById.getSerialCode());
|
}
|
respDTO.setSerialCode(dangerManageById.getSerialCode());
|
respDTO.setRectifyDepName(data.getDepName());
|
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.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);
|
}
|
|
//读取上报主配置
|
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);
|
if (ObjectUtils.isEmpty(page)){
|
resultVO.setMsg("查询成功,无数据");
|
return resultVO;
|
}
|
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());
|
}
|
DepInfoRPCRespDTO data = (DepInfoRPCRespDTO)depInfoByDepId.getData();
|
respDTO.setRectifyDepName(data.getDepName());
|
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.add(respDTO);
|
}
|
|
resultVO.setData(list);
|
resultVO.setCount((int) page.getTotal());
|
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 AusinessException(E.DATA_PARAM_NULL, "隐患管理单不能为空");
|
}
|
PreventDangerManage dangerManageById =
|
preventDangerManageService.getDangerManageById(rectifySaveReqDTO.getDangerManagerId());
|
if (ObjectUtils.isEmpty(dangerManageById)){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "请填写正确的隐患管理单");
|
}
|
//每个隐患管理单，只能有一个整改清单
|
PreventDangerRectify rectifyByCode =
|
preventDangerRectifyService.getRectifyByCode(dangerManageById.getDangerCode());
|
if (ObjectUtils.isNotEmpty(rectifyByCode)){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "每个隐患管理单只能有一个整改任务单");
|
}
|
if (rectifySaveReqDTO.getRectifyTime() == null ){
|
throw new AusinessException(E.DATA_PARAM_NULL, "整改期限不能为空");
|
}
|
|
if (rectifySaveReqDTO.getLiablePersonId() == null ){
|
throw new AusinessException(E.DATA_PARAM_NULL, "整改责任人不能为空");
|
}
|
//获取责任人信息
|
ResultVO<UserRPCRespDTO> liablePersonResult = accountAuthService.getUserById(rectifySaveReqDTO.getLiablePersonId());
|
UserRPCRespDTO liablePerson = (UserRPCRespDTO)liablePersonResult.getData();
|
if (ObjectUtils.isEmpty(liablePerson)){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "请正确填写整改责任人");
|
}
|
if (rectifySaveReqDTO.getRectifyDesc() == null ){
|
throw new AusinessException(E.DATA_PARAM_NULL, "整改内容说明");
|
}
|
if (rectifySaveReqDTO.getRectifyTime() == null ){
|
throw new AusinessException(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;
|
}
|
|
/**
|
* 隐患整改--延期
|
*/
|
@Transactional
|
@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 AusinessException(E.DATA_PARAM_NULL, "传参非法");
|
}
|
if (updateReqDTO.getDangerManagerId() == null ){
|
throw new AusinessException(E.DATA_PARAM_NULL, "隐患管理单不能为空");
|
}
|
if (updateReqDTO.getRectifyTime() == null ){
|
throw new AusinessException(E.DATA_PARAM_NULL, "延期的时间不能为空");
|
}
|
if (updateReqDTO.getTimeOutDesc() == null ){
|
throw new AusinessException(E.DATA_PARAM_NULL, "延期说明不能为空");
|
}
|
PreventDangerRectify rectify = preventDangerRectifyService.getRectifyById(updateReqDTO.getId());
|
if (updateReqDTO.getRectifyTime().getTime() - rectify.getRectifyTime().getTime() <= 0){
|
throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "延期时间必须大于整改期限");
|
}
|
PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(rectify.getDangerManagerId());
|
if (ObjectUtils.isEmpty(dangerManageById)){
|
throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "传参错误");
|
}
|
if (dangerManageById.getDangerStatus() == StatusEnum.DANGER_MANAGER_NOT_ACCEPT.getCode()){
|
throw new AusinessException(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 AusinessException(E.UPDATE_FAIL, "延期操作失败");
|
}
|
//管理单变更状态成功
|
//封装修改参数
|
UpdateRectifyResultParams updateRectifyParams = new UpdateRectifyResultParams();
|
updateRectifyParams.setDangerStatus(StatusEnum.DANGER_MANAGER_TIMEOUT_RECTIFY.getCode());
|
updateRectifyParams.setDangerManagerId(updateReqDTO.getDangerManagerId());
|
updateRectifyParams.setUpdateReportDataTime(new Date());
|
|
//封装延期状态参数
|
PreventDangerManageTimeout manageTimeout = new PreventDangerManageTimeout();
|
manageTimeout.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());
|
manageTimeout.setTimeoutStatus(StatusEnum.DANGER_MANAGER_TIMEOUT_RECTIFY.getCode());
|
manageTimeout.setDangerRectifyId(updateReqDTO.getId());
|
manageTimeout.setDangerManagerId(updateReqDTO.getDangerManagerId());
|
|
int resultManager = preventDangerManageService.updateRectifyResult(updateRectifyParams);
|
if (resultManager < 1){
|
throw new AusinessException(E.UPDATE_FAIL, "隐患管理状态变更失败");
|
}
|
int resultTimeout = preventDangerManageTimeoutService.updateTimeout(manageTimeout);
|
if (resultTimeout < 1){
|
throw new AusinessException(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 AusinessException(E.DATA_PARAM_NULL, "参数非法");
|
}
|
PreventDangerManage dangerManageById =
|
preventDangerManageService.getDangerManageById(rectifyUpdateReqDTO.getDangerManagerId());
|
if (ObjectUtils.isEmpty(dangerManageById)){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "请填写正确的隐患管理单");
|
}
|
if (rectifyUpdateReqDTO.getRectifyTime() == null ){
|
throw new AusinessException(E.DATA_PARAM_NULL, "整改期限不能为空");
|
}
|
if (rectifyUpdateReqDTO.getLiablePersonId() == null ){
|
throw new AusinessException(E.DATA_PARAM_NULL, "整改责任人不能为空");
|
}
|
//获取责任人信息
|
ResultVO<UserRPCRespDTO> liablePersonResult = accountAuthService.getUserById(rectifyUpdateReqDTO.getLiablePersonId());
|
UserRPCRespDTO liablePerson = (UserRPCRespDTO)liablePersonResult.getData();
|
if (ObjectUtils.isEmpty(liablePerson)){
|
throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "请正确填写整改责任人");
|
}
|
if (rectifyUpdateReqDTO.getRectifyDesc() == null ){
|
throw new AusinessException(E.DATA_PARAM_NULL, "整改内容说明不能为空");
|
}
|
if (rectifyUpdateReqDTO.getRectifyType() == null ){
|
throw new AusinessException(E.DATA_PARAM_NULL, "整改类型不能为空");
|
}
|
if (rectifyUpdateReqDTO.getCost() == null ){
|
throw new AusinessException(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 AusinessException(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 AusinessException(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 AusinessException(E.DATA_PARAM_CHECK_INVALID, "该整改单不是整改中状态，只有在整改的单据才可以申请验收");
|
}
|
if (reportRectify.getRectifyInfo() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "整改说明不能为空");
|
}
|
|
if (dangerManageById.getDangerReview() == StatusEnum.DANGER_RECTIFY_REVIEW.getCode()){
|
throw new AusinessException(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 AusinessException(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 AusinessException(E.UPDATE_FAIL, "状态变更失败");
|
}
|
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);
|
}
|
//只有没有处理过的隐患，才能关闭
|
//封装参数
|
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 AusinessException(E.UPDATE_FAIL, "关闭隐患管理信息失败");
|
}
|
//当做删除-进行同步
|
int resultRectify = preventDangerRectifyService.closeDanger(closeDangerParams);
|
if (resultRectify < 1){
|
throw new AusinessException(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 AusinessException(E.DATA_PARAM_NULL, "参数为空");
|
}
|
if (reportRectify.getDangerManagerId() == null ){
|
throw new AusinessException(E.DATA_PARAM_NULL, "参数为空");
|
}
|
if (reportRectify.getCheckAcceptDesc() == null){
|
throw new AusinessException(E.DATA_PARAM_NULL, "验收意见不能为空");
|
}
|
PreventDangerRectify rectifyById = preventDangerRectifyService.getRectifyById(reportRectify.getId());
|
if(!rectifyById.getCheckAcceptPersonId().equals(userId)){
|
throw new AusinessException(E.DATA_PARAM_NULL, "非验收人，无权操作");
|
}
|
PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(reportRectify.getDangerManagerId());
|
if (dangerManageById.getDangerStatus() != StatusEnum.DANGER_MANAGER_WAIT_ACCEPT.getCode()){
|
throw new AusinessException(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 AusinessException(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 AusinessException(E.UPDATE_FAIL, "验收状态变更失败");
|
}
|
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 AusinessException(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;
|
}
|
|
/**
|
* 生成隐患编码
|
* @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();
|
}
|
}
|
