package com.ruoyi.project.mobile.service;
|
|
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.github.pagehelper.util.StringUtil;
|
import com.ruoyi.common.constant.TrHiddenDangerCheckConstants;
|
import com.ruoyi.common.utils.DateUtils;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.common.utils.security.ShiroUtils;
|
import com.ruoyi.doublePrevention.entity.PreventRiskDangerInfo;
|
import com.ruoyi.doublePrevention.service.RiskService;
|
import com.ruoyi.doublePrevention.service.baseService.PreventRiskDangerCheckAndMeasureService;
|
import com.ruoyi.doublePrevention.service.baseService.PreventRiskDangerConfirmLogService;
|
import com.ruoyi.framework.web.domain.AjaxResult;
|
import com.ruoyi.project.mobile.domain.ApiRequestHeader;
|
import com.ruoyi.project.mobile.domain.ApiResult;
|
import com.ruoyi.project.system.user.domain.User;
|
import com.ruoyi.project.system.user.service.IUserService;
|
import com.ruoyi.project.tr.hiddenDangerCheck.domain.HiddenDangerCheck;
|
import com.ruoyi.project.tr.hiddenDangerCheck.service.IHiddenDangerCheckService;
|
import com.ruoyi.project.tr.hiddenDangerCheckPoint.domain.HiddenDangerCheckPoint;
|
import com.ruoyi.project.tr.hiddenDangerCheckPoint.service.IHiddenDangerCheckPointService;
|
import org.apache.commons.lang3.ObjectUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.data.redis.connection.ReactiveListCommands;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.ui.ModelMap;
|
import org.springframework.web.bind.annotation.GetMapping;
|
import org.springframework.web.bind.annotation.PathVariable;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.text.NumberFormat;
|
import java.text.ParseException;
|
import java.text.SimpleDateFormat;
|
import java.util.*;
|
|
|
@Service
|
public class ApiHiddenDangerCheckService extends BaseApiService {
|
|
private static Logger logger = LoggerFactory.getLogger(ApiHiddenDangerCheckService.class);
|
|
@Autowired
|
IHiddenDangerCheckService hiddenDangerCheckService;//隐患Service
|
|
@Autowired
|
IHiddenDangerCheckPointService hdcpService;//隐患检查点Service
|
|
@Autowired
|
private PreventRiskDangerCheckAndMeasureService riskDangerCheckAndMeasureService;//隐患检查点Service
|
|
@Autowired
|
IUserService userService;//用户Service
|
|
@Autowired
|
private RiskService riskService;
|
|
@Autowired
|
private PreventRiskDangerConfirmLogService confirmLogService;
|
|
|
@Autowired
|
private IHiddenDangerCheckPointService hiddenDangerCheckPointService;
|
|
/**
|
* 获取隐患列表
|
*
|
* @param str
|
* @param header
|
* @return
|
*/
|
public ApiResult getHiddenDangeCheckList(String str, ApiRequestHeader header) {
|
//验证userId,loginName,token,deviceType,deviceId,appType 是否一致
|
ApiRequestHeader requestHeader = getHeader(header);
|
if (!(header.equals(requestHeader))) {
|
return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
|
}
|
|
String loginName = header.loginName;
|
try {
|
Map<String, String> queryHiddenDangerCheck = new ObjectMapper().readValue(str, HashMap.class);
|
String hiddenDangerCheckType = queryHiddenDangerCheck.get("hiddenDangerCheckType");//隐患类型
|
String hiddenDangerCheckStatus = queryHiddenDangerCheck.get("hiddenDangerCheckStatus");//隐患状态
|
HiddenDangerCheckPoint hdcp = new HiddenDangerCheckPoint();
|
|
if (StringUtils.isEmpty(hiddenDangerCheckType) || StringUtils.isEmpty(hiddenDangerCheckType)) {
|
return ApiResult.success("传输hiddenDangerCheckType为空", new ArrayList<HiddenDangerCheck>());
|
} else {
|
if ("examine".equals(hiddenDangerCheckType)) {
|
hdcp.setExamineUserId(Long.valueOf(header.userId));//核查人
|
hdcp.setExamineStatus(hiddenDangerCheckStatus);//核查状态
|
|
} else if ("rectify".equals(hiddenDangerCheckType)) {
|
hdcp.setRectifyUserId(Long.valueOf(header.userId));//整改人
|
hdcp.setRectifyStatus(hiddenDangerCheckStatus);//整改状态
|
|
} else if ("accept".equals(hiddenDangerCheckType)) {
|
hdcp.setAcceptUserId(Long.valueOf(header.userId));//验收人
|
hdcp.setAcceptStatus(hiddenDangerCheckStatus);//验收状态
|
|
} else if ("planExecute".equals(hiddenDangerCheckType)) {
|
HiddenDangerCheck hdcQuery = new HiddenDangerCheck();
|
hdcQuery.setPlanFormulateStatusExclude(TrHiddenDangerCheckConstants.PLAN_FORMULATE_STATUS_NOT_STARTED);//排除---------隐患排查计划制定(未开始)的
|
if ("1".equals(hiddenDangerCheckStatus)) {
|
hiddenDangerCheckStatus = "2";
|
}
|
hdcQuery.setPlanExecuteStatus(hiddenDangerCheckStatus);//隐患排查计划执行（0未开始 2已完成）
|
hdcQuery.setCheckUserId(Long.valueOf(header.userId));//排查人
|
|
|
List<HiddenDangerCheck> resultList = hiddenDangerCheckService.selectHiddenDangerCheckList(hdcQuery);
|
//特殊处理（获取计划创建人姓名）
|
for (HiddenDangerCheck hdc : resultList) {
|
User user = userService.selectUserById(hdc.getPlanCreateUserId());
|
hdc.setPlanCreateUserName(user.getUserName());
|
}
|
return ApiResult.success("请求数据成功", resultList);
|
|
} else {
|
return ApiResult.success("传输hiddenDangerCheckType有误", new ArrayList<HiddenDangerCheck>());
|
}
|
List<HiddenDangerCheckPoint> resultList = hdcpService.selectHiddenDangerCheckPointList(hdcp);
|
for (HiddenDangerCheckPoint dangerCheckPoint : resultList) {
|
PreventRiskDangerInfo dangerInfo = riskService.getDangerInfoByDangerCheckPointId(dangerCheckPoint.getId());
|
if (ObjectUtils.isNotEmpty(dangerInfo)){
|
if (ObjectUtils.isNotEmpty(dangerInfo.getDangerSrc())){
|
dangerCheckPoint.setDangerSrc(dangerInfo.getDangerSrc());
|
}
|
if (ObjectUtils.isNotEmpty(dangerInfo.getReportTime())){
|
dangerCheckPoint.setReportTime(dangerInfo.getReportTime());
|
}
|
}
|
}
|
return ApiResult.success("请求数据成功", resultList);
|
}
|
} catch (Exception e) {
|
return ApiResult.error("异常");
|
}
|
}
|
|
/**
|
* 隐患核查--再次核查
|
*/
|
@Transactional
|
public ApiResult editNextConfirmSave(String str, ApiRequestHeader header) {
|
//验证userId,loginName,token,deviceType,deviceId,appType 是否一致
|
ApiRequestHeader requestHeader = getHeader(header);
|
if (!(header.equals(requestHeader))) {
|
return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
|
}
|
try {
|
Map<String, String> map = new ObjectMapper().readValue(str, HashMap.class);
|
HiddenDangerCheckPoint hdcp = new ObjectMapper().readValue(str, HiddenDangerCheckPoint.class);
|
// todo-2022 中间核查，插入多人核查附属表
|
if(ObjectUtils.isEmpty(hdcp.getId())){
|
throw new RuntimeException("id不能为空");
|
}
|
// report_status , 上报判定结果(0未判定 1不是隐患 2是隐患）
|
// if(ObjectUtils.isEmpty(hdcp.getReportStatus())){
|
// throw new RuntimeException("判定结果不能为空");
|
// }
|
// examine_user_id , 核查人id
|
if(ObjectUtils.isEmpty(hdcp.getExamineUserId())){
|
throw new RuntimeException("核查人Id不能为空");
|
}
|
// examine_user_name
|
if(ObjectUtils.isEmpty(hdcp.getExamineUserName())){
|
throw new RuntimeException("核查人姓名不能为空");
|
}
|
// examine_opinion 意见
|
// if(ObjectUtils.isEmpty(hdcp.getRectifyDeadlineTime())){
|
// throw new RuntimeException("核查意见不能为空");
|
// }
|
int confirmResult = confirmLogService.saveConfirmLog(hdcp);
|
if (confirmResult < 1){
|
throw new RuntimeException("操作失败");
|
}
|
return ApiResult.success("隐患核查保存成功");
|
} catch (Exception e) {
|
return ApiResult.error(e.getMessage());
|
}
|
}
|
/**
|
* 隐患核查--保存
|
*/
|
@Transactional
|
public ApiResult editDangerExamineSave(String str, ApiRequestHeader header) {
|
//验证userId,loginName,token,deviceType,deviceId,appType 是否一致
|
ApiRequestHeader requestHeader = getHeader(header);
|
if (!(header.equals(requestHeader))) {
|
return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
|
}
|
try {
|
Map<String, String> map = new ObjectMapper().readValue(str, HashMap.class);
|
HiddenDangerCheckPoint hdcp = new ObjectMapper().readValue(str, HiddenDangerCheckPoint.class);
|
// todo-2023
|
hdcp.setUpdateBy(header.loginName);
|
hdcp.setUpdateTime(DateUtils.getNowDate());
|
hdcp.setExamineCreateTime(DateUtils.getNowDate());//设置核查时间
|
hdcp.setExamineStatus(TrHiddenDangerCheckConstants.EXAMINE_STATUS_ALREADY_EXAMINE);//核查状态(已核查)
|
if (!StringUtil.isEmpty(hdcp.getDangerLevel())) {
|
if (("0".equals(hdcp.getDangerLevel()))
|
|| ("1".equals(hdcp.getDangerLevel()))) {//0 一般隐患 1 重大隐患
|
hdcp.setRectifyStatus(TrHiddenDangerCheckConstants.RECTIFY_STATUS_NOT_RECTIFY);//整改状态(未整改)
|
hdcp.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_RECTIFY);//隐患整改阶段(数据进入到隐患整改阶段)
|
} else if (("2".equals(hdcp.getDangerLevel()))) { //2 不是隐患
|
hdcp.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_NOT);//是否为隐患(正常)
|
}
|
}
|
|
hdcpService.updateHiddenDangerCheckPoint(hdcp);
|
//20250623 修改此处
|
PreventRiskDangerInfo dangerInfoByDangerCheckPointId = riskService.getDangerInfoByDangerCheckPointId(hdcp.getId());
|
if (ObjectUtils.isNotEmpty(dangerInfoByDangerCheckPointId)){
|
//此处插入隐患附属表
|
int result = riskService.updateDangerInfo(hdcp);
|
if (result < 1){
|
throw new RuntimeException("修改失败");
|
}
|
}else {
|
//此处插入隐患附属表
|
int result = riskService.insertDangerInfo(hdcp.getId(), hdcp);
|
if (result < 1){
|
throw new RuntimeException("添加隐患附属信息失败");
|
}
|
}
|
// //此处插入隐患附属表
|
// int result = riskService.updateCheckLog(hdcp.getId(), hdcp);
|
// if (result< 1){
|
// throw new RuntimeException("添加隐患附属信息失败");
|
// }
|
|
|
HiddenDangerCheckPoint hiddenDangerCheckPoint = hiddenDangerCheckPointService.getHiddenDangerCheckPointById(hdcp.getId());
|
int confirmResult = confirmLogService.saveConfirmLog(hiddenDangerCheckPoint);
|
if (confirmResult < 1){
|
throw new RuntimeException("操作失败");
|
}
|
|
hdcpService.getTaskCountTotal(Long.valueOf(header.userId));//查询未执行任务总数量并推送
|
|
return ApiResult.success("隐患核查保存成功");
|
} catch (Exception e) {
|
return ApiResult.error(e.getMessage());
|
}
|
}
|
|
/**
|
* 隐患整改--保存
|
*/
|
@Transactional
|
public ApiResult editDangerRectifySave(String str, ApiRequestHeader header) {
|
//验证userId,loginName,token,deviceType,deviceId,appType 是否一致
|
ApiRequestHeader requestHeader = getHeader(header);
|
if (!(header.equals(requestHeader))) {
|
return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
|
}
|
try {
|
HiddenDangerCheckPoint hdcp = new ObjectMapper().readValue(str, HiddenDangerCheckPoint.class);
|
hdcp.setUpdateBy(header.loginName);
|
hdcp.setUpdateTime(DateUtils.getNowDate());
|
hdcp.setRectifyCreateTime(DateUtils.getNowDate());//设置整改时间
|
hdcp.setRectifyStatus(TrHiddenDangerCheckConstants.RECTIFY_STATUS_ALREADY_RECTIFY);//整改状态(已整改)
|
hdcp.setAcceptStatus(TrHiddenDangerCheckConstants.ACCEPT_STATUS_NOT_ACCEPT);//验收状态(未验收)
|
hdcp.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_ACCEPT);//隐患验收阶段(数据进入到隐患验收阶段)
|
hdcpService.updateHiddenDangerCheckPoint(hdcp);
|
|
hdcpService.getTaskCountTotal(Long.valueOf(header.userId));//查询未执行任务总数量并推送
|
|
// todo-2022 隐患信息附属表
|
int result = riskService.updateDangerInfoRectify(hdcp);
|
if (result < 1){
|
throw new RuntimeException("整改信息保存失败");
|
}
|
return ApiResult.success("隐患整改保存成功");
|
} catch (Exception e) {
|
return ApiResult.error("异常");
|
}
|
}
|
|
/**
|
* 整改延期--保存
|
*/
|
@Transactional
|
public ApiResult rectifyTimeOutSave(String str, ApiRequestHeader header) {
|
//验证userId,loginName,token,deviceType,deviceId,appType 是否一致
|
ApiRequestHeader requestHeader = getHeader(header);
|
if (!(header.equals(requestHeader))) {
|
return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
|
}
|
try {
|
HiddenDangerCheckPoint hdcp = new ObjectMapper().readValue(str, HiddenDangerCheckPoint.class);
|
hdcp.setUpdateBy(header.loginName);
|
hdcp.setUpdateTime(DateUtils.getNowDate());
|
|
int result = hdcpService.rectifyTimeOut(hdcp.getId(), hdcp.getRectifyDeadlineTime());
|
if (result < 1) {
|
return ApiResult.error("延期失败");
|
}
|
|
return ApiResult.success("延期成功");
|
} catch (Exception e) {
|
return ApiResult.error("异常");
|
}
|
}
|
|
|
/**
|
* 隐患验收--保存
|
*/
|
@Transactional
|
public ApiResult editDangerAcceptSave(String str, ApiRequestHeader header) {
|
//验证userId,loginName,token,deviceType,deviceId,appType 是否一致
|
ApiRequestHeader requestHeader = getHeader(header);
|
if (!(header.equals(requestHeader))) {
|
return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
|
}
|
try {
|
new ObjectMapper().readValue(str, HiddenDangerCheckPoint.class);
|
HiddenDangerCheckPoint hdcp = new ObjectMapper().readValue(str, HiddenDangerCheckPoint.class);
|
hdcp.setUpdateBy(header.loginName);
|
hdcp.setUpdateTime(DateUtils.getNowDate());
|
if (ObjectUtils.isEmpty(hdcp.getAcceptCreateTime())){
|
throw new RuntimeException("请填写验收时间");
|
}
|
if (!StringUtils.isEmpty(hdcp.getAcceptResult())) {
|
//验收结果 (0不通过 打回上一级整改阶段 1通过)
|
if ("0".equals(hdcp.getAcceptResult())) {
|
hdcp.setAcceptCreateTime(hdcp.getAcceptCreateTime());//设置验收时间
|
hdcp.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_RECTIFY);//隐患整改阶段(数据进入到隐患整改阶段)
|
hdcp.setRectifyStatus(TrHiddenDangerCheckConstants.RECTIFY_STATUS_NOT_RECTIFY);//整改状态(未整改)
|
hdcp.setAcceptStatus(TrHiddenDangerCheckConstants.ACCEPT_STATUS_ALREADY_ACCEPT_NOT_PASS);//验收状态(验收未通过)
|
} else if ("1".equals(hdcp.getAcceptResult())) {
|
hdcp.setAcceptCreateTime(hdcp.getAcceptCreateTime());//设置验收时间
|
hdcp.setAcceptStatus(TrHiddenDangerCheckConstants.ACCEPT_STATUS_ALREADY_ACCEPT_PASS);//验收状态(验收通过)
|
}
|
}
|
hdcpService.updateHiddenDangerCheckPoint(hdcp);
|
|
hdcpService.getTaskCountTotal(Long.valueOf(header.userId));//查询未执行任务总数量并推送
|
|
// todo-2022 验收通过,修改为已验收状态
|
int result = riskService.updateDangerInfoAccept(hdcp);
|
if (result < 1){
|
throw new RuntimeException("隐患验收信息保存失败");
|
}
|
|
return ApiResult.success("隐患验收保存成功");
|
} catch (Exception e) {
|
return ApiResult.error("异常");
|
}
|
}
|
|
|
|
/**
|
* 隐患计划执行--保存
|
*/
|
public ApiResult editDangerPlanExecuteSave(String str, ApiRequestHeader header) {
|
//验证userId,loginName,token,deviceType,deviceId,appType 是否一致
|
ApiRequestHeader requestHeader = getHeader(header);
|
if (!(header.equals(requestHeader))) {
|
return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
|
}
|
try {
|
HiddenDangerCheck hiddenDangerCheck = new ObjectMapper().readValue(str, HiddenDangerCheck.class);
|
hiddenDangerCheck.setCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)
|
hiddenDangerCheck.setCheckTime(DateUtils.getNowDate());//设置排查时间
|
hiddenDangerCheck.setPlanFormulateStatus(TrHiddenDangerCheckConstants.PLAN_FORMULATE_STATUS_ALREADY_COMPLETE);//隐患排查计划制定(已完成)
|
hiddenDangerCheck.setPlanExecuteStatus(TrHiddenDangerCheckConstants.PLAN_EXECUTE_STATUS_ALREADY_COMPLETE);//隐患排查计划执行(已完成)
|
HiddenDangerCheckPoint hdcpTemp = new HiddenDangerCheckPoint();
|
hdcpTemp.setCheckId(hiddenDangerCheck.getCheckId());
|
List<HiddenDangerCheckPoint> hdcpList = hdcpService.selectHiddenDangerCheckPointList(hdcpTemp);
|
|
for (HiddenDangerCheckPoint hdcp : hdcpList) {
|
if(StringUtils.isEmpty(hdcp.getWhetherDanger())){
|
return ApiResult.error("检查点需全部操作，请操作检查点。");
|
}
|
}
|
|
hdcpList.forEach(hdcp-> {
|
if (hdcp != null) {
|
hdcp.setUpdateBy(header.loginName);//更新者
|
hdcp.setUpdateTime(DateUtils.getNowDate());//更新时间
|
//是隐患设置核查人ID、核查人名称
|
if((!StringUtils.isEmpty(hdcp.getWhetherDanger()))&&
|
(TrHiddenDangerCheckConstants.WHETHER_DANGER_YES.equals(hdcp.getWhetherDanger()))) {
|
hdcp.setExamineStatus(TrHiddenDangerCheckConstants.EXAMINE_STATUS_NOT_EXAMINE);//核查状态(待核查)
|
hdcp.setExamineUserId(hiddenDangerCheck.getExamineUserId());//核查人ID
|
hdcp.setExamineUserName(hiddenDangerCheck.getExamineUserName());//核查人名称
|
hdcp.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_EXAMINE);//3隐患核查阶段(/** 更新者 */数据进入到3隐患核查阶段)
|
}
|
hdcpService.updateHiddenDangerCheckPoint(hdcp);
|
}
|
});
|
hiddenDangerCheckService.updateHiddenDangerCheck(hiddenDangerCheck);
|
|
hdcpService.getTaskCountTotal(Long.valueOf(header.userId));//查询未执行任务总数量并推送
|
|
return ApiResult.success("隐患排查计划执行--保存成功");
|
} catch (Exception e) {
|
return ApiResult.error("异常");
|
}
|
}
|
|
|
/**
|
* 隐患计划执行中---设置为记录正常
|
*/
|
public ApiResult editPointSetNormal(String str, ApiRequestHeader header) {
|
//验证userId,loginName,token,deviceType,deviceId,appType 是否一致
|
ApiRequestHeader requestHeader = getHeader(header);
|
if (!(header.equals(requestHeader))) {
|
return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
|
}
|
try {
|
HiddenDangerCheckPoint hdcp = new ObjectMapper().readValue(str, HiddenDangerCheckPoint.class);
|
hdcp.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_NOT);//是否为隐患(正常)
|
hdcp.setCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)
|
hdcp.setPlanFormulateStatus(TrHiddenDangerCheckConstants.PLAN_FORMULATE_STATUS_ALREADY_COMPLETE);//隐患排查计划制定(已完成)
|
hdcp.setPlanExecuteStatus(TrHiddenDangerCheckConstants.PLAN_EXECUTE_STATUS_ALREADY_COMPLETE);//隐患排查计划执行(已完成)
|
hdcpService.updateHiddenDangerCheckPoint(hdcp);
|
|
hdcpService.getTaskCountTotal(Long.valueOf(header.userId));//查询未执行任务总数量并推送
|
|
return ApiResult.success("隐患排查计划执行--设置为正常--成功");
|
} catch (Exception e) {
|
return ApiResult.error("异常");
|
}
|
}
|
|
|
/**
|
* 隐患计划执行中---隐患登记
|
*/
|
@Transactional
|
public ApiResult editPointDangerRegisterSave(String str, ApiRequestHeader header) {
|
//验证userId,loginName,token,deviceType,deviceId,appType 是否一致
|
ApiRequestHeader requestHeader = getHeader(header);
|
if (!(header.equals(requestHeader))) {
|
return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
|
}
|
try {
|
HiddenDangerCheckPoint hdcp = new ObjectMapper().readValue(str, HiddenDangerCheckPoint.class);
|
if (ObjectUtils.isEmpty(hdcp.getCheckPerson())){
|
throw new RuntimeException("检查人不能为空");
|
}
|
if (ObjectUtils.isEmpty(hdcp.getFindTime())){
|
throw new RuntimeException("发现时间不能为空");
|
}
|
if(ObjectUtils.isEmpty(hdcp.getDangerSrc())){
|
throw new RuntimeException("隐患来源不能为空");
|
}
|
hdcp.setRegisterCreateTime(DateUtils.getNowDate());//设置隐患登记上报创建时间
|
hdcp.setRegisterUserId(Long.valueOf(header.userId));//设置隐患登记上报创建人ID
|
User user = userService.selectUserById(Long.valueOf(header.userId));
|
hdcp.setRegisterUserName(user.getUserName());//设置隐患登记上报创建人名称
|
hdcp.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_YES);//是否为隐患(是隐患)
|
hdcp.setCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)
|
hdcp.setExamineStatus(TrHiddenDangerCheckConstants.EXAMINE_STATUS_NOT_EXAMINE);//核查状态(待核查)
|
hdcp.setPlanFormulateStatus(TrHiddenDangerCheckConstants.PLAN_FORMULATE_STATUS_ALREADY_COMPLETE);//隐患排查计划制定(已完成)
|
hdcp.setPlanExecuteStatus(TrHiddenDangerCheckConstants.PLAN_EXECUTE_STATUS_ALREADY_COMPLETE);//隐患排查计划执行(已完成)
|
hdcp.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_EXAMINE);//隐患核查阶段(数据进入到隐患核查阶段)
|
|
hdcp.setDangerSources(TrHiddenDangerCheckConstants.DANGER_SOURCES_PLAN_PRODUCE); //隐患来源(隐患计划排查生成)
|
|
HiddenDangerCheckPoint queryExist = new HiddenDangerCheckPoint();
|
queryExist.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_YES);//是否为隐患(是隐患)
|
queryExist.setCheckPointId(hdcp.getCheckPointId());
|
queryExist.setCheckId(hdcp.getCheckId());
|
List<HiddenDangerCheckPoint> queryExistList = hdcpService.selectHiddenDangerCheckPointList(queryExist);
|
int i=0;
|
if(queryExistList.size()>0){
|
hdcp.setId(null);
|
hdcp.setCheckTime(DateUtils.getNowDate());
|
hdcp.setCreateBy(user.getLoginName());
|
hdcp.setCreateTime(DateUtils.getNowDate());
|
|
hdcp.setCompanyId(user.getCompanyId());
|
i = hdcpService.insertHiddenDangerCheckPoint(hdcp);
|
//20250623增加此逻辑
|
int result = riskService.insertDangerInfo(hdcp.getId(), hdcp);
|
if (result< 1){
|
throw new RuntimeException("添加隐患附属信息失败");
|
}
|
}else{
|
hdcp.setUpdateBy(user.getLoginName());
|
hdcp.setUpdateTime(DateUtils.getNowDate());
|
i = hdcpService.updateHiddenDangerCheckPoint(hdcp);
|
//20250623增加此逻辑
|
PreventRiskDangerInfo dangerInfoByDangerCheckPointId = riskService.getDangerInfoByDangerCheckPointId(hdcp.getId());
|
if (dangerInfoByDangerCheckPointId != null){
|
// todo-2022 此处修改附属表 20250623 放开
|
int result = riskService.updateDangerInfo(hdcp);
|
if (result < 1){
|
throw new RuntimeException("修改失败");
|
}
|
}else {
|
int result = riskService.insertDangerInfo(hdcp.getId(), hdcp);
|
if (result < 1){
|
throw new RuntimeException("修改失败");
|
}
|
}
|
}
|
|
hdcpService.getTaskCountTotal(Long.valueOf(header.userId));//查询未执行任务总数量并推送
|
|
return ApiResult.success("隐患排查计划执行--隐患登记--成功");
|
} catch (Exception e) {
|
return ApiResult.error(e.getMessage());
|
}
|
}
|
|
/**
|
* 隐患查看
|
*/
|
public ApiResult detailPointDangerRegister(String str, ApiRequestHeader header) {
|
//验证userId,loginName,token,deviceType,deviceId,appType 是否一致
|
ApiRequestHeader requestHeader = getHeader(header);
|
if (!(header.equals(requestHeader))) {
|
return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
|
}
|
try {
|
HiddenDangerCheckPoint hdcp = new ObjectMapper().readValue(str, HiddenDangerCheckPoint.class);
|
HiddenDangerCheckPoint hiddenDangerCheckPoint = hdcpService.selectHiddenDangerCheckPointById(hdcp.getId());
|
PreventRiskDangerInfo dangerInfo = riskService.getDangerInfoByDangerCheckPointId(hiddenDangerCheckPoint.getId());
|
if (ObjectUtils.isNotEmpty(dangerInfo.getReportTime())){
|
hiddenDangerCheckPoint.setReportTime(dangerInfo.getReportTime());
|
}
|
return ApiResult.success("隐患查看--成功",hiddenDangerCheckPoint);
|
} catch (Exception e) {
|
return ApiResult.error("异常");
|
}
|
}
|
|
/**
|
* 隐患数据统计
|
*/
|
public ApiResult getDangerDataStatistics(String str, ApiRequestHeader header) {
|
//验证userId,loginName,token,deviceType,deviceId,appType 是否一致
|
ApiRequestHeader requestHeader = getHeader(header);
|
if (!(header.equals(requestHeader))) {
|
return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
|
}
|
try {
|
HiddenDangerCheckPoint hdcpQuery = new HiddenDangerCheckPoint();
|
HiddenDangerCheckPoint hdcpQueryAll = new HiddenDangerCheckPoint();
|
HiddenDangerCheckPoint queryByTime = new HiddenDangerCheckPoint();
|
hdcpQuery.setRectifyUserIdIsNotNull("1");//隐患整改人ID 不为空
|
hdcpQueryAll.setRectifyUserIdIsNotNull("1");//隐患整改人ID 不为空
|
queryByTime.setRectifyUserIdIsNotNull("1");//隐患整改人ID 不为空
|
Map<String, String> map = new ObjectMapper().readValue(str, HashMap.class);
|
if(map!=null){
|
if(!StringUtils.isEmpty(map.get("companyId"))){
|
// User userQuery = new User();
|
// userQuery.setCompanyId(Long.valueOf(map.get("companyId")));
|
// List<User> userList = userService.selectUserList(userQuery);
|
// List<Long> userIdList = new ArrayList<>();
|
// for (User user : userList){
|
// userIdList.add(user.getUserId());
|
// }
|
hdcpQuery.setCompanyId(Long.valueOf(map.get("companyId")));//隐患整改人ID 为登陆账号companyId下的userId的
|
hdcpQueryAll.setCompanyId(Long.valueOf(map.get("companyId")));//隐患整改人ID 为登陆账号companyId下的userId的
|
queryByTime.setCompanyId(Long.valueOf(map.get("companyId")));//隐患整改人ID 为登陆账号companyId下的userId的
|
}else{
|
return ApiResult.error("参数companyId不能为空！");
|
}
|
//隐患等级
|
if(!StringUtils.isEmpty(map.get("dangerLevel"))){
|
hdcpQuery.setDangerLevel(map.get("dangerLevel"));
|
}
|
//日期区间
|
if(!StringUtils.isEmpty(map.get("dateRange"))){
|
if(("近一周").equals(map.get("dateRange"))){
|
hdcpQuery.setParams(getDaySevenRange());
|
}else if(("近一月").equals(map.get("dateRange"))){
|
hdcpQuery.setParams(getMonthRange());
|
}else if(("近一年").equals(map.get("dateRange"))){
|
hdcpQuery.setParams(getYearRange());
|
}
|
}
|
//整改状态
|
if(!StringUtils.isEmpty(map.get("rectifyStatus"))){
|
if(("未整改").equals(map.get("rectifyStatus"))){
|
hdcpQuery.setStage("4");
|
hdcpQuery.setRectifyStatus("0");
|
}else if(("未验收").equals(map.get("rectifyStatus"))){
|
hdcpQuery.setStage("5");
|
hdcpQuery.setAcceptStatus("0");
|
}else if(("已验收").equals(map.get("rectifyStatus"))){
|
hdcpQuery.setStage("5");
|
hdcpQuery.setAcceptStatus("1");
|
}
|
}
|
//整改部门
|
if(!StringUtils.isEmpty(map.get("rectifyDeptId"))){
|
hdcpQuery.setRectifyDeptId(Long.valueOf(map.get("rectifyDeptId")));
|
}
|
}
|
List<HiddenDangerCheckPoint> resultList = hdcpService.selectHiddenDangerCheckPointList(hdcpQuery);//根据companyId 和 页面筛选条件 查询出的列表
|
|
Map<String, Object> resultMap = new HashMap<>();
|
for (HiddenDangerCheckPoint hdcp : resultList) {
|
if (!StringUtils.isEmpty(hdcp.getStage())) {
|
if ("3".equals(hdcp.getStage())) {
|
if ((!StringUtils.isEmpty(hdcp.getExamineStatus()))&&"0".equals(hdcp.getExamineStatus())) {
|
hdcp.setStage("未核查");
|
}
|
}else if ("4".equals(hdcp.getStage())){
|
if ((!StringUtils.isEmpty(hdcp.getRectifyStatus()))&&"0".equals(hdcp.getRectifyStatus())) {
|
hdcp.setStage("未整改");
|
}
|
}else if ("5".equals(hdcp.getStage())){
|
if (!StringUtils.isEmpty(hdcp.getAcceptStatus())) {
|
if("0".equals(hdcp.getAcceptStatus())){
|
hdcp.setStage("未验收");
|
}else{
|
hdcp.setStage("已验收");
|
}
|
}
|
}
|
}
|
}
|
for (HiddenDangerCheckPoint dangerCheckPoint : resultList) {
|
PreventRiskDangerInfo dangerInfo = riskService.getDangerInfoByDangerCheckPointId(dangerCheckPoint.getId());
|
if (ObjectUtils.isNotEmpty(dangerInfo)){
|
if (ObjectUtils.isNotEmpty(dangerInfo.getReportTime())){
|
dangerCheckPoint.setReportTime(dangerInfo.getReportTime());
|
}
|
}
|
}
|
resultMap.put("resultList", resultList);
|
|
//companyId下总的数据统计
|
List<HiddenDangerCheckPoint> resultListAll = hdcpService.selectHiddenDangerCheckPointList(hdcpQueryAll);//根据companyId 查询出的列表
|
int totalDangerNum = 0;//隐患数
|
int rectifyNum = 0;//已整改数目
|
int notRectifyNum = 0;//未整改数目
|
int totalRectifyNum = 0;//整改总条数（已整改数目+未整改数目）
|
String rectifyRate = "暂无";//整改率
|
|
int onTimeRectifyNum = 0;//按期整改数
|
String onTimeRectifyRate = "暂无";//按期率
|
int overdueRectifyNum = 0;//超期整改数
|
String overdueRectifyRate = "暂无";//超期率
|
for (HiddenDangerCheckPoint hdcp : resultListAll) {
|
if (!StringUtils.isEmpty(hdcp.getStage())) {
|
if ("3".equals(hdcp.getStage())) {
|
if (!StringUtil.isEmpty(hdcp.getExamineStatus())) {
|
if ("0".equals(hdcp.getExamineStatus())) {
|
notRectifyNum++;
|
}
|
}
|
}else if ("4".equals(hdcp.getStage())) {
|
if (!StringUtil.isEmpty(hdcp.getRectifyStatus())) {
|
if ("0".equals(hdcp.getRectifyStatus())) {
|
notRectifyNum++;
|
}
|
}
|
} else if ("5".equals(hdcp.getStage())) {
|
if (!StringUtil.isEmpty(hdcp.getAcceptStatus())) {
|
rectifyNum++;
|
SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd");
|
try {
|
if (f.parse(f.format(hdcp.getRectifyDeadlineTime())).before(f.parse(f.format(hdcp.getRectifyCompleteTime())))){
|
overdueRectifyNum++;
|
} else {
|
onTimeRectifyNum++;
|
}
|
} catch (ParseException e) {
|
}
|
}
|
}
|
}
|
}
|
totalDangerNum = resultListAll.size();
|
totalRectifyNum = rectifyNum + notRectifyNum;
|
if(totalDangerNum>0) {
|
//计算整改率
|
BigDecimal a = divide(rectifyNum , totalDangerNum,4);
|
//下面将结果转化成百分比
|
NumberFormat percent1 = NumberFormat.getPercentInstance();
|
percent1.setMaximumFractionDigits(2);
|
rectifyRate = percent1.format(a.doubleValue());
|
|
//计算按期率
|
BigDecimal b = divide(onTimeRectifyNum , totalDangerNum,4);
|
//下面将结果转化成百分比
|
NumberFormat percent2 = NumberFormat.getPercentInstance();
|
percent2.setMaximumFractionDigits(2);
|
onTimeRectifyRate = percent2.format(b.doubleValue());
|
|
|
//计算超期率
|
BigDecimal c = divide(overdueRectifyNum , totalDangerNum,4);
|
//下面将结果转化成百分比
|
NumberFormat percent3 = NumberFormat.getPercentInstance();
|
percent3.setMaximumFractionDigits(2);
|
overdueRectifyRate = percent3.format(c.doubleValue());
|
}
|
resultMap.put("totalDangerNum", totalDangerNum);
|
resultMap.put("rectifyNum", rectifyNum);
|
resultMap.put("notRectifyNum", notRectifyNum);
|
resultMap.put("rectifyRate", rectifyRate);
|
resultMap.put("onTimeRectifyNum", onTimeRectifyNum);
|
resultMap.put("onTimeRectifyRate", onTimeRectifyRate);
|
resultMap.put("overdueRectifyNum", overdueRectifyNum);
|
resultMap.put("overdueRectifyRate", overdueRectifyRate);
|
|
|
|
String monthOnMonthRate = "";//环比-------（上个月 - 上上个月）/上上个月
|
String yearOnYearRate = "";//同比-------（上个月 - 去年上个月）/去年上个月
|
|
Map map1 = getLastMonthTime(0,-1);//上个月
|
|
Map map2 = getLastMonthTime(0,-2);//上上个月
|
|
Map map3 = getLastMonthTime(-1,-1);//去年上个月
|
|
|
queryByTime.setParams(map1);
|
List<HiddenDangerCheckPoint> list1 = hdcpService.selectHiddenDangerCheckPointList(queryByTime);//上个月
|
queryByTime.setParams(map2);
|
List<HiddenDangerCheckPoint> list2 = hdcpService.selectHiddenDangerCheckPointList(queryByTime);//上上个月
|
queryByTime.setParams(map3);
|
List<HiddenDangerCheckPoint> list3 = hdcpService.selectHiddenDangerCheckPointList(queryByTime);//去年上个月
|
|
|
//计算环比
|
if(list2.size()>0) {
|
BigDecimal d = divide((list1.size() - list2.size()) , list2.size(),4);
|
//下面将结果转化成百分比
|
NumberFormat percent4 = NumberFormat.getPercentInstance();
|
percent4.setMaximumFractionDigits(2);
|
monthOnMonthRate = percent4.format(d.doubleValue());
|
}else{
|
monthOnMonthRate = "暂无";
|
}
|
|
|
//计算同比
|
if(list3.size()>0) {
|
BigDecimal e = divide((list1.size() - list3.size()) , list3.size(),4);
|
//下面将结果转化成百分比
|
NumberFormat percent5 = NumberFormat.getPercentInstance();
|
percent5.setMaximumFractionDigits(2);
|
yearOnYearRate = percent5.format(e.doubleValue());
|
}else{
|
yearOnYearRate = "暂无";
|
}
|
|
resultMap.put("monthOnMonthRate", monthOnMonthRate);
|
resultMap.put("yearOnYearRate", yearOnYearRate);
|
return ApiResult.success("请求数据成功", resultMap);
|
} catch (Exception e) {
|
return ApiResult.error("异常");
|
}
|
}
|
|
|
|
|
/**
|
* 除法（需要给定小数位数）
|
* @param i1 操作数1
|
* @param i2 操作数2
|
* @return
|
*/
|
public static BigDecimal divide(int i1, int i2,int scale) {
|
BigDecimal b1 = new BigDecimal(i1);
|
BigDecimal b2 = new BigDecimal(i2);
|
if(b1 == null) {
|
return new BigDecimal(0);
|
}
|
if(b2 == null || equals(b2,new BigDecimal(0))){
|
throw new ArithmeticException("b2 is zero ! ");
|
}
|
return b1.divide(b2, scale, RoundingMode.DOWN);
|
}
|
|
|
/**
|
* 等于
|
* @param b1 操作数1
|
* @param b2 操作数2
|
* @return 结果
|
*/
|
public static boolean equals(BigDecimal b1, BigDecimal b2) {
|
if (b1 == null) {
|
b1 = new BigDecimal(0);
|
}
|
if (b2 == null) {
|
b2 = new BigDecimal(0);
|
}
|
return b1.compareTo(b2) == 0;
|
}
|
|
|
/**
|
* 获得近一周的开始时间和结束时间
|
* @return
|
*/
|
public static Map getDaySevenRange(){
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
Map condition=new HashMap();
|
Calendar calendar = Calendar.getInstance();
|
calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
|
calendar.set(Calendar.HOUR_OF_DAY,24);
|
condition.put("endTime",sdf.format(calendar.getTime()));
|
calendar.set(Calendar.HOUR_OF_DAY,-168);
|
condition.put("beginTime",sdf.format(calendar.getTime()));
|
return condition;
|
}
|
|
/**
|
* 获得近一月的开始时间和结束时间
|
* @return
|
*/
|
public static Map getMonthRange(){
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
Map condition=new HashMap();
|
Calendar calendar = Calendar.getInstance();
|
calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
|
calendar.set(Calendar.HOUR_OF_DAY,24);
|
condition.put("endTime",sdf.format(calendar.getTime()));
|
calendar.add(Calendar.MONTH,-1);
|
condition.put("beginTime",sdf.format(calendar.getTime()));
|
return condition;
|
}
|
|
/**
|
* 获得近一年的开始时间和结束时间
|
* @return
|
*/
|
public static Map getYearRange(){
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
Map condition=new HashMap();
|
Calendar calendar = Calendar.getInstance();
|
calendar.set(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH), calendar.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
|
calendar.set(Calendar.HOUR_OF_DAY,24);
|
condition.put("endTime",sdf.format(calendar.getTime()));
|
calendar.add(Calendar.YEAR,-1);
|
condition.put("beginTime",sdf.format(calendar.getTime()));
|
return condition;
|
}
|
|
|
|
|
|
|
/**
|
* 获取某个月月开始时间和结束时间
|
* year -1代表去年
|
* month -1代表上月，-2代表上上月
|
* @return
|
*/
|
public static Map getLastMonthTime(int year,int month) {
|
Calendar c=Calendar.getInstance();
|
c.add(Calendar.YEAR, year);
|
c.add(Calendar.MONTH, month);
|
SimpleDateFormat sdfLast = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
int lastMonthMaxDay=c.getActualMaximum(Calendar.DAY_OF_MONTH);
|
c.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), lastMonthMaxDay, 23, 59, 59);
|
String endTimeStr = sdfLast.format(c.getTime()); //上月最后一天
|
SimpleDateFormat sdfFirst = new SimpleDateFormat("yyyy-MM-01 00:00:00");
|
String startTimeStr = sdfFirst.format(c.getTime()); //上月第一天
|
|
Map map = new HashMap();
|
map.put("beginTime", startTimeStr);
|
map.put("endTime", endTimeStr);
|
return map;
|
}
|
|
|
}
|
