src/main/java/com/ruoyi/common/utils/BeanCopyUtils.java
对比新文件 @@ -0,0 +1,55 @@ package com.ruoyi.common.utils; import org.springframework.beans.BeanUtils; import java.util.List; import java.util.stream.Collectors; public class BeanCopyUtils { private BeanCopyUtils() { } /**练习 public static Object copyBean(Object source, Class clazz) { //创建目标对象 Object result = null; try { result = clazz.newInstance(); //实现属性copy BeanUtils.copyProperties(source, result); } catch (Exception e) { e.printStackTrace(); } //返回结果 return result; }*/ public static <V> V copyBean(Object source,Class<V> clazz) { //创建目标对象 V result = null; try { result = clazz.newInstance(); //实现属性copy BeanUtils.copyProperties(source, result); } catch (Exception e) { e.printStackTrace(); } //返回结果 return result; } /**练习 * public static <V> List<V> copyBeanList(List<Object> list, Class<V> clazz){ return list.stream() .map(o -> copyBean(o, clazz)) .collect(Collectors.toList()); }*/ public static <O,V> List<V> copyBeanList(List<O> list, Class<V> clazz){ return list.stream() .map(o -> copyBean(o, clazz)) .collect(Collectors.toList()); } } src/main/java/com/ruoyi/doublePrevention/entity/PreventRiskCheckUnit.java
@@ -29,6 +29,7 @@ * */ private Long riskId; public Long getId() { return id; } src/main/java/com/ruoyi/doublePrevention/entity/PreventRiskDangerCheckAndMeasure.java
对比新文件 @@ -0,0 +1,97 @@ package com.ruoyi.doublePrevention.entity; import com.baomidou.mybatisplus.annotation.IdType; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import java.util.Date; @TableName("prevent_risk_danger_check_and_measure") public class PreventRiskDangerCheckAndMeasure { /** * 主键 * */ @TableId(value = "id" , type = IdType.AUTO) private Long id; /** * 核查任务id * */ private Long checkId; /** * 核查任务附属表id * */ private Long dangerCheckPointId; /** * 核查点id * */ private Long baseCheckPointId; /** * 管控措施id * */ private Long controlMeasureId; /** * job id * */ private String checkContent; /** * 排查结果：0-正常，1-存在隐患，2-未处理，3其他 * */ private Byte checkResult; public Long getId() { return id; } public void setId(Long id) { this.id = id; } public Long getDangerCheckPointId() { return dangerCheckPointId; } public void setDangerCheckPointId(Long dangerCheckPointId) { this.dangerCheckPointId = dangerCheckPointId; } public Long getCheckId() { return checkId; } public void setCheckId(Long checkId) { this.checkId = checkId; } public Long getBaseCheckPointId() { return baseCheckPointId; } public void setBaseCheckPointId(Long baseCheckPointId) { this.baseCheckPointId = baseCheckPointId; } public Long getControlMeasureId() { return controlMeasureId; } public void setControlMeasureId(Long controlMeasureId) { this.controlMeasureId = controlMeasureId; } public String getCheckContent() { return checkContent; } public void setCheckContent(String checkContent) { this.checkContent = checkContent; } public Byte getCheckResult() { return checkResult; } public void setCheckResult(Byte checkResult) { this.checkResult = checkResult; } } src/main/java/com/ruoyi/doublePrevention/entity/PreventRiskDangerCheckLog.java
对比新文件 @@ -0,0 +1,121 @@ package com.ruoyi.doublePrevention.entity; import com.baomidou.mybatisplus.annotation.IdType; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import java.util.Date; @TableName("prevent_risk_danger_check_log") public class PreventRiskDangerCheckLog { /** * 主键 * */ @TableId(value = "id" , type = IdType.AUTO) private Long id; /** * uuid * */ private String uuid; /** * 排查任务id * */ private Long checkId; /** * 排查结果：0-正常，1-存在隐患，2-未处理，3其他 * */ private Byte checkStatus; /** * job id * */ private Long jobId; /** * 同步时间 */ private Date reportTime; /** * 同步数据修改时间 */ private Date updateReportDataTime; /** * 上报状态 1-待上报；2-已上报；3-不上报；4-变更需上传 */ private Byte reportStatus; /** * 上报开关 1-上报；2-不上报 */ private Byte reportSwitch; public Long getCheckId() { return checkId; } public void setCheckId(Long checkId) { this.checkId = checkId; } public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getUuid() { return uuid; } public void setUuid(String uuid) { this.uuid = uuid; } public Byte getCheckStatus() { return checkStatus; } public void setCheckStatus(Byte checkStatus) { this.checkStatus = checkStatus; } public Long getJobId() { return jobId; } public void setJobId(Long jobId) { this.jobId = jobId; } public Date getReportTime() { return reportTime; } public void setReportTime(Date reportTime) { this.reportTime = reportTime; } public Date getUpdateReportDataTime() { return updateReportDataTime; } public void setUpdateReportDataTime(Date updateReportDataTime) { this.updateReportDataTime = updateReportDataTime; } public Byte getReportStatus() { return reportStatus; } public void setReportStatus(Byte reportStatus) { this.reportStatus = reportStatus; } public Byte getReportSwitch() { return reportSwitch; } public void setReportSwitch(Byte reportSwitch) { this.reportSwitch = reportSwitch; } } src/main/java/com/ruoyi/doublePrevention/entity/PreventRiskDangerInfo.java
对比新文件 @@ -0,0 +1,188 @@ package com.ruoyi.doublePrevention.entity; import com.baomidou.mybatisplus.annotation.IdType; import com.baomidou.mybatisplus.annotation.TableId; import java.util.Date; public class PreventRiskDangerInfo { /** * 主键 * */ @TableId(value = "id" , type = IdType.AUTO) private Long id; /** * Uuid * */ private String Uuid; /** * 核查任务附属表id * */ private Long dangerCheckPointId; /** * hazard_code 风先分析对象编码（风险分析单元编码） * */ private String hazardCode; /** * 隐患来源 * 1-日常排查；2-综合性排查；3-专业性排查;4-季节性排查；5-重点时段及节假日前排查 * 6-事故类比排查；7-复产复工前排查;8-外聘专家诊断式排查；9-管控措施实效;10-其他；11-政府执法检查 * */ private Byte dangerSrc; /** * 隐患描述 * */ private String dangerDesc; /** * 隐患产生的原因 * */ private String dangerReason; /** * 隐患类型 * 1-安全；2-工艺；3-电气；4-仪表 * 5-消防；6-总图；7-设备；8其他 * */ private Byte hazardDangerType; /** * 隐患状态 * 0-整改中 * 1-待验收 * 2-延期整改 * 3-超期未整改 * 9-已验收 */ private Byte dangerState; /** * 延期标识 1-正常；2-延期； * */ private Byte timeoutFlag; /** * 同步时间 */ private Date reportTime; /** * 同步数据修改时间 */ private Date updateReportDataTime; /** * 上报状态 1-待上报；2-已上报；3-不上报；4-变更需上传 */ private Byte reportStatus; /** * 上报开关 1-上报；2-不上报 */ private Byte reportSwitch; public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getUuid() { return Uuid; } public void setUuid(String uuid) { Uuid = uuid; } public Long getDangerCheckPointId() { return dangerCheckPointId; } public void setDangerCheckPointId(Long dangerCheckPointId) { this.dangerCheckPointId = dangerCheckPointId; } public String getHazardCode() { return hazardCode; } public void setHazardCode(String hazardCode) { this.hazardCode = hazardCode; } public Byte getDangerSrc() { return dangerSrc; } public void setDangerSrc(Byte dangerSrc) { this.dangerSrc = dangerSrc; } public String getDangerDesc() { return dangerDesc; } public void setDangerDesc(String dangerDesc) { this.dangerDesc = dangerDesc; } public String getDangerReason() { return dangerReason; } public void setDangerReason(String dangerReason) { this.dangerReason = dangerReason; } public Byte getHazardDangerType() { return hazardDangerType; } public void setHazardDangerType(Byte hazardDangerType) { this.hazardDangerType = hazardDangerType; } public Byte getDangerState() { return dangerState; } public void setDangerState(Byte dangerState) { this.dangerState = dangerState; } public Byte getTimeoutFlag() { return timeoutFlag; } public void setTimeoutFlag(Byte timeoutFlag) { this.timeoutFlag = timeoutFlag; } public Date getReportTime() { return reportTime; } public void setReportTime(Date reportTime) { this.reportTime = reportTime; } public Date getUpdateReportDataTime() { return updateReportDataTime; } public void setUpdateReportDataTime(Date updateReportDataTime) { this.updateReportDataTime = updateReportDataTime; } public Byte getReportStatus() { return reportStatus; } public void setReportStatus(Byte reportStatus) { this.reportStatus = reportStatus; } public Byte getReportSwitch() { return reportSwitch; } public void setReportSwitch(Byte reportSwitch) { this.reportSwitch = reportSwitch; } } src/main/java/com/ruoyi/doublePrevention/entity/PreventRiskJobAndMeasure.java
对比新文件 @@ -0,0 +1,121 @@ package com.ruoyi.doublePrevention.entity; import com.baomidou.mybatisplus.annotation.IdType; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import java.util.Date; @TableName("prevent_risk_job_and_measure") public class PreventRiskJobAndMeasure { /** * 主键 * */ @TableId(value = "id" , type = IdType.AUTO) private Long id; /** * job ID * */ private Long jobId; /** * job uuid * */ private String jobUuid; /** * 管控措施 ID * */ private Long measureId; /** * 管控措施 uuid * */ private String measureUuid; /** * 同步时间 */ private Date reportTime; /** * 同步数据修改时间 */ private Date updateReportDataTime; /** * 上报状态 1-待上报；2-已上报；3-不上报；4-变更需上传 */ private Byte reportStatus; /** * 上报开关 1-上报；2-不上报 */ private Byte reportSwitch; public Long getId() { return id; } public void setId(Long id) { this.id = id; } public Long getJobId() { return jobId; } public void setJobId(Long jobId) { this.jobId = jobId; } public String getJobUuid() { return jobUuid; } public void setJobUuid(String jobUuid) { this.jobUuid = jobUuid; } public Long getMeasureId() { return measureId; } public void setMeasureId(Long measureId) { this.measureId = measureId; } public String getMeasureUuid() { return measureUuid; } public void setMeasureUuid(String measureUuid) { this.measureUuid = measureUuid; } public Date getReportTime() { return reportTime; } public void setReportTime(Date reportTime) { this.reportTime = reportTime; } public Date getUpdateReportDataTime() { return updateReportDataTime; } public void setUpdateReportDataTime(Date updateReportDataTime) { this.updateReportDataTime = updateReportDataTime; } public Byte getReportStatus() { return reportStatus; } public void setReportStatus(Byte reportStatus) { this.reportStatus = reportStatus; } public Byte getReportSwitch() { return reportSwitch; } public void setReportSwitch(Byte reportSwitch) { this.reportSwitch = reportSwitch; } } src/main/java/com/ruoyi/doublePrevention/entity/PreventRiskUnitUuid.java
@@ -4,6 +4,8 @@ import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import java.util.Date; @TableName("prevent_risk_unit_uuid") public class PreventRiskUnitUuid { @@ -21,16 +23,52 @@ * */ private String riskUnitUuid; /** * 删除标识 * */ private Byte deleteStatus; * 同步时间 */ private Date reportTime; /** * 同步数据修改时间 */ private Date updateReportDataTime; /** * 上报状态 1-待上报；2-已上报；3-不上报；4-变更需上传 */ private Byte reportStatus; /** * 上报开关 1-上报；2-不上报 */ private Byte reportSwitch; public Byte getDeleteStatus() { return deleteStatus; public Date getReportTime() { return reportTime; } public void setDeleteStatus(Byte deleteStatus) { this.deleteStatus = deleteStatus; public void setReportTime(Date reportTime) { this.reportTime = reportTime; } public Date getUpdateReportDataTime() { return updateReportDataTime; } public void setUpdateReportDataTime(Date updateReportDataTime) { this.updateReportDataTime = updateReportDataTime; } public Byte getReportStatus() { return reportStatus; } public void setReportStatus(Byte reportStatus) { this.reportStatus = reportStatus; } public Byte getReportSwitch() { return reportSwitch; } public void setReportSwitch(Byte reportSwitch) { this.reportSwitch = reportSwitch; } public Long getId() { src/main/java/com/ruoyi/doublePrevention/entity/dto/resp/PreventRiskCheckUnitRespDTO.java
对比新文件 @@ -0,0 +1,265 @@ package com.ruoyi.doublePrevention.entity.dto.resp; import com.ruoyi.doublePrevention.entity.PreventRiskControlMeasure; import com.ruoyi.framework.aspectj.lang.annotation.Excel; import java.util.List; public class PreventRiskCheckUnitRespDTO { /** id */ private Long riskListId; /** 风险单元编号 */ private String riskListNum; /** 风险单元名称 */ private String riskListName; /** 是否特种(1否,2是) */ @Excel(name = "是否特种",readConverterExp = "1=否,2=是") private Long riskListIsSpecial; /** 图片 */ private String riskListImgUrl; /** 设备设施类型 */ private Long riskListDeviceType; /** 规格/型号 */ private String riskListDeviceModel; /** 作业活动类型 */ private Long riskListWorkType; /** 作业频率 */ private Long riskListWorkFrequency; private String riskListWorkFrequencyName; /** 工艺作业类型 */ private Long riskListCraftsType; /** * 风险单元类型名称,(包含设备设施类型名称,作业活动类型名称,工艺节点类型名称) */ private String riskTypeName; /** 节点描述 */ private String riskListCraftsDescription; /** 区域/位置 */ private Long regionId; /** 区域/位置名称 */ private String regionName; /** 管辖单位/部门 */ private Long deptId; /** 管辖部门名称 */ private String deptName; /** 负责人 */ private Long userId; /** 负责人名称 */ private String userName; /** 风险单元类型(1设备设置,2作业活动,3工艺节点) */ @Excel(name = "风险单元类型", readConverterExp = "1=设备设施,2=作业活动,3=工艺节点,4=基础清单,5=区域/作业场所") private Integer riskType; /** 所属公司 */ private Long companyId; /**已评价计划数 如作为查询条件 0 代表未评价, 1 代表已评价 */ private Integer isEvaluation; private List<PreventRiskControlMeasure> riskControlMeasures; public Long getRiskListId() { return riskListId; } public void setRiskListId(Long riskListId) { this.riskListId = riskListId; } public String getRiskListNum() { return riskListNum; } public void setRiskListNum(String riskListNum) { this.riskListNum = riskListNum; } public String getRiskListName() { return riskListName; } public void setRiskListName(String riskListName) { this.riskListName = riskListName; } public Long getRiskListIsSpecial() { return riskListIsSpecial; } public void setRiskListIsSpecial(Long riskListIsSpecial) { this.riskListIsSpecial = riskListIsSpecial; } public String getRiskListImgUrl() { return riskListImgUrl; } public void setRiskListImgUrl(String riskListImgUrl) { this.riskListImgUrl = riskListImgUrl; } public Long getRiskListDeviceType() { return riskListDeviceType; } public void setRiskListDeviceType(Long riskListDeviceType) { this.riskListDeviceType = riskListDeviceType; } public String getRiskListDeviceModel() { return riskListDeviceModel; } public void setRiskListDeviceModel(String riskListDeviceModel) { this.riskListDeviceModel = riskListDeviceModel; } public Long getRiskListWorkType() { return riskListWorkType; } public void setRiskListWorkType(Long riskListWorkType) { this.riskListWorkType = riskListWorkType; } public Long getRiskListWorkFrequency() { return riskListWorkFrequency; } public void setRiskListWorkFrequency(Long riskListWorkFrequency) { this.riskListWorkFrequency = riskListWorkFrequency; } public String getRiskListWorkFrequencyName() { return riskListWorkFrequencyName; } public void setRiskListWorkFrequencyName(String riskListWorkFrequencyName) { this.riskListWorkFrequencyName = riskListWorkFrequencyName; } public Long getRiskListCraftsType() { return riskListCraftsType; } public void setRiskListCraftsType(Long riskListCraftsType) { this.riskListCraftsType = riskListCraftsType; } public String getRiskTypeName() { return riskTypeName; } public void setRiskTypeName(String riskTypeName) { this.riskTypeName = riskTypeName; } public String getRiskListCraftsDescription() { return riskListCraftsDescription; } public void setRiskListCraftsDescription(String riskListCraftsDescription) { this.riskListCraftsDescription = riskListCraftsDescription; } public Long getRegionId() { return regionId; } public void setRegionId(Long regionId) { this.regionId = regionId; } public String getRegionName() { return regionName; } public void setRegionName(String regionName) { this.regionName = regionName; } public Long getDeptId() { return deptId; } public void setDeptId(Long deptId) { this.deptId = deptId; } public String getDeptName() { return deptName; } public void setDeptName(String deptName) { this.deptName = deptName; } public Long getUserId() { return userId; } public void setUserId(Long userId) { this.userId = userId; } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } public Integer getRiskType() { return riskType; } public void setRiskType(Integer riskType) { this.riskType = riskType; } public Long getCompanyId() { return companyId; } public void setCompanyId(Long companyId) { this.companyId = companyId; } public Integer getIsEvaluation() { return isEvaluation; } public void setIsEvaluation(Integer isEvaluation) { this.isEvaluation = isEvaluation; } public List<PreventRiskControlMeasure> getRiskControlMeasures() { return riskControlMeasures; } public void setRiskControlMeasures(List<PreventRiskControlMeasure> riskControlMeasures) { this.riskControlMeasures = riskControlMeasures; } } src/main/java/com/ruoyi/doublePrevention/enums/StatusEnum.java
@@ -7,6 +7,8 @@ DELETE_STATUS_USE((byte) 0, "正常"), DELETE_STATUS_DISCARD((byte) 1, "删除"), EXEC_FAIL((byte) 0, "操作失败"), EXEC_SUCCESS((byte) 1, "操作成功"), ; byte code; @JsonValue src/main/java/com/ruoyi/doublePrevention/repository/PreventRiskCheckUnitRepository.java
@@ -1,7 +1,10 @@ package com.ruoyi.doublePrevention.repository; import com.ruoyi.doublePrevention.entity.PreventRiskCheckUnit; import com.ruoyi.project.tr.baseCheckPoint.domain.BaseCheckPoint; import org.springframework.stereotype.Repository; import java.util.List; @Repository public interface PreventRiskCheckUnitRepository { @@ -11,18 +14,13 @@ */ int insertPointAndMeasure(PreventRiskCheckUnit checkUnit); List<PreventRiskCheckUnit> getUnitByRiskId(String riskId); /** * @description 根据原检查点id查询原检查点与管控措施对应的单条记录 * 删除原检查点与管控措施的对应关系 */ PreventRiskCheckUnit getPointAndMeasureByPointId(Long checkPointId); int deletePointAndMeasure(String id); /** * @description 根据id对相关记录进行修改 * 通过baseCheckPointId 查询管控措施列表 */ int updateRiskCheckUnitById(PreventRiskCheckUnit riskCheckUnit); /** * @description 根据原检查点批量删除 原检查点与管控措施对应的多条记录 */ int deleteRiskCheckUnitByCheckPointIds(String[] checkPointIds); PreventRiskCheckUnit getUnitByBaseCheckPointId(Long baseCheckPointId); } src/main/java/com/ruoyi/doublePrevention/repository/PreventRiskDangerCheckAndMeasureRepository.java
对比新文件 @@ -0,0 +1,13 @@ package com.ruoyi.doublePrevention.repository; import com.ruoyi.doublePrevention.entity.PreventRiskDangerCheckAndMeasure; import org.springframework.stereotype.Repository; @Repository public interface PreventRiskDangerCheckAndMeasureRepository { /** * 写入核查任务检查点与管控措施信息 * */ int insertCheckAndMeasure(PreventRiskDangerCheckAndMeasure checkAndMeasure); } src/main/java/com/ruoyi/doublePrevention/repository/PreventRiskDangerCheckLogRepository.java
对比新文件 @@ -0,0 +1,17 @@ package com.ruoyi.doublePrevention.repository; import com.ruoyi.doublePrevention.entity.PreventRiskDangerCheckLog; import org.springframework.stereotype.Repository; @Repository public interface PreventRiskDangerCheckLogRepository { /** * 定时生成排查任务记录时， * 插入排查记录附属表 */ int insertDangerCheckLog(PreventRiskDangerCheckLog dangerCheck); /** * 删除定时核查任务 * */ int deleteDangerCheck(Long checkId); } src/main/java/com/ruoyi/doublePrevention/repository/PreventRiskDangerInfoRepository.java
对比新文件 @@ -0,0 +1,19 @@ package com.ruoyi.doublePrevention.repository; import com.ruoyi.doublePrevention.entity.PreventRiskDangerInfo; import org.springframework.stereotype.Repository; @Repository public interface PreventRiskDangerInfoRepository { /** * 新增隐患上报 * */ int insertDangerInfo(PreventRiskDangerInfo dangerInfo); /** * 修改隐患上报 * */ int updateDangerInfo(PreventRiskDangerInfo dangerInfo); int deleteDangerInfo(Long id); } src/main/java/com/ruoyi/doublePrevention/repository/PreventRiskJobAndMeasureRepository.java
对比新文件 @@ -0,0 +1,22 @@ package com.ruoyi.doublePrevention.repository; import com.ruoyi.doublePrevention.entity.PreventRiskJobAndMeasure; import org.springframework.stereotype.Repository; @Repository public interface PreventRiskJobAndMeasureRepository { /** * 插入管控措施与job的对应关系 * */ int insertJobAndMeasure(PreventRiskJobAndMeasure jobAndMeasure); /** * 查询JobAndMeasure - By JobId */ PreventRiskJobAndMeasure getJobAndMeasureByJobId(Long jobId); /** * 删除job管控措施的附属表关联信息 */ int deleteJobAndMeasure(Long jobId); } src/main/java/com/ruoyi/doublePrevention/repository/PreventRiskUnitUuidRepository.java
@@ -14,4 +14,12 @@ * 通过id获取uuid * */ PreventRiskUnitUuid getRiskUnitUuidById(Long id); /** * 修改 * */ int updateRiskUnitUuid(PreventRiskUnitUuid riskUnitUuid); /** * 删除附属表信息 */ int deleteRiskUnit(String[] riskListIds); } src/main/java/com/ruoyi/doublePrevention/service/RiskService.java
@@ -2,13 +2,17 @@ import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.ruoyi.doublePrevention.entity.PreventRiskCheckUnit; import com.ruoyi.doublePrevention.entity.PreventRiskControlMeasure; import com.ruoyi.doublePrevention.entity.PreventRiskEvent; import com.ruoyi.doublePrevention.entity.PreventRiskJobAndMeasure; import com.ruoyi.doublePrevention.entity.dto.req.*; import com.ruoyi.doublePrevention.entity.dto.resp.*; import com.ruoyi.doublePrevention.repository.param.PreventPointAndMeasureParams; import com.ruoyi.doublePrevention.vo.ResultVO; import com.ruoyi.project.tr.HiddenDangerCheckJob.domain.HiddenDangerCheckJob; import com.ruoyi.project.tr.baseCheckPoint.domain.BaseCheckPoint; import com.ruoyi.project.tr.hiddenDangerCheck.domain.HiddenDangerCheck; import com.ruoyi.project.tr.hiddenDangerCheckPoint.domain.HiddenDangerCheckPoint; import com.ruoyi.project.tr.riskList.domain.RiskList; import java.util.List; @@ -18,7 +22,14 @@ * 为设施设备清单附属表添加uuid * */ int insertRiskUnitUuid(Long id); /** * 修改风险清单附属表 */ int updateRiskUnit(Long riskListId); /** * 删除附属表信息 */ int deleteRiskUnit(String ids); /** * 风险事件-新增 */ @@ -78,15 +89,59 @@ * 管控措施-分页查询 */ ResultVO<List<PreventRiskControlMeasurePageQueryRespDTO>> getRiskControlMeasurePage(PreventRiskControlMeasureQueryReqDTO measureQueryReqDTO); /** * 查询管控措施 by 基础排查清单ID */ List<PreventRiskControlMeasure> getRiskControlMeasureByRiskId(Long riskListId); /** * 保存原检查点与管控措施的对应关系 */ int insertPointAndMeasure(PreventPointAndMeasureParams pointAndMeasureParams); /** * 删除原检查点与管控措施的对应关系 */ int deletePointAndMeasure(String ids); /** * 保存job管控措施的附属表 */ int insertJobAndMeasure(Long jobId); /** * 修改job管控措施的附属表 */ int updateJobAndMeasure(HiddenDangerCheckJob hiddenDangerCheckJob); /** * 删除job管控措施的附属表 */ int deleteJobAndMeasure(String ids); /** * 查询Job与措施 */ PreventRiskJobAndMeasure getJobAndMeasure(Long jobId); /** * 定时生成排查任务记录时， * 插入排查记录附属表 */ int insertDangerCheckLog(Long checkId, HiddenDangerCheck hdc); /** * 定时生成排查任务记录时， * 插入检查点附属表 */ void insertCheckAndMeasure(Long id, HiddenDangerCheckPoint hdcp); /** * 删除定时核查任务 * */ int deleteDangerCheck(String ids); /** * @description 根据原检查点查询 原检查点与管控措施对应记录 * 新增隐患上报 * */ int insertDangerInfo(Long id, HiddenDangerCheckPoint hdcp); /** * 修改隐患上报 * */ int updateDangerInfo(HiddenDangerCheckPoint hiddenDangerCheckPoint); /** * 删除隐患上报 */ PreventRiskCheckUnit getRiskUnitByBaseCheckPointId(Long checkPointId); int deleteDangerInfo(Long id); } src/main/java/com/ruoyi/doublePrevention/service/baseService/PreventRiskCheckUnitService.java
@@ -1,7 +1,10 @@ package com.ruoyi.doublePrevention.service.baseService; import com.ruoyi.doublePrevention.entity.PreventRiskCheckUnit; import com.ruoyi.project.tr.baseCheckPoint.domain.BaseCheckPoint; import org.springframework.stereotype.Repository; import java.util.List; @Repository public interface PreventRiskCheckUnitService { @@ -10,9 +13,18 @@ * 保存原检查点与管控措施的对应关系 */ int insertPointAndMeasure(PreventRiskCheckUnit checkUnit); /** * 通过riskId 查询管控措施列表 */ List<PreventRiskCheckUnit> getUnitByRiskId(String riskId); /** * @description 根据原检查点查询 原检查点与管控措施对应记录 * 删除原检查点与管控措施的对应关系 */ PreventRiskCheckUnit getRiskUnitByBaseCheckPointId(Long checkPointId); int deletePointAndMeasure(String id); /** * 通过baseCheckPointId 查询管控措施列表 */ PreventRiskCheckUnit getUnitByBaseCheckPointId(Long baseCheckPointId); } src/main/java/com/ruoyi/doublePrevention/service/baseService/PreventRiskDangerCheckAndMeasureService.java
对比新文件 @@ -0,0 +1,11 @@ package com.ruoyi.doublePrevention.service.baseService; import com.ruoyi.doublePrevention.entity.PreventRiskDangerCheckAndMeasure; public interface PreventRiskDangerCheckAndMeasureService { /** * 写入核查任务检查点与管控措施信息 * */ int insertCheckAndMeasure(PreventRiskDangerCheckAndMeasure checkAndMeasure); } src/main/java/com/ruoyi/doublePrevention/service/baseService/PreventRiskDangerCheckLogService.java
对比新文件 @@ -0,0 +1,15 @@ package com.ruoyi.doublePrevention.service.baseService; import com.ruoyi.doublePrevention.entity.PreventRiskDangerCheckLog; public interface PreventRiskDangerCheckLogService { /** * 定时生成排查任务记录时， * 插入排查记录附属表 */ int insertDangerCheckLog(PreventRiskDangerCheckLog dangerCheck); /** * 删除定时核查任务 * */ int deleteDangerCheck(Long checkId); } src/main/java/com/ruoyi/doublePrevention/service/baseService/PreventRiskDangerInfoService.java
对比新文件 @@ -0,0 +1,19 @@ package com.ruoyi.doublePrevention.service.baseService; import com.ruoyi.doublePrevention.entity.PreventRiskDangerInfo; public interface PreventRiskDangerInfoService { /** * 新增隐患上报 * */ int insertDangerInfo(PreventRiskDangerInfo dangerInfo); /** * 修改隐患上报 * */ int updateDangerInfo(PreventRiskDangerInfo dangerInfo); /** * 删除隐患上报 */ int deleteDangerInfo(Long id); } src/main/java/com/ruoyi/doublePrevention/service/baseService/PreventRiskJobAndMeasureService.java
对比新文件 @@ -0,0 +1,19 @@ package com.ruoyi.doublePrevention.service.baseService; import com.ruoyi.doublePrevention.entity.PreventRiskJobAndMeasure; public interface PreventRiskJobAndMeasureService { /** * 插入管控措施与job的对应关系 * */ int insertJobAndMeasure(PreventRiskJobAndMeasure jobAndMeasure); /** * 查询JobAndMeasure - By JobId */ PreventRiskJobAndMeasure getJobAndMeasureByJobId(Long jobId); /** * 删除job管控措施的附属表关联信息 */ int deleteJobAndMeasure(Long jobId); } src/main/java/com/ruoyi/doublePrevention/service/baseService/PreventRiskUnitUuidService.java
@@ -12,4 +12,12 @@ * 通过id获取uuid * */ PreventRiskUnitUuid getRiskUnitUuidById(Long id); /** * 修改 * */ int updateRiskUnitUuid(PreventRiskUnitUuid riskUnitUuid); /** * 删除附属表信息 */ int deleteRiskUnit(String[] riskListIds); } src/main/java/com/ruoyi/doublePrevention/service/baseService/impl/PreventRiskCheckUnitServiceImpl.java
@@ -3,8 +3,11 @@ import com.ruoyi.doublePrevention.entity.PreventRiskCheckUnit; import com.ruoyi.doublePrevention.repository.PreventRiskCheckUnitRepository; import com.ruoyi.doublePrevention.service.baseService.PreventRiskCheckUnitService; import com.ruoyi.project.tr.baseCheckPoint.domain.BaseCheckPoint; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import java.util.List; @Service("PreventRiskCheckUnitService") public class PreventRiskCheckUnitServiceImpl implements PreventRiskCheckUnitService { @@ -18,12 +21,25 @@ public int insertPointAndMeasure(PreventRiskCheckUnit checkUnit) { return preventRiskCheckUnitRepository.insertPointAndMeasure(checkUnit); } /** * @description 根据远检查点获取原检查点与管控措施关联的记录 * 通过riskId 查询管控措施列表 */ @Override public PreventRiskCheckUnit getRiskUnitByBaseCheckPointId(Long checkPointId) { return preventRiskCheckUnitRepository.getPointAndMeasureByPointId(checkPointId); public List<PreventRiskCheckUnit> getUnitByRiskId(String riskId) { return preventRiskCheckUnitRepository.getUnitByRiskId(riskId); } /** * 删除原检查点与管控措施的对应关系 */ @Override public int deletePointAndMeasure(String id) { return preventRiskCheckUnitRepository.deletePointAndMeasure(id); } /** * 通过baseCheckPointId 查询管控措施列表 */ @Override public PreventRiskCheckUnit getUnitByBaseCheckPointId(Long baseCheckPointId) { return preventRiskCheckUnitRepository.getUnitByBaseCheckPointId(baseCheckPointId); } } src/main/java/com/ruoyi/doublePrevention/service/baseService/impl/PreventRiskDangerCheckAndMeasureServiceImpl.java
对比新文件 @@ -0,0 +1,22 @@ package com.ruoyi.doublePrevention.service.baseService.impl; import com.ruoyi.doublePrevention.entity.PreventRiskDangerCheckAndMeasure; import com.ruoyi.doublePrevention.repository.PreventRiskDangerCheckAndMeasureRepository; import com.ruoyi.doublePrevention.service.baseService.PreventRiskDangerCheckAndMeasureService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @Service("PreventRiskDangerCheckAndMeasureService") public class PreventRiskDangerCheckAndMeasureServiceImpl implements PreventRiskDangerCheckAndMeasureService { @Autowired private PreventRiskDangerCheckAndMeasureRepository preventRiskDangerCheckAndMeasureRepository; /** * 写入核查任务检查点与管控措施信息 * */ @Override public int insertCheckAndMeasure(PreventRiskDangerCheckAndMeasure checkAndMeasure) { return preventRiskDangerCheckAndMeasureRepository.insertCheckAndMeasure(checkAndMeasure); } } src/main/java/com/ruoyi/doublePrevention/service/baseService/impl/PreventRiskDangerCheckLogServiceImpl.java
对比新文件 @@ -0,0 +1,29 @@ package com.ruoyi.doublePrevention.service.baseService.impl; import com.ruoyi.doublePrevention.entity.PreventRiskDangerCheckLog; import com.ruoyi.doublePrevention.repository.PreventRiskDangerCheckLogRepository; import com.ruoyi.doublePrevention.service.baseService.PreventRiskDangerCheckLogService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @Service("PreventRiskDangerCheckLogService") public class PreventRiskDangerCheckLogServiceImpl implements PreventRiskDangerCheckLogService { @Autowired private PreventRiskDangerCheckLogRepository preventRiskDangerCheckLogRepository; /** * 定时生成排查任务记录时， * 插入排查记录附属表 */ @Override public int insertDangerCheckLog(PreventRiskDangerCheckLog dangerCheck) { return preventRiskDangerCheckLogRepository.insertDangerCheckLog(dangerCheck); } /** * 删除定时核查任务 * */ @Override public int deleteDangerCheck(Long checkId) { return preventRiskDangerCheckLogRepository.deleteDangerCheck(checkId); } } src/main/java/com/ruoyi/doublePrevention/service/baseService/impl/PreventRiskDangerInfoServiceImpl.java
对比新文件 @@ -0,0 +1,38 @@ package com.ruoyi.doublePrevention.service.baseService.impl; import com.ruoyi.doublePrevention.entity.PreventRiskDangerInfo; import com.ruoyi.doublePrevention.repository.PreventRiskDangerInfoRepository; import com.ruoyi.doublePrevention.service.baseService.PreventRiskDangerInfoService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @Service("PreventRiskDangerInfoService") public class PreventRiskDangerInfoServiceImpl implements PreventRiskDangerInfoService { @Autowired private PreventRiskDangerInfoRepository preventRiskDangerInfoRepository; /** * 新增隐患上报 * */ @Override public int insertDangerInfo(PreventRiskDangerInfo dangerInfo) { return preventRiskDangerInfoRepository.insertDangerInfo(dangerInfo); } /** * 修改隐患上报 * */ @Override public int updateDangerInfo(PreventRiskDangerInfo dangerInfo) { return preventRiskDangerInfoRepository.updateDangerInfo(dangerInfo); } /** * 删除隐患上报 */ @Override public int deleteDangerInfo(Long id) { return preventRiskDangerInfoRepository.deleteDangerInfo(id); } } src/main/java/com/ruoyi/doublePrevention/service/baseService/impl/PreventRiskJobAndMeasureServiceImpl.java
对比新文件 @@ -0,0 +1,38 @@ package com.ruoyi.doublePrevention.service.baseService.impl; import com.ruoyi.doublePrevention.entity.PreventRiskJobAndMeasure; import com.ruoyi.doublePrevention.repository.PreventRiskJobAndMeasureRepository; import com.ruoyi.doublePrevention.service.baseService.PreventRiskJobAndMeasureService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @Service("PreventRiskJobAndMeasureService") public class PreventRiskJobAndMeasureServiceImpl implements PreventRiskJobAndMeasureService { @Autowired private PreventRiskJobAndMeasureRepository preventRiskJobAndMeasureRepository; /** * 插入管控措施与job的对应关系 * */ @Override public int insertJobAndMeasure(PreventRiskJobAndMeasure jobAndMeasure) { return preventRiskJobAndMeasureRepository.insertJobAndMeasure(jobAndMeasure); } /** * 查询JobAndMeasure - By JobId */ @Override public PreventRiskJobAndMeasure getJobAndMeasureByJobId(Long jobId) { return preventRiskJobAndMeasureRepository.getJobAndMeasureByJobId(jobId); } /** * 删除job管控措施的附属表关联信息 */ @Override public int deleteJobAndMeasure(Long jobId) { return preventRiskJobAndMeasureRepository.deleteJobAndMeasure(jobId); } } src/main/java/com/ruoyi/doublePrevention/service/baseService/impl/PreventRiskUnitUuidServiceImpl.java
@@ -26,4 +26,18 @@ public PreventRiskUnitUuid getRiskUnitUuidById(Long id) { return preventRiskUnitUuidRepository.getRiskUnitUuidById(id); } /** * 修改 * */ @Override public int updateRiskUnitUuid(PreventRiskUnitUuid riskUnitUuid) { return preventRiskUnitUuidRepository.updateRiskUnitUuid(riskUnitUuid); } /** * 删除附属表信息 */ @Override public int deleteRiskUnit(String[] riskListIds) { return preventRiskUnitUuidRepository.deleteRiskUnit(riskListIds); } } src/main/java/com/ruoyi/doublePrevention/service/impl/RiskServiceImpl.java
@@ -4,6 +4,7 @@ import com.github.pagehelper.Page; import com.github.pagehelper.PageHelper; import com.ruoyi.common.utils.StringUtils; import com.ruoyi.common.utils.text.Convert; import com.ruoyi.doublePrevention.entity.*; import com.ruoyi.doublePrevention.entity.dto.req.*; import com.ruoyi.doublePrevention.entity.dto.resp.*; @@ -16,16 +17,16 @@ import com.ruoyi.doublePrevention.service.baseService.*; import com.ruoyi.doublePrevention.vo.ResultVO; import com.ruoyi.project.system.user.domain.User; import com.ruoyi.project.tr.HiddenDangerCheckJob.domain.HiddenDangerCheckJob; import com.ruoyi.project.tr.HiddenDangerCheckJob.mapper.HiddenDangerCheckJobMapper; import com.ruoyi.project.tr.hiddenDangerCheck.domain.HiddenDangerCheck; import com.ruoyi.project.tr.hiddenDangerCheckPoint.domain.HiddenDangerCheckPoint; import org.springframework.beans.BeanUtils; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.UUID; import java.util.*; import java.util.stream.Collectors; import static com.ruoyi.common.utils.security.ShiroUtils.getSysUser; @@ -54,6 +55,21 @@ @Autowired private PreventRiskCheckUnitService preventRiskCheckUnitService; @Autowired private PreventRiskJobAndMeasureService preventRiskJobAndMeasureService; @Autowired private HiddenDangerCheckJobMapper hiddenDangerCheckJobMapper; @Autowired private PreventRiskDangerCheckLogService preventRiskDangerCheckLogService; @Autowired private PreventRiskDangerCheckAndMeasureService preventRiskDangerCheckAndMeasureService; @Autowired private PreventRiskDangerInfoService preventRiskDangerInfoService; /** * 为设施设备清单附属表添加uuid * */ @@ -62,12 +78,74 @@ String uuid = UUID.randomUUID().toString(); PreventRiskUnitUuid riskUnitUuid = new PreventRiskUnitUuid(); //封装参数 todo //封装参数 riskUnitUuid.setRiskUnitId(id); riskUnitUuid.setRiskUnitUuid(uuid); riskUnitUuid.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode()); //获取上报主配置信息 PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_ANA_UNIT.getCode()); //设置本条数据上报更新时间 riskUnitUuid.setUpdateReportDataTime(new Date()); //读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置 if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode() && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){ //设置上报状态为-等待上报 riskUnitUuid.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode()); //设置本条数据上报开关为-开启 riskUnitUuid.setReportSwitch(SyncEnum.REPORT_ON.getCode()); //其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作 }else { //设置上报状态为-不上报 riskUnitUuid.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode()); //设置本条数据上报开关为-关闭 riskUnitUuid.setReportSwitch(SyncEnum.REPORT_OFF.getCode()); } return preventRiskUnitUuidService.insertRiskUnitUuid(riskUnitUuid); } /** * 修改风险清单附属表 */ @Override public int updateRiskUnit(Long riskListId) { PreventRiskUnitUuid riskUnitUuid = new PreventRiskUnitUuid(); //封装参数 riskUnitUuid.setRiskUnitId(riskListId); //获取上报主配置信息 PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_ANA_UNIT.getCode()); //设置本条数据上报更新时间 riskUnitUuid.setUpdateReportDataTime(new Date()); //读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置 if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode() && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){ //设置上报状态为-等待上报 riskUnitUuid.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode()); //设置本条数据上报开关为-开启 riskUnitUuid.setReportSwitch(SyncEnum.REPORT_ON.getCode()); //其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作 }else { //设置上报状态为-不上报 riskUnitUuid.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode()); //设置本条数据上报开关为-关闭 riskUnitUuid.setReportSwitch(SyncEnum.REPORT_OFF.getCode()); } return preventRiskUnitUuidService.updateRiskUnitUuid(riskUnitUuid); } /** * 删除附属表信息 */ @Override public int deleteRiskUnit(String ids) { String[] riskIds = Convert.toStrArray(ids); return preventRiskUnitUuidService.deleteRiskUnit(riskIds); } /** * 风险事件-新增 @@ -646,6 +724,24 @@ resultVO.setCount(count); return resultVO; } /** * 查询管控措施 by 基础排查清单ID */ @Override public List<PreventRiskControlMeasure> getRiskControlMeasureByRiskId(Long riskListId) { //获取管控措施list List<PreventRiskControlMeasure> controlMeasureList = new ArrayList<>(); //通过riskListId ,查询对应的管控措施id List<PreventRiskCheckUnit> unitByRiskId = preventRiskCheckUnitService.getUnitByRiskId(riskListId.toString()); //遍历集合，封装管控措施 for (PreventRiskCheckUnit checkUnit : unitByRiskId) { PreventRiskControlMeasure controlMeasure = riskControlMeasureService.getPreventRiskControlMeasureById(checkUnit.getControlMeasureId()); controlMeasureList.add(controlMeasure); } return controlMeasureList; } /** * 保存原检查点与管控措施的对应关系 @@ -656,8 +752,7 @@ String uuid = UUID.randomUUID().toString(); PreventRiskCheckUnit checkUnit = new PreventRiskCheckUnit(); //封装数据 todo //封装数据 checkUnit.setUuid(uuid); checkUnit.setRiskId(pointAndMeasureParams.getRiskId()); checkUnit.setBaseCheckPointId(pointAndMeasureParams.getBaseCheckPointId()); @@ -670,12 +765,336 @@ return result; } /** * @description 根据原检查点查询 原检查点与管控措施对应记录 * 删除原检查点与管控措施的对应关系 */ @Override public PreventRiskCheckUnit getRiskUnitByBaseCheckPointId(Long checkPointId) { return preventRiskCheckUnitService.getRiskUnitByBaseCheckPointId(checkPointId); public int deletePointAndMeasure(String ids) { String[] idList = Convert.toStrArray(ids); for (String id : idList) { int result = preventRiskCheckUnitService.deletePointAndMeasure(id); if (result < 1){ return StatusEnum.EXEC_FAIL.getCode(); } } return StatusEnum.EXEC_SUCCESS.getCode(); } } /** * 保存job管控措施的附属表 */ @Override public int insertJobAndMeasure(Long jobId) { String jobUuid = UUID.randomUUID().toString(); PreventRiskJobAndMeasure jobAndMeasure = new PreventRiskJobAndMeasure(); //根据jobId查询对应的基础排查清单 HiddenDangerCheckJob jobById = hiddenDangerCheckJobMapper.getJobById(jobId); //根据RiskId查询对应的管控措施 List<PreventRiskCheckUnit> unitByRiskId = preventRiskCheckUnitService.getUnitByRiskId(jobById.getRiskId()); //遍历管控措施集合 for (PreventRiskCheckUnit checkUnit : unitByRiskId) { PreventRiskControlMeasure preventRiskControlMeasureById = riskControlMeasureService.getPreventRiskControlMeasureById(checkUnit.getControlMeasureId()); //封装数据 jobAndMeasure.setJobId(jobId); jobAndMeasure.setJobUuid(jobUuid); jobAndMeasure.setMeasureId(checkUnit.getControlMeasureId()); jobAndMeasure.setMeasureUuid(preventRiskControlMeasureById.getUuid());//todo 如果删除了措施 此处可能为空，后续处理 //获取上报主配置信息 PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_TASK_FROM_WORK.getCode()); //设置上报时间为空 jobAndMeasure.setReportTime(null); //设置本条数据上报更新时间 jobAndMeasure.setUpdateReportDataTime(new Date()); //读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置 if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode() && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){ //设置上报状态为-等待上报 jobAndMeasure.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode()); //设置本条数据上报开关为-开启 jobAndMeasure.setReportSwitch(SyncEnum.REPORT_ON.getCode()); //其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作 }else { //设置上报状态为-不上报 jobAndMeasure.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode()); //设置本条数据上报开关为-关闭 jobAndMeasure.setReportSwitch(SyncEnum.REPORT_OFF.getCode()); } int result = preventRiskJobAndMeasureService.insertJobAndMeasure(jobAndMeasure); if (result < 1 ){ return StatusEnum.EXEC_FAIL.getCode(); } } return StatusEnum.EXEC_SUCCESS.getCode(); } /** * 修改job管控措施的附属表 */ @Transactional @Override public int updateJobAndMeasure(HiddenDangerCheckJob hiddenDangerCheckJob) { // 2、若有变更，需要预先读取jobAndMeasure的uuid，保存下来 PreventRiskJobAndMeasure jobAndMeasureByJobId = preventRiskJobAndMeasureService.getJobAndMeasureByJobId(hiddenDangerCheckJob.getJobId()); String jobUuid = jobAndMeasureByJobId.getJobUuid(); Date reportTime = jobAndMeasureByJobId.getReportTime(); if (jobAndMeasureByJobId != null){ //3、删除库中原关联关系 int deleteResult = preventRiskJobAndMeasureService.deleteJobAndMeasure(hiddenDangerCheckJob.getJobId()); if(deleteResult < 1){ throw new RuntimeException("清除job管控措施的附属表关联信息失败"); } } //4根据RiskId查询对应的管控措施 List<PreventRiskCheckUnit> unitByRiskId = preventRiskCheckUnitService.getUnitByRiskId(hiddenDangerCheckJob.getRiskId()); //5封装数据，插入数据库，重新添加关联关系 for (PreventRiskCheckUnit checkUnit : unitByRiskId) { PreventRiskControlMeasure preventRiskControlMeasureById = riskControlMeasureService.getPreventRiskControlMeasureById(checkUnit.getControlMeasureId()); PreventRiskJobAndMeasure jobAndMeasure = new PreventRiskJobAndMeasure(); //封装参数 jobAndMeasure.setJobId(jobAndMeasureByJobId.getJobId()); //使用保存下来的uuid，再次添加关联关系 jobAndMeasure.setJobUuid(jobUuid); jobAndMeasure.setMeasureId(checkUnit.getControlMeasureId()); jobAndMeasure.setMeasureUuid(preventRiskControlMeasureById.getUuid());//todo 如果删除了措施 此处可能为空，后续处理 //获取上报主配置信息 PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_TASK_FROM_WORK.getCode()); //设置上报时间 jobAndMeasure.setReportTime(reportTime); //设置本条数据上报更新时间 jobAndMeasure.setUpdateReportDataTime(new Date()); //读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置 if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode() && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){ //设置上报状态为-等待上报 jobAndMeasure.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode()); //设置本条数据上报开关为-开启 jobAndMeasure.setReportSwitch(SyncEnum.REPORT_ON.getCode()); //其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作 }else { //设置上报状态为-不上报 jobAndMeasure.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode()); //设置本条数据上报开关为-关闭 jobAndMeasure.setReportSwitch(SyncEnum.REPORT_OFF.getCode()); } int result = preventRiskJobAndMeasureService.insertJobAndMeasure(jobAndMeasure); if (result < 1 ){ return StatusEnum.EXEC_FAIL.getCode(); } } return StatusEnum.EXEC_SUCCESS.getCode(); } /** * 删除job管控措施的附属表关联信息 */ @Transactional @Override public int deleteJobAndMeasure(String ids) { Long[] jobIds = Convert.toLongArray(ids); for (Long jobId : jobIds) { int result = preventRiskJobAndMeasureService.deleteJobAndMeasure(jobId); if (result < 1 ){ throw new RuntimeException("删除job管控措施的附属表关联信息失败"); } } return StatusEnum.EXEC_SUCCESS.getCode(); } /** * 查询Job与措施 */ @Override public PreventRiskJobAndMeasure getJobAndMeasure(Long jobId) { return preventRiskJobAndMeasureService.getJobAndMeasureByJobId(jobId); } /** * 定时生成排查任务记录时， * 插入排查记录附属表 */ @Override public int insertDangerCheckLog(Long checkId, HiddenDangerCheck hdc) { String dangerCheckUuid = UUID.randomUUID().toString(); PreventRiskDangerCheckLog dangerCheck = new PreventRiskDangerCheckLog(); dangerCheck.setUuid(dangerCheckUuid); dangerCheck.setCheckStatus(null); dangerCheck.setCheckId(checkId); dangerCheck.setJobId(hdc.getJobId()); //获取上报主配置信息 PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG__CHECK_RECORD.getCode()); //设置上报时间为空 dangerCheck.setReportTime(null); //设置本条数据上报更新时间 dangerCheck.setUpdateReportDataTime(new Date()); //读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置 if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode() && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){ //设置上报状态为-等待上报 dangerCheck.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode()); //设置本条数据上报开关为-开启 dangerCheck.setReportSwitch(SyncEnum.REPORT_ON.getCode()); //其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作 }else { //设置上报状态为-不上报 dangerCheck.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode()); //设置本条数据上报开关为-关闭 dangerCheck.setReportSwitch(SyncEnum.REPORT_OFF.getCode()); } return preventRiskDangerCheckLogService.insertDangerCheckLog(dangerCheck); } /** * 定时生成排查任务记录时， * 插入检查点附属表 */ @Override public void insertCheckAndMeasure(Long id, HiddenDangerCheckPoint hdcp) { PreventRiskDangerCheckAndMeasure checkAndMeasure = new PreventRiskDangerCheckAndMeasure(); //根据检查点信息，查询对应管控措施 PreventRiskCheckUnit checkUnit = preventRiskCheckUnitService.getUnitByBaseCheckPointId(hdcp.getCheckPointId()); if (checkUnit == null){ throw new RuntimeException("基础检查点不存在"); } PreventRiskControlMeasure controlMeasure = riskControlMeasureService.getPreventRiskControlMeasureById(checkUnit.getControlMeasureId()); if (controlMeasure == null){ throw new RuntimeException("管控措施已经被删除"); } //封装数据 checkAndMeasure.setCheckId(hdcp.getCheckId()); checkAndMeasure.setDangerCheckPointId(id); checkAndMeasure.setBaseCheckPointId(hdcp.getCheckPointId()); checkAndMeasure.setControlMeasureId(controlMeasure.getId()); checkAndMeasure.setCheckContent(controlMeasure.getCheckContent()); checkAndMeasure.setCheckResult(null); //写入核查任务检查点与管控措施信息 preventRiskDangerCheckAndMeasureService.insertCheckAndMeasure(checkAndMeasure); } /** * 删除定时核查任务 * */ @Override @Transactional public int deleteDangerCheck(String ids) { Long[] dangerCheckIdList = Convert.toLongArray(ids); //1、删除核查任务附属表 for (Long checkId : dangerCheckIdList) { int result = preventRiskDangerCheckLogService.deleteDangerCheck(checkId); if (result < 1){ return StatusEnum.EXEC_FAIL.getCode(); } } //2、删除核查任务-检查点的附属表----老代码未删除检查点信息，此处暂不做处理 return StatusEnum.EXEC_SUCCESS.getCode(); } /** * 新增隐患上报 * */ @Override public int insertDangerInfo(Long id, HiddenDangerCheckPoint hdcp) { String dangerInfoUuid = UUID.randomUUID().toString(); PreventRiskDangerInfo dangerInfo = new PreventRiskDangerInfo(); dangerInfo.setUuid(dangerInfoUuid); dangerInfo.setDangerCheckPointId(id); dangerInfo.setHazardCode(hdcp.getHazardCode()); dangerInfo.setDangerSrc(hdcp.getDangerSrc()); dangerInfo.setDangerDesc(hdcp.getDangerDesc()); dangerInfo.setDangerReason(hdcp.getDangerReason()); dangerInfo.setHazardDangerType(hdcp.getHazardDangerType()); dangerInfo.setDangerState(hdcp.getDangerState()); dangerInfo.setTimeoutFlag(null);//暂时不清楚是否需要此功能，先设为空 //获取上报主配置信息 PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode()); //设置上报时间为空 dangerInfo.setReportTime(null); //设置本条数据上报更新时间 dangerInfo.setUpdateReportDataTime(new Date()); //读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置 if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode() && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){ //设置上报状态为-等待上报 dangerInfo.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode()); //设置本条数据上报开关为-开启 dangerInfo.setReportSwitch(SyncEnum.REPORT_ON.getCode()); //其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作 }else { //设置上报状态为-不上报 dangerInfo.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode()); //设置本条数据上报开关为-关闭 dangerInfo.setReportSwitch(SyncEnum.REPORT_OFF.getCode()); } return preventRiskDangerInfoService.insertDangerInfo(dangerInfo); } /** * 修改隐患上报 * */ @Override public int updateDangerInfo(HiddenDangerCheckPoint hdcp) { //封装修改数据 PreventRiskDangerInfo dangerInfo = new PreventRiskDangerInfo(); dangerInfo.setDangerCheckPointId(hdcp.getId()); dangerInfo.setHazardCode(hdcp.getHazardCode()); dangerInfo.setDangerSrc(hdcp.getDangerSrc()); dangerInfo.setDangerDesc(hdcp.getDangerDesc()); dangerInfo.setDangerReason(hdcp.getDangerReason()); dangerInfo.setHazardDangerType(hdcp.getHazardDangerType()); dangerInfo.setDangerState(hdcp.getDangerState()); dangerInfo.setTimeoutFlag(null);//暂时不清楚是否需要此功能，先设为空 //获取上报主配置信息 PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode()); //设置本条数据上报更新时间 dangerInfo.setUpdateReportDataTime(new Date()); //读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置 if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode() && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){ //设置上报状态为-等待上报 dangerInfo.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode()); //设置本条数据上报开关为-开启 dangerInfo.setReportSwitch(SyncEnum.REPORT_ON.getCode()); //其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作 }else { //设置上报状态为-不上报 dangerInfo.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode()); //设置本条数据上报开关为-关闭 dangerInfo.setReportSwitch(SyncEnum.REPORT_OFF.getCode()); } return preventRiskDangerInfoService.updateDangerInfo(dangerInfo); } /** * 删除隐患上报 */ @Override public int deleteDangerInfo(Long id) { return preventRiskDangerInfoService.deleteDangerInfo(id); } } src/main/java/com/ruoyi/project/tr/HiddenDangerCheckJob/controller/HiddenDangerCheckJobController.java
@@ -4,6 +4,10 @@ import com.ruoyi.common.exception.job.TaskException; import com.ruoyi.common.utils.StringUtils; import com.ruoyi.common.utils.poi.ExcelUtil; import com.ruoyi.doublePrevention.entity.PreventReportConfig; import com.ruoyi.doublePrevention.entity.PreventRiskJobAndMeasure; import com.ruoyi.doublePrevention.enums.SyncEnum; import com.ruoyi.doublePrevention.service.RiskService; import com.ruoyi.framework.aspectj.lang.annotation.Log; import com.ruoyi.framework.aspectj.lang.enums.BusinessType; import com.ruoyi.framework.web.controller.BaseController; @@ -56,6 +60,8 @@ private IRegionService regionService; @Autowired private IDeptService deptService; @Autowired private RiskService riskService; @GetMapping() public String hiddenDangerCheckJob() { @@ -85,6 +91,10 @@ @ResponseBody public AjaxResult remove(String ids) throws SchedulerException { hiddenDangerCheckJobService.deleteJobByIds(ids); //todo-2022 删除job与措施的关联关系 riskService.deleteJobAndMeasure(ids); return success(); } @@ -152,6 +162,7 @@ /** * 新增保存调度 * todo-2022 对应work */ @Log(title = "定时任务", businessType = BusinessType.INSERT) @PostMapping("/add") @@ -212,6 +223,14 @@ } } hiddenDangerCheckJobService.insertJob(hiddenDangerCheckJob); //todo- 2022 保存job与管控措施的对应关系 hiddenDangerCheckJob.getJobId(); int result = riskService.insertJobAndMeasure(hiddenDangerCheckJob.getJobId());{ if (result < 0 ){ throw new RuntimeException("保存job与管控措施的对应关系失败"); } } } } } @@ -350,6 +369,15 @@ hiddenDangerCheckJob.setRiskDeptName(d.getDeptName()); } } //todo- 2022 保存job与管控措施的对应关系 //1、先查询基础清单是否有变更 HiddenDangerCheckJob jobById = hiddenDangerCheckJobService.getJobById(hiddenDangerCheckJob.getJobId()); if (!jobById.getRiskId().equals(hiddenDangerCheckJob.getRiskId())){ // 2、若有变更，再次添加关联关系 riskService.updateJobAndMeasure(hiddenDangerCheckJob); } return toAjax(hiddenDangerCheckJobService.updateJob(hiddenDangerCheckJob)); }
@@ -65,4 +65,8 @@ * @return 结果 */ int insertJob(HiddenDangerCheckJob job); /** * Job getByID */ HiddenDangerCheckJob getJobById(Long jobId); } src/main/java/com/ruoyi/project/tr/HiddenDangerCheckJob/service/HiddenDangerCheckJobServiceImpl.java
@@ -252,4 +252,11 @@ { return CronUtils.isValid(cronExpression); } /** * 获取job-By Id */ @Override public HiddenDangerCheckJob getJobById(Long jobId) { return jobMapper.getJobById(jobId); } } src/main/java/com/ruoyi/project/tr/HiddenDangerCheckJob/service/IHiddenDangerCheckJobService.java
@@ -100,4 +100,8 @@ * @return 结果 */ boolean checkCronExpressionIsValid(String cronExpression); /** * 获取job-By Id */ HiddenDangerCheckJob getJobById(Long jobId); } src/main/java/com/ruoyi/project/tr/HiddenDangerCheckJob/util/AbstractQuartzJob.java
@@ -10,12 +10,15 @@ import com.ruoyi.common.utils.bean.BeanUtils; import com.ruoyi.common.utils.security.ShiroUtils; import com.ruoyi.common.utils.spring.SpringUtils; import com.ruoyi.doublePrevention.entity.PreventRiskJobAndMeasure; import com.ruoyi.doublePrevention.service.RiskService; import com.ruoyi.framework.web.service.JpushService; import com.ruoyi.project.enumerate.TrRiskTypeEnum; import com.ruoyi.project.monitor.job.domain.JobLog; import com.ruoyi.project.monitor.job.service.IJobLogService; import com.ruoyi.project.tr.HiddenDangerCheckJob.domain.HiddenDangerCheckJob; import com.ruoyi.project.tr.baseCheckPoint.domain.BaseCheckPoint; import com.ruoyi.project.tr.baseCheckPoint.mapper.BaseCheckPointMapper; import com.ruoyi.project.tr.baseCheckPoint.service.IBaseCheckPointService; import com.ruoyi.project.tr.hiddenDangerCheck.domain.HiddenDangerCheck; import com.ruoyi.project.tr.hiddenDangerCheck.service.IHiddenDangerCheckService; @@ -25,11 +28,14 @@ import com.ruoyi.project.tr.riskCheckPoint.service.IRiskCheckPointService; import com.ruoyi.project.tr.riskEvaluationPlan.domain.RiskEvaluationPlan; import com.ruoyi.project.tr.riskEvaluationPlan.service.IRiskEvaluationPlanService; import com.ruoyi.project.tr.riskList.domain.RiskList; import com.ruoyi.project.tr.riskList.service.IRiskListService; import org.quartz.JobExecutionContext; import org.quartz.JobExecutionException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.transaction.annotation.Transactional; import org.springframework.web.context.support.SpringBeanAutowiringSupport; import java.util.Date; @@ -48,11 +54,17 @@ JpushService jpushService; @Autowired private RiskService riskService; @Autowired private IRiskListService iRiskListService; /** * 线程本地变量 */ private static ThreadLocal<Date> threadLocal = new ThreadLocal<>(); @Override public void execute(JobExecutionContext context) throws JobExecutionException { @@ -62,9 +74,8 @@ before(context, job); if (job != null) { doExecute(context, job); } createData(context, job);//生成数据 createData(context, job);//生成数据 // todo-2022 调用方法 定时隐患排查任务生成 after(context, job, null); } catch (Exception e) { log.error("任务执行异常 - ：", e); @@ -114,8 +125,11 @@ /** * todo-2022 定时隐患排查任务生成 * */ //生成定时隐患排查数据 @Transactional protected void createData(JobExecutionContext context, HiddenDangerCheckJob job) { Date startTime = threadLocal.get(); @@ -148,20 +162,35 @@ hdc.setCheckType(job.getCheckType());//设置排查方式 if ("1".equals(job.getCheckType())) { hdc.setRiskId(job.getRiskId() != null ? Long.valueOf(job.getRiskId()) : -1);//风险单元ID hdc.setRiskName(job.getRiskName());//风险单元名称 // todo-2022 ,基础排除清单名称-》改用基础清单表中信息 RiskList infoByRiskId = iRiskListService.getInfoByRiskId(job.getRiskId()); hdc.setRiskName(infoByRiskId.getRiskListName());//风险单元名称 hdc.setDangerPlaceId(job.getRiskPlaceId());//风险单元地点ID hdc.setDangerPlaceName(job.getRiskPlaceName());//风险单元地点名称 hdc.setDangerDeptId(job.getRiskDeptId());//隐患责任部门ID hdc.setDangerDeptName(job.getRiskDeptName());//隐患责任部门名称 hdc.setRiskType(job.getRiskType());//风险单元类型 // //1、校验是否有管控措施 // PreventRiskJobAndMeasure jobAndMeasure = riskService.getJobAndMeasure(job.getJobId()); // if (jobAndMeasure == null ){ // throw new RuntimeException("空任务，不调度"); // } // HiddenDangerCheck（隐患排查）写入数据库当中 SpringUtils.getBean(IHiddenDangerCheckService.class).insertHiddenDangerCheck(hdc); //HiddenDangerCheckPoint（隐患排查检查点）写入数据库当中 hdc.setCompanyId(job.getCompanyId()); insertHiddenDangerCheckPoint(hdc); // todo-2022 插入 任务附属表 写到此处 hdc.getCheckId(); int result = riskService.insertDangerCheckLog(hdc.getCheckId(), hdc); if (result < 1){ throw new RuntimeException("定时任务生产失败"); } } else if ("2".equals(job.getCheckType())) { String[] riskIdArray = job.getRiskId().split(","); @@ -198,8 +227,11 @@ } } /** * todo-2022 生成核查任务时，添加任务的核查点信息 * */ //生成检查点信息 @Transactional public void insertHiddenDangerCheckPoint(HiddenDangerCheck job) { if(!StringUtils.isEmpty(job.getRiskType())) { //风险单元类型为基础清单 @@ -222,6 +254,11 @@ // hdcp.setDangerSources(TrHiddenDangerCheckConstants.DANGER_SOURCES_SCHEDULE_PRODUCE);//隐患来源(定时器任务生成) // 写入数据库当中 SpringUtils.getBean(IHiddenDangerCheckPointService.class).insertHiddenDangerCheckPoint(hdcp); hdcp.getId(); // todo-2022 现场核查清单对应的核查点信息 riskService.insertCheckAndMeasure(hdcp.getId(), hdcp); } }); @@ -232,7 +269,6 @@ RiskCheckPoint rcpQuery = new RiskCheckPoint(); rcpQuery.setPlanId(plan.getPlanId()); List<RiskCheckPoint> riskCheckPointList = SpringUtils.getBean(IRiskCheckPointService.class).selectRiskCheckPointList(rcpQuery); riskCheckPointList.forEach(rcp -> { if (rcp != null) { src/main/java/com/ruoyi/project/tr/baseCheckPoint/controller/BaseCheckPointController.java
@@ -8,9 +8,9 @@ import com.ruoyi.common.utils.DateUtils; import com.ruoyi.common.utils.StringUtils; import com.ruoyi.common.utils.security.ShiroUtils; import com.ruoyi.doublePrevention.entity.PreventRiskCheckUnit; import com.ruoyi.doublePrevention.repository.param.PreventPointAndMeasureParams; import com.ruoyi.doublePrevention.service.RiskService; import com.ruoyi.doublePrevention.service.baseService.PreventRiskDangerInfoService; import com.ruoyi.project.enumerate.TrEvaluationMethodDetailsEnum; import com.ruoyi.project.enumerate.TrEvaluationMethodTypeEnum; import com.ruoyi.project.system.dept.domain.Dept; @@ -157,19 +157,23 @@ @Log(title = "基础清单检查点", businessType = BusinessType.INSERT) @PostMapping("/add") @ResponseBody @Transactional public AjaxResult addSave(BaseCheckPoint baseCheckPoint) { //老代码改造 int result = baseCheckPointService.insertBaseCheckPoint(baseCheckPoint); //todo ，此处改造，嵌入管控措施 //todo-2022 ，此处改造，嵌入管控措施 baseCheckPoint.getCheckPointId(); PreventPointAndMeasureParams pointAndMeasureParams = new PreventPointAndMeasureParams(); //封装参数 pointAndMeasureParams.setBaseCheckPointId(baseCheckPoint.getCheckPointId()); pointAndMeasureParams.setControlMeasureId(baseCheckPoint.getControlMeasureId());//todo，该参数页面尚未封装进去 pointAndMeasureParams.setControlMeasureId(baseCheckPoint.getControlMeasureId());// todo，该参数页面尚未封装进去 pointAndMeasureParams.setRiskId(baseCheckPoint.getRiskId()); riskService.insertPointAndMeasure(pointAndMeasureParams); int result1 = riskService.insertPointAndMeasure(pointAndMeasureParams); if (result1 < 1){ throw new RuntimeException("新增异常，保存管控措施关系失败"); } return toAjax(result); } @@ -181,12 +185,6 @@ public String edit(@PathVariable("checkPointId") Long checkPointId, ModelMap mmap) { BaseCheckPoint baseCheckPoint = baseCheckPointService.selectBaseCheckPointById(checkPointId); //todo-2022 返回参数加入措施id PreventRiskCheckUnit riskCheckUnit = riskService.getRiskUnitByBaseCheckPointId(checkPointId); if (riskCheckUnit != null){ baseCheckPoint.setControlMeasureId(riskCheckUnit.getControlMeasureId()); } mmap.put("baseCheckPoint", baseCheckPoint); return prefix + "/edit"; } @@ -197,19 +195,38 @@ @Log(title = "基础清单检查点", businessType = BusinessType.UPDATE) @PostMapping("/edit") @ResponseBody @Transactional public AjaxResult editSave(BaseCheckPoint baseCheckPoint) { return toAjax(baseCheckPointService.updateBaseCheckPoint(baseCheckPoint)); int result = baseCheckPointService.updateBaseCheckPoint(baseCheckPoint); //todo-2022 ，此处改造，修改检查点与管控措施的关系----注，删除点，重加点 // int result1 = riskService.updatePointAndMeasure(baseCheckPoint); // if (result1 < 1){ // throw new RuntimeException("保存管控措施关系失败"); // } return toAjax(result); } /** * 删除基础清单检查点 */ @Transactional @Log(title = "基础清单检查点", businessType = BusinessType.DELETE) @PostMapping( "/remove") @ResponseBody public AjaxResult remove(String ids) { return toAjax(baseCheckPointService.deleteBaseCheckPointByIds(ids)); //老代码 int result = baseCheckPointService.deleteBaseCheckPointByIds(ids); //todo-2022 ，此处改造，删除检查点与管控措施的关系 int result1 = riskService.deletePointAndMeasure(ids); if (result1 < 1){ throw new RuntimeException("新增异常，保存管控措施关系失败"); } return toAjax(result); } } src/main/java/com/ruoyi/project/tr/baseCheckPoint/domain/BaseCheckPoint.java
@@ -1,9 +1,12 @@ package com.ruoyi.project.tr.baseCheckPoint.domain; import com.baomidou.mybatisplus.annotation.TableField; import kotlin.jvm.Transient; import org.apache.commons.lang3.builder.ToStringBuilder; import org.apache.commons.lang3.builder.ToStringStyle; import com.ruoyi.framework.aspectj.lang.annotation.Excel; import com.ruoyi.framework.web.domain.BaseEntity; import org.springframework.transaction.annotation.Transactional; import java.util.List; @@ -39,6 +42,7 @@ private String checkType; /**措施id */ @Transient @Excel(name = "措施id") private Long controlMeasureId;
@@ -58,4 +58,5 @@ * @return 结果 */ int deleteBaseCheckPointById(Long checkPointId); } src/main/java/com/ruoyi/project/tr/baseCheckPoint/service/impl/BaseCheckPointServiceImpl.java
@@ -2,17 +2,12 @@ import java.util.List; import com.ruoyi.common.utils.DateUtils; import com.ruoyi.doublePrevention.entity.PreventRiskCheckUnit; import com.ruoyi.doublePrevention.enums.ErrorCodes; import com.ruoyi.doublePrevention.repository.PreventRiskCheckUnitRepository; import com.ruoyi.doublePrevention.service.baseService.PreventRiskCheckUnitService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import com.ruoyi.project.tr.baseCheckPoint.mapper.BaseCheckPointMapper; import com.ruoyi.project.tr.baseCheckPoint.domain.BaseCheckPoint; import com.ruoyi.project.tr.baseCheckPoint.service.IBaseCheckPointService; import com.ruoyi.common.utils.text.Convert; import org.springframework.transaction.annotation.Transactional; /** * 基础清单检查点Service业务层处理 @@ -25,9 +20,6 @@ { @Autowired private BaseCheckPointMapper baseCheckPointMapper; @Autowired private PreventRiskCheckUnitRepository riskCheckUnitRepository; /** * 查询基础清单检查点 @@ -73,21 +65,10 @@ * @return 结果 */ @Override @Transactional public int updateBaseCheckPoint(BaseCheckPoint baseCheckPoint) { baseCheckPoint.setUpdateTime(DateUtils.getNowDate()); baseCheckPointMapper.updateBaseCheckPoint(baseCheckPoint); //todo-2022 对措施与检查点关联的措施id进行修改 PreventRiskCheckUnit riskCheckUnit = riskCheckUnitRepository.getPointAndMeasureByPointId(baseCheckPoint.getCheckPointId()); if (riskCheckUnit == null){ throw new RuntimeException("查询不到对应的措施"); } riskCheckUnit.setControlMeasureId(baseCheckPoint.getControlMeasureId()); int riskCheckUnitUpdateResult = riskCheckUnitRepository.updateRiskCheckUnitById(riskCheckUnit); return riskCheckUnitUpdateResult; return baseCheckPointMapper.updateBaseCheckPoint(baseCheckPoint); } /** @@ -97,14 +78,9 @@ * @return 结果 */ @Override @Transactional public int deleteBaseCheckPointByIds(String ids) { baseCheckPointMapper.deleteBaseCheckPointByIds(Convert.toStrArray(ids)); //todo-2022 对措施与检查点关联的表根据原检查点id进行批量删除 int deletePointAndMeasureResult = riskCheckUnitRepository.deleteRiskCheckUnitByCheckPointIds(Convert.toStrArray(ids)); return deletePointAndMeasureResult; return baseCheckPointMapper.deleteBaseCheckPointByIds(Convert.toStrArray(ids)); } /** src/main/java/com/ruoyi/project/tr/hiddenDangerCheck/controller/DangerReportController.java
@@ -5,6 +5,7 @@ import com.ruoyi.common.utils.DateUtils; import com.ruoyi.common.utils.StringUtils; import com.ruoyi.common.utils.security.ShiroUtils; import com.ruoyi.doublePrevention.service.RiskService; import com.ruoyi.framework.aspectj.lang.annotation.Log; import com.ruoyi.framework.aspectj.lang.enums.BusinessType; import com.ruoyi.framework.web.controller.BaseController; @@ -20,6 +21,7 @@ import com.ruoyi.project.tr.hiddenTroubleType.service.IHiddenTroubleTypeService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.transaction.annotation.Transactional; import org.springframework.ui.ModelMap; import org.springframework.web.bind.annotation.*; @@ -49,6 +51,9 @@ @Autowired private IUserService userService; @Autowired private RiskService riskService; @GetMapping() public String hiddenDangerCheck(ModelMap mmap) { @@ -130,10 +135,12 @@ /** * 新增保存隐患上报 * todo-2022 隐患上报 需要检查对分别对两张表做了什么，然后添加附属表（tr_hidden_danger_check_point） */ @Log(title = "隐患上报", businessType = BusinessType.INSERT) @PostMapping("/addDangerReportSave") @ResponseBody @Transactional public AjaxResult addDangerReportSave(HiddenDangerCheckPoint hdcp) { HiddenDangerCheck hiddenDangerCheck = new HiddenDangerCheck(); hiddenDangerCheck.setCreateBy(ShiroUtils.getLoginName());//创建者 @@ -154,13 +161,23 @@ hdcp.setCompanyId(getSysUser().getCompanyId()); int i = hiddenDangerCheckPointService.insertHiddenDangerCheckPoint(hdcp); if (i< 1){ throw new RuntimeException("添加隐患信息失败"); } // todo-2022 此处插入附属表 //获取Id返回值 hdcp.getId(); int result = riskService.insertDangerInfo(hdcp.getId(), hdcp); if (result< 1){ throw new RuntimeException("添加隐患附属信息失败"); } hiddenDangerCheckPointService.getTaskCountTotal(getSysUser().getUserId());//查询未执行任务总数量并推送 return toAjax(i); } /** @@ -317,6 +334,7 @@ @Log(title = "隐患上报", businessType = BusinessType.UPDATE) @PostMapping("/editDangerReportSave") @ResponseBody @Transactional public AjaxResult editDangerReportSave(HiddenDangerCheckPoint hiddenDangerCheckPoint) { HiddenDangerCheckPoint hdcp = hiddenDangerCheckPointService.selectHiddenDangerCheckPointById(hiddenDangerCheckPoint.getId()); if(hdcp!=null&&hdcp.getCheckId()!=null){ @@ -332,6 +350,12 @@ hiddenDangerCheckPoint.setUpdateBy(ShiroUtils.getLoginName());//更新者 hiddenDangerCheckPoint.setUpdateTime(DateUtils.getNowDate());//设置更新时间 hiddenDangerCheckPointService.updateHiddenDangerCheckPoint(hiddenDangerCheckPoint); // todo-2022 此处修改附属表 int result = riskService.updateDangerInfo(hiddenDangerCheckPoint); if (result < 1){ throw new RuntimeException("修改失败"); } hiddenDangerCheckPointService.getTaskCountTotal(getSysUser().getUserId());//查询未执行任务总数量并推送 return AjaxResult.success(); @@ -402,6 +426,7 @@ @Log(title = "隐患上报", businessType = BusinessType.DELETE) @PostMapping("/removeDangerReport") @ResponseBody @Transactional public AjaxResult removeDangerReport(String ids) { if(StringUtils.isEmpty(ids)){ return AjaxResult.error("id不能为空"); @@ -410,6 +435,14 @@ if(hdcp.getCheckId()!=null){ hiddenDangerCheckPointService.deleteHiddenDangerCheckPointById(hdcp.getId()); hiddenDangerCheckService.deleteHiddenDangerCheckById(hdcp.getCheckId()); // todo-2022 此处删除附属表 int result = riskService.deleteDangerInfo(hdcp.getId()); if (result < 1){ throw new RuntimeException("删除失败"); } hiddenDangerCheckPointService.getTaskCountTotal(getSysUser().getUserId());//查询未执行任务总数量并推送 return AjaxResult.success(); } @@ -419,6 +452,7 @@ /** * 隐患上报--提交 * 隐患信息提交，此处不改。思路：使用stage 进行阶段判断。只有认定后的隐患，才需要上报。 */ @Log(title = "隐患上报--提交") @PostMapping("/submitDangerReport") src/main/java/com/ruoyi/project/tr/hiddenDangerCheck/controller/DangerScheduleController.java
@@ -6,6 +6,7 @@ import com.ruoyi.common.utils.StringUtils; import com.ruoyi.common.utils.poi.ExcelUtil; import com.ruoyi.common.utils.security.ShiroUtils; import com.ruoyi.doublePrevention.service.RiskService; import com.ruoyi.framework.aspectj.lang.annotation.Log; import com.ruoyi.framework.aspectj.lang.enums.BusinessType; import com.ruoyi.framework.web.controller.BaseController; @@ -32,6 +33,7 @@ import org.apache.shiro.authz.annotation.RequiresPermissions; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.transaction.annotation.Transactional; import org.springframework.ui.ModelMap; import org.springframework.web.bind.annotation.*; @@ -72,6 +74,9 @@ @Autowired private IRoleService roleService; @Autowired private RiskService riskService; @GetMapping() public String hiddenDangerCheck(ModelMap mmap) { @@ -536,8 +541,18 @@ @Log(title = "删除定时隐患排查", businessType = BusinessType.DELETE) @PostMapping("/remove") @ResponseBody @Transactional public AjaxResult remove(String ids) { return toAjax(hiddenDangerCheckService.deleteHiddenDangerCheckByIds(ids)); //老代码 int result = hiddenDangerCheckService.deleteHiddenDangerCheckByIds(ids); // todo-2022 删除定时核查任务 新代码添加 int result1 = riskService.deleteDangerCheck(ids); if (result1 < 1){ throw new RuntimeException("删除核查任务附属表失败"); } return toAjax(result); }
@@ -29,7 +29,7 @@ /** * 新增隐患排查 * * TODO 任务调度服务 * @param hiddenDangerCheck 隐患排查 * @return 结果 */ src/main/java/com/ruoyi/project/tr/hiddenDangerCheck/service/impl/HiddenDangerCheckServiceImpl.java
@@ -73,7 +73,7 @@ /** * 新增隐患排查 * * todo 调度任务 * @param hiddenDangerCheck 隐患排查 * @return 结果 */ src/main/java/com/ruoyi/project/tr/hiddenDangerCheckPoint/domain/HiddenDangerCheckPoint.java
@@ -1,6 +1,8 @@ package com.ruoyi.project.tr.hiddenDangerCheckPoint.domain; import com.alibaba.fastjson.annotation.JSONField; import com.baomidou.mybatisplus.annotation.IdType; import com.baomidou.mybatisplus.annotation.TableId; import com.fasterxml.jackson.annotation.JsonFormat; import com.ruoyi.framework.aspectj.lang.annotation.Excel; import com.ruoyi.framework.web.domain.BaseEntity; @@ -433,6 +435,92 @@ private Long companyId; /** * hazard_code 风先分析对象编码（风险分析单元编码） * */ private String hazardCode; /** * 隐患来源 * 1-日常排查；2-综合性排查；3-专业性排查;4-季节性排查；5-重点时段及节假日前排查 * 6-事故类比排查；7-复产复工前排查;8-外聘专家诊断式排查；9-管控措施实效;10-其他；11-政府执法检查 * */ private Byte dangerSrc; /** * 隐患描述 * */ private String dangerDesc; /** * 隐患产生的原因 * */ private String dangerReason; /** * 隐患类型 * 1-安全；2-工艺；3-电气；4-仪表 * 5-消防；6-总图；7-设备；8其他 * */ private Byte hazardDangerType; /** * 隐患状态 * 0-整改中 * 1-待验收 * 2-延期整改 * 3-超期未整改 * 9-已验收 */ private Byte dangerState; public String getHazardCode() { return hazardCode; } public void setHazardCode(String hazardCode) { this.hazardCode = hazardCode; } public Byte getDangerSrc() { return dangerSrc; } public void setDangerSrc(Byte dangerSrc) { this.dangerSrc = dangerSrc; } public String getDangerDesc() { return dangerDesc; } public void setDangerDesc(String dangerDesc) { this.dangerDesc = dangerDesc; } public String getDangerReason() { return dangerReason; } public void setDangerReason(String dangerReason) { this.dangerReason = dangerReason; } public Byte getHazardDangerType() { return hazardDangerType; } public void setHazardDangerType(Byte hazardDangerType) { this.hazardDangerType = hazardDangerType; } public Byte getDangerState() { return dangerState; } public void setDangerState(Byte dangerState) { this.dangerState = dangerState; } public List<Long> getCompanyIdList() { return companyIdList; } src/main/java/com/ruoyi/project/tr/riskList/controller/RiskListController.java
@@ -1,8 +1,11 @@ package com.ruoyi.project.tr.riskList.controller; import com.ruoyi.common.utils.BeanCopyUtils; import com.ruoyi.common.utils.DateUtils; import com.ruoyi.common.utils.poi.ExcelUtil; import com.ruoyi.common.utils.security.ShiroUtils; import com.ruoyi.doublePrevention.entity.PreventRiskControlMeasure; import com.ruoyi.doublePrevention.entity.dto.resp.PreventRiskCheckUnitRespDTO; import com.ruoyi.doublePrevention.service.RiskService; import com.ruoyi.framework.aspectj.lang.annotation.Log; import com.ruoyi.framework.aspectj.lang.enums.BusinessType; @@ -30,7 +33,6 @@ import org.springframework.transaction.annotation.Transactional; import org.springframework.ui.ModelMap; import org.springframework.web.bind.annotation.*; import org.thymeleaf.spring5.processor.SpringErrorClassTagProcessor; import java.util.ArrayList; import java.util.Date; @@ -201,7 +203,7 @@ int result = riskListService.insertRiskList(riskList); riskList.getRiskListId(); //todo 判断是风先分析单元 ，还是任务单元，分别封装处理 //todo-2022 //新代码，为设施设备清单附属表添加uuid int uuidResult = riskService.insertRiskUnitUuid(riskList.getRiskListId()); if (uuidResult < 0){ @@ -296,6 +298,7 @@ /** * 修改保存风险清单 */ @Transactional @Log(title = "风险清单", businessType = BusinessType.UPDATE) @PostMapping("/edit") @ResponseBody @@ -303,7 +306,12 @@ User sysUser = getSysUser(); riskList.setUpdateBy(sysUser.getUserName()); riskList.setUpdateTime(DateUtils.getNowDate()); return toAjax(riskListService.updateRiskList(riskList)); int result = riskListService.updateRiskList(riskList); //todo-2022 新代码，附属表变更 riskService.updateRiskUnit(riskList.getRiskListId()); return toAjax(result); } /** @@ -314,7 +322,12 @@ @ResponseBody public AjaxResult remove(String ids) { //删除风险清单的同时,删除评价计划, return toAjax(riskListService.deleteRiskListByIds(ids)); int result = riskListService.deleteRiskListByIds(ids); //todo-2022 新代码，附属表变更 riskService.deleteRiskUnit(ids); return toAjax(result); } /** @@ -425,7 +438,22 @@ @ResponseBody public TableDataInfo list(RiskList riskList) { startPage(); List<RiskList> list = riskListService.selectRiskListList(riskList); List<RiskList> riskLists = riskListService.selectRiskListList(riskList); List<PreventRiskCheckUnitRespDTO> list = new ArrayList<>(); //todo-2022 新代码，使用DTO,封装进去措施数据 for (RiskList risk : riskLists) { PreventRiskCheckUnitRespDTO respDTO = BeanCopyUtils.copyBean(risk, PreventRiskCheckUnitRespDTO.class); //查询封装管控措施 List<PreventRiskControlMeasure> riskControlMeasureList = riskService.getRiskControlMeasureByRiskId(risk.getRiskListId()); if (riskControlMeasureList != null && riskControlMeasureList.size() > 1){ respDTO.setRiskControlMeasures(riskControlMeasureList); } list.add(respDTO); } return getDataTable(list); }
@@ -15,36 +15,25 @@ insert into prevent_risk_check_unit values(null, #{uuid}, #{baseCheckPointId}, #{controlMeasureId}, #{riskId}) </insert> <!-- List<PreventRiskCheckUnit> getUnitByRiskId(String riskId);--> <select id="getUnitByRiskId" resultMap="BaseResultMap"> select * from prevent_risk_check_unit where risk_id = #{riskId} </select> <update id="updateRiskCheckUnitById"> update prevent_risk_control_measure <set> <if test="baseCheckPointId != null "> base_check_point_id = #{baseCheckPointId}, </if> <if test="controlMeasureId != null"> control_measure_id = #{controlMeasureId}, </if> <if test="riskId != null"> risk_id = #{riskId}, </if> </set> </update> <!-- PreventRiskCheckUnit getUnitByBaseCheckPointId(Long baseCheckPointId);--> <select id="getUnitByBaseCheckPointId" resultMap="BaseResultMap"> select * from prevent_risk_check_unit where base_check_point_id = #{baseCheckPointId} </select> <delete id="deleteRiskCheckUnitByCheckPointIds"> delete from prevent_risk_control_measure where base_check_point_id in <foreach item="checkPointId" collection="array" open="(" separator="," close=")"> #{checkPointId} </foreach> <!-- int deletePointAndMeasure(String id);--> <delete id="deletePointAndMeasure"> delete from prevent_risk_check_unit where base_check_point_id = #{id} </delete> <select id="getPointAndMeasureByPointId" resultMap="BaseResultMap"> select * from prevent_risk_check_unit where base_check_point_id = #{checkPointId} </select> </mapper>
对比新文件 @@ -0,0 +1,21 @@ <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > <mapper namespace="com.ruoyi.doublePrevention.repository.PreventRiskDangerCheckAndMeasureRepository" > <resultMap id="BaseResultMap" type="com.ruoyi.doublePrevention.entity.PreventRiskDangerCheckAndMeasure"> <id column="id" property="id"/> <result column="check_id" property="checkId" /> <result column="danger_check_point_id" property="dangerCheckPointId" /> <result column="base_check_point_id" property="baseCheckPointId" /> <result column="control_measure_id" property="controlMeasureId"/> <result column="check_content" property="checkContent"/> <result column="check_result" property="checkResult"/> </resultMap> <!-- int insertCheckAndMeasure(PreventRiskDangerCheckAndMeasure checkAndMeasure);--> <insert id="insertCheckAndMeasure"> insert into prevent_risk_danger_check_and_measure values (null, #{checkId}, #{dangerCheckPointId}, #{baseCheckPointId}, #{controlMeasureId}, #{checkContent}, #{checkResult}) </insert> </mapper> src/main/resources/mybatis/doublePrevention/PreventRiskDangerCheckLogMapper.xml
对比新文件 @@ -0,0 +1,31 @@ <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > <mapper namespace="com.ruoyi.doublePrevention.repository.PreventRiskDangerCheckLogRepository" > <resultMap id="BaseResultMap" type="com.ruoyi.doublePrevention.entity.PreventRiskDangerCheckLog"> <id column="id" property="id"/> <result column="uuid" property="uuid" /> <result column="job_id" property="jobId"/> <result column="check_status" property="checkStatus"/> <result column="check_id" property="checkId" /> <result column="report_time" property="reportTime"/> <result column="update_report_data_time" property="updateReportDataTime"/> <result column="report_status" property="reportStatus"/> <result column="report_switch" property="reportSwitch"/> </resultMap> <!-- int insertDangerCheckLog(PreventRiskDangerCheckLog dangerCheck);--> <insert id="insertDangerCheckLog"> insert into prevent_risk_danger_check_log values (null, #{uuid}, #{jobId}, #{checkStatus}, #{checkId}, #{reportTime}, #{updateReportDataTime}, #{reportStatus}, #{reportSwitch}) </insert> <!-- int deleteDangerCheck(Long checkId);--> <delete id="deleteDangerCheck"> delete from prevent_risk_danger_check_log where check_id = #{checkId} </delete> </mapper>
对比新文件 @@ -0,0 +1,52 @@ <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > <mapper namespace="com.ruoyi.doublePrevention.repository.PreventRiskDangerInfoRepository" > <resultMap id="BaseResultMap" type="com.ruoyi.doublePrevention.entity.PreventRiskDangerInfo"> <id column="id" property="id"/> <result column="uuid" property="uuid"/> <result column="danger_check_point_id" property="dangerCheckPointId"/> <result column="hazard_code" property="hazardCode"/> <result column="danger_src" property="dangerSrc"/> <result column="danger_desc" property="dangerDesc"/> <result column="danger_reason" property="dangerReason"/> <result column="hazard_danger_type" property="hazardDangerType"/> <result column="danger_state" property="dangerState"/> <result column="timeout_flag" property="timeoutFlag"/> <result column="report_time" property="reportTime"/> <result column="update_report_data_time" property="updateReportDataTime"/> <result column="report_status" property="reportStatus"/> <result column="report_switch" property="reportSwitch"/> </resultMap> <!-- int insertDangerInfo(PreventRiskDangerInfo dangerInfo);--> <insert id="insertDangerInfo"> insert into prevent_risk_danger_info values (null, #{uuid}, #{dangerCheckPointId}, #{hazardCode}, #{dangerSrc}, #{dangerDesc}, #{dangerReason}, #{hazardDangerType}, #{dangerState}, #{timeoutFlag}, #{reportTime}, #{updateReportDataTime}, #{reportStatus}, #{reportSwitch}) </insert> <!-- int updateDangerInfo(PreventRiskDangerInfo dangerInfo);--> <update id="updateDangerInfo"> update prevent_risk_danger_info set hazard_code = #{hazardCode}, danger_src = #{dangerSrc}, danger_desc = #{dangerDesc}, danger_reason = #{dangerReason}, hazard_danger_type = #{hazardDangerType}, danger_state = #{dangerState}, timeout_flag = #{timeoutFlag}, update_report_data_time = #{updateReportDataTime}, report_status = #{reportStatus}, report_switch = #{reportSwitch} where danger_check_point_id = #{dangerCheckPointId} </update> <!-- int deleteDangerInfo(Long id);--> <delete id="deleteDangerInfo"> delete from prevent_risk_danger_info where danger_check_point_id = #{id} </delete> </mapper>
对比新文件 @@ -0,0 +1,37 @@ <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > <mapper namespace="com.ruoyi.doublePrevention.repository.PreventRiskJobAndMeasureRepository" > <resultMap id="BaseResultMap" type="com.ruoyi.doublePrevention.entity.PreventRiskJobAndMeasure"> <id column="id" property="id"/> <result column="job_id" property="jobId"/> <result column="job_uuid" property="jobUuid" /> <result column="measure_id" property="measureId"/> <result column="measure_uuid" property="measureUuid" /> <result column="report_time" property="reportTime"/> <result column="update_report_data_time" property="updateReportDataTime"/> <result column="report_status" property="reportStatus"/> <result column="report_switch" property="reportSwitch"/> </resultMap> <!-- int insertJobAndMeasure(PreventRiskJobAndMeasure jobAndMeasure);--> <insert id="insertJobAndMeasure"> insert into prevent_risk_job_and_measure values(null, #{jobId}, #{jobUuid}, #{measureId}, #{measureUuid}, #{reportTime}, #{updateReportDataTime}, #{reportStatus}, #{reportSwitch}) </insert> <!-- PreventRiskJobAndMeasure getJobAndMeasureByJobId(Long jobId);--> <select id="getJobAndMeasureByJobId" resultMap="BaseResultMap"> select * from prevent_risk_job_and_measure where job_id = #{jobId} limit 1 </select> <!-- int deleteJobAndMeasure(Long jobId);--> <delete id="deleteJobAndMeasure"> delete from prevent_risk_job_and_measure where job_id = #{jobId} </delete> <!-- PreventRiskJobAndMeasure getJobAndMeasure(Long jobId);--> </mapper> src/main/resources/mybatis/doublePrevention/PreventRiskUnitUuidMapper.xml
@@ -6,15 +6,39 @@ <id column="id" property="id"/> <result column="risk_unit_uuid" property="riskUnitUuid"/> <result column="risk_unit_id" property="riskUnitId" /> <result column="delete_status" property="deleteStatus" /> <result column="report_status" property="reportStatus"/> <result column="report_time" property="reportTime"/> <result column="update_report_data_time" property="updateReportDataTime"/> <result column="report_switch" property="reportSwitch"/> </resultMap> <!-- int insertUuid(PreventRiskUnitUuid riskUnitUuid);--> <insert id="insertUuid"> insert into prevent_risk_unit_uuid values(null, #{riskUnitId}, #{riskUnitUuid}, #{deleteStatus}) </insert> <!-- PreventRiskUnitUuid getRiskUnitUuidById(Long id);--> <select id="getRiskUnitUuidById" resultMap="BaseResultMap"> select * from prevent_risk_unit_uuid where delete_status = 0 and risk_unit_id = #{id} </select> <!-- int insertUuid(PreventRiskUnitUuid riskUnitUuid);--> <insert id="insertUuid"> insert into prevent_risk_unit_uuid values(null, #{riskUnitId}, #{riskUnitUuid}, #{reportTime}, #{updateReportDataTime}, #{reportStatus}, #{reportSwitch}) </insert> <!-- PreventRiskUnitUuid updateRiskUnitUuid(PreventRiskUnitUuid riskUnitUuid);--> <update id="updateRiskUnitUuid"> update prevent_risk_unit_uuid set report_status = #{reportStatus}, update_report_data_time = #{updateReportDataTime}, report_switch = #{reportSwitch} where risk_unit_id = #{riskUnitId} </update> <!-- int deleteRiskUnit(String riskListId);--> <delete id="deleteRiskUnit"> delete from prevent_risk_unit_uuid where risk_unit_id in <foreach item="riskListId" collection="array" open="(" separator="," close=")"> #{riskListId} </foreach> </delete> </mapper> src/main/resources/mybatis/tr/HiddenDangerCheckJobMapper.xml
@@ -224,4 +224,10 @@ ) </insert> <!--HiddenDangerCheckJob getJobById(Long jobId);--> <select id="getJobById" resultType="com.ruoyi.project.tr.HiddenDangerCheckJob.domain.HiddenDangerCheckJob"> select * from tr_hidden_danger_check_job where id = #{jobId} </select> </mapper> src/main/resources/mybatis/tr/HiddenDangerCheckPointMapper.xml
@@ -358,7 +358,7 @@ where a.id = #{id} </select> <insert id="insertHiddenDangerCheckPoint" parameterType="HiddenDangerCheckPoint"> <insert id="insertHiddenDangerCheckPoint" parameterType="HiddenDangerCheckPoint" useGeneratedKeys="true" keyProperty="id"> insert into tr_hidden_danger_check_point <trim prefix="(" suffix=")" suffixOverrides=","> <if test="id != null ">id,</if>
