Skip to content

A
amos-boot-biz
Commit 3b4c9369 authored by suhuiguang's avatar suhuiguang
Browse files
Options

1.删除隐患

parent 6b9dc633
Hide whitespace changes
Inline Side-by-side
Showing with 90 additions and 6533 deletions
amos-boot-module/amos-boot-module-api/amos-boot-module-maintenance-api/src/main/java/com/yeejoin/amos/maintenance/common/enums/PlanTaskFinishStatusEnum.java
View file @ 3b4c9369
...@@ -7,7 +7,7 @@ import java.util.Map; ...@@ -7,7 +7,7 @@ import java.util.Map;
public enum PlanTaskFinishStatusEnum { public enum PlanTaskFinishStatusEnum {
NOTSTARTED("未开始",0), NOTSTARTED("未开始",0),
UNDERWAY("处理中",1), UNDERWAY("待执行",1),
FINISHED("已结束",2), FINISHED("已结束",2),
OVERTIME("已超时",3); OVERTIME("已超时",3);
......
amos-boot-module/amos-boot-module-api/amos-boot-module-maintenance-api/src/main/java/com/yeejoin/amos/maintenance/dao/entity/LatentDanger.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.dao.entity;
import lombok.Data;
import org.hibernate.annotations.Where;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import java.util.Date;
/**
* @author keyong
* @title: LatentDanger
* <pre>
* @description: 隐患表
* </pre>
* @date 2021/1/26 14:03
*/
@Entity
@Table(name = "p_latent_danger")
@NamedQuery(name = "LatentDanger.findAll", query = "SELECT c FROM LatentDanger c")
@Where(clause = "deleted=0") //表示未删除的数据
@Data
public class LatentDanger extends BasicEntity {
private static final long serialVersionUID = 1L;
/**
* 业务唯一标识
*/
@Column(name = "business_key")
private String businessKey;
/**
* 公司组织机构
*/
@Column(name = "org_code")
private String orgCode;
/**
* 隐患名称
*/
@Column(name = "danger_name")
private String dangerName;
@Column(name = "instance_id")
private String instanceId;
@Column(name = "current_flow_record_id")
private Long currentFlowRecordId;
/**
* 隐患等级（1：一般隐患；2：重大隐患；0：安全问题）
*/
@Column(name = "danger_level")
private Integer dangerLevel;
/**
* 隐患地点
*/
@Column(name = "danger_position")
private String dangerPosition;
/**
* 隐患类型（1：普通隐患；2：巡检隐患）
*/
@Column(name = "danger_type")
private Integer dangerType;
/**
* 备注
*/
@Column(name = "remark")
private String remark;
/**
* 整改类型（1：常规整改；2：安措计划；3：延期整改）
*/
@Column(name = "reform_type")
private Integer reformType;
/**
* 限制时间
*/
@Column(name = "reform_limit_date")
private Date reformLimitDate;
@Column(name = "overtime_state")
private Integer overtimeState;
@Column(name = "reform_json")
private String reformJson;
/**
* 隐患状态（1：待评审；2：待治理；3：安措计划中；4：逾期未治理；5：待验证；6：治理完毕；7：已撤销）
*/
@Column(name = "danger_state")
private Integer dangerState;
/**
* 发现人
*/
@Column(name = "discoverer_user_id")
private String discovererUserId;
@Column(name = "discoverer_department_id")
private String discovererDepartmentId;
@Column(name = "photo_urls")
private String photoUrls;
/**
* 是否删除（0：否；1：是）
*/
@Column(name = "deleted")
private Integer deleted;
/**
* 记录修改时间
*/
@Column(name = "update_date")
private Date updateDate;
/**
* 延期治理时间
*/
@Column(name = "delay_limit_date")
private Date delayLimitDate;
/**
* 问题描述
*/
@Column(name = "problem_description")
private String problemDescription;
/**
* 原因分析
*/
@Column(name = "reason_analysis")
private String reasonAnalysis;
/**
* 举一反三
*/
@Column(name = "infer_other_things")
private String inferOtherThings;
/**
* 检查记录创建的隐患检查项对应id
*/
@Column(name = "check_input_id")
private Long checkInputId;
}
amos-boot-module/amos-boot-module-api/amos-boot-module-maintenance-api/src/main/java/com/yeejoin/amos/maintenance/dao/entity/LatentDangerFlowRecord.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.dao.entity;
import lombok.Data;
import org.hibernate.annotations.Where;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import java.util.Date;
/**
* @author keyong
* @title: LatentDangerFlowRecord
* <pre>
* @description: 隐患工作流记录表
* </pre>
* @date 2021/1/26 14:18
*/
@Entity
@Table(name = "p_latent_danger_flow_record")
@NamedQuery(name = "LatentDangerFlowRecord.findAll", query = "SELECT c FROM LatentDangerFlowRecord c")
@Where(clause = "deleted=0") //表示未删除的数据
@Data
public class LatentDangerFlowRecord extends BasicEntity {
private static final long serialVersionUID = 1L;
@Column(name = "danger_id")
private Long dangerId;
@Column(name = "action_flag")
private String actionFlag;
@Column(name = "flow_task_name")
private String flowTaskName;
@Column(name = "flow_task_user_ids")
private String flowTaskUserIds;
@Column(name = "flow_task_id")
private String flowTaskId;
@Column(name = "excute_state")
private Integer excuteState;
@Column(name = "excute_user_id")
private String excuteUserId;
@Column(name = "excute_result")
private String excuteResult;
@Column(name = "remark")
private String remark;
@Column(name = "flow_json")
private String flowJson;
/**
* 是否删除（0：否；1：是）
*/
@Column(name = "deleted")
private Integer deleted;
/**
* 记录修改时间
*/
@Column(name = "update_date")
private Date updateDate;
@Column(name = "excute_department_id")
private String excuteDepartmentId;
}
amos-boot-module/amos-boot-module-api/amos-boot-module-maintenance-api/src/main/java/com/yeejoin/amos/maintenance/dao/entity/LatentDangerPatrol.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.dao.entity;
import lombok.Data;
import org.hibernate.annotations.Where;
import org.springframework.data.annotation.Transient;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
import java.util.Date;
/**
* @author keyong
* @title: LatentDangerPatrol
* <pre>
* @description: 隐患巡检关系表
* </pre>
* @date 2021/1/26 14:51
*/
@Entity
@Table(name = "p_latent_danger_patrol")
@NamedQuery(name = "LatentDangerPatrol.findAll", query = "SELECT c FROM LatentDangerPatrol c")
@Where(clause = "deleted=0") //表示未删除的数据
@Data
public class LatentDangerPatrol extends BasicEntity {
private static final long serialVersionUID = 1L;
@Column(name = "latent_danger_id")
private Long latentDangerId;
@Column(name = "point_classify_id")
private Long pointClassifyId;
@Column(name = "check_id")
private Long checkId;
@Column(name = "item_id")
private Long itemId;
@Column(name = "point_id")
private Long pointId;
@Column(name = "route_id")
private Long routeId;
@Column(name = "risk_factor_flow_id")
private String riskFactorFlowId;
@Column(name = "route_point_item_id")
private Long routePointItemId;
/**
* 是否删除（0：否；1：是）
*/
@Column(name = "deleted")
private Integer deleted;
/**
* 检查类型-交大字段，只是前段显示用
*/
@Transient private String checkType;
/**
* 记录修改时间
*/
@Column(name = "update_date")
private Date updateDate;
}
amos-boot-module/amos-boot-module-api/amos-boot-module-maintenance-api/src/main/java/com/yeejoin/amos/maintenance/dao/entity/LatentDangerPhoto.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.dao.entity;
import lombok.Data;
import org.hibernate.annotations.Where;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.NamedQuery;
import javax.persistence.Table;
/**
* @author keyong
* @title: LatentDangerPhoto
* <pre>
* @description: 隐患图片
* </pre>
* @date 2021/1/26 14:50
*/
@Entity
@Table(name = "p_latent_danger_photo")
@NamedQuery(name = "LatentDangerPhoto.findAll", query = "SELECT c FROM LatentDangerPhoto c")
@Where(clause = "deleted=0") //表示未删除的数据
@Data
public class LatentDangerPhoto extends BasicEntity {
private static final long serialVersionUID = 1L;
@Column(name = "biz_code")
private String bizCode;
@Column(name = "url")
private String url;
@Column(name = "biz_id")
private Long bizId;
@Column(name = "deleted")
private String deleted;
@Column(name = "update_date")
private String updateDate;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/controller/LatentDangerController.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.controller;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.alibaba.fastjson.JSONObject;
import com.yeejoin.amos.boot.biz.common.bo.ReginParams;
import com.yeejoin.amos.boot.biz.common.bo.RoleBo;
import com.yeejoin.amos.feign.privilege.model.AgencyUserModel;
import com.yeejoin.amos.maintenance.business.dto.DangerExecuteSubmitDto;
import com.yeejoin.amos.maintenance.business.param.LatentDangerExcuteParam;
import com.yeejoin.amos.maintenance.business.param.LatentDangerListParam;
import com.yeejoin.amos.maintenance.business.param.LatentDangerNormalParam;
import com.yeejoin.amos.maintenance.business.param.LatentDangerPatrolParam;
import com.yeejoin.amos.maintenance.business.param.PageParam;
import com.yeejoin.amos.maintenance.business.service.intfc.ILatentDangerService;
import com.yeejoin.amos.maintenance.business.util.CommonResponse;
import com.yeejoin.amos.maintenance.business.util.CommonResponseUtil;
import com.yeejoin.amos.maintenance.business.util.FileHelper;
import com.yeejoin.amos.maintenance.business.vo.DangerTimeAxisVo;
import com.yeejoin.amos.maintenance.common.enums.DictTypeEnum;
import com.yeejoin.amos.maintenance.core.common.response.DangerListResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
@RestController
@RequestMapping(value = "/api/latent/danger")
@Api(tags = "隐患接口api")
public class LatentDangerController extends AbstractBaseController {
private final Logger logger = LoggerFactory.getLogger(LatentDangerController.class);
@Autowired
private ILatentDangerService iLatentDangerService;
@ApiOperation(value = "创建无码无计划隐患", notes = "创建无码无计划隐患")
@PostMapping(value = "/normal/save")
public CommonResponse saveNormal(@ApiParam(value = "隐患对象", required = true) @RequestBody LatentDangerNormalParam latentDangerParam) {
CommonResponse commonResponse = new CommonResponse();
try {
AgencyUserModel user = getUserInfo();
if (ObjectUtils.isEmpty(user)) {
return CommonResponseUtil.failure("用户session过期");
}
String dangerLevelStr = String.valueOf(latentDangerParam.getDangerLevel());
if (iLatentDangerService.getDangerLevelJsonObject(dangerLevelStr, getToken(), getProduct(), getAppKey(), DictTypeEnum.DANGERLEVEL.getCode()) == null) {
return CommonResponseUtil.failure("隐患等级有误");
}
ReginParams reginParams = getSelectedOrgInfo();
String loginOrgCode = getOrgCode(reginParams);
String deptId = getDepartmentId(reginParams);
String companyId = getCompanyId(reginParams);
String departmentName = getDepartmentName(reginParams);
RoleBo role = reginParams.getRole();
return iLatentDangerService.saveNormal(latentDangerParam, user.getUserId(),
user.getRealName(), deptId, departmentName, companyId, loginOrgCode, role);
} catch (Exception e) {
logger.error("创建普通隐患异常", e.getMessage());
return CommonResponseUtil.failure("系统繁忙，请稍后再试");
}
}
@ApiOperation(value = "创建巡检隐患", notes = "创建巡检隐患")
@PostMapping(value = "/patrol/save")
public CommonResponse savePatrol(@ApiParam(value = "隐患对象", required = true) @RequestBody LatentDangerPatrolParam latentDangerPatrolParam) {
try {
AgencyUserModel user = getUserInfo();
if (ObjectUtils.isEmpty(user)) {
return CommonResponseUtil.failure("用户session过期");
}
ReginParams reginParams = getSelectedOrgInfo();
String loginOrgCode = getOrgCode(reginParams);
String deptId = getDepartmentId(reginParams);
String companyId = getCompanyId(reginParams);
String departmentName = getDepartmentName(reginParams);
RoleBo role = reginParams.getRole();
return iLatentDangerService.savePatrol(latentDangerPatrolParam, user.getUserId(),
user.getRealName(), deptId, departmentName, companyId, loginOrgCode, role);
} catch (Exception e) {
logger.error("创建巡检隐患异常", e.getMessage());
return CommonResponseUtil.failure("系统繁忙，请稍后再试");
}
}
@ApiOperation(value = "隐患列表", notes = "隐患列表")
@PostMapping(value = "/list")
public CommonResponse list(@ApiParam(value = "隐患对象", required = true) @RequestBody LatentDangerListParam latentDangerListParam) {
Date startDate = new Date();
try {
AgencyUserModel user = getUserInfo();
if (ObjectUtils.isEmpty(user)) {
return CommonResponseUtil.failure("用户session过期");
}
ReginParams reginParams = getSelectedOrgInfo();
String loginOrgCode = getOrgCode(reginParams);
String deptId = null;
return iLatentDangerService.list(getToken(), getProduct(), getAppKey(), latentDangerListParam, user, loginOrgCode, deptId);
} catch (Exception e) {
logger.error("隐患列表异常", e.getMessage());
return CommonResponseUtil.failure("系统繁忙，请稍后再试");
}finally {
Date endDate = new Date();
logger.info("-------------------------隐患列表时间" +(endDate.getTime()-startDate.getTime()));
}
}
@ApiOperation(value = "隐患详情", notes = "隐患详情")
@GetMapping(value = "/detail")
public CommonResponse detail(@ApiParam(value = "任务Id", required = true) @RequestParam String id,
@ApiParam(value = "是否完成", required = true) @RequestParam boolean isFinish) {
try {
AgencyUserModel user = getUserInfo();
if (ObjectUtils.isEmpty(user)) {
return CommonResponseUtil.failure("用户session过期");
}
return iLatentDangerService.detail(id, user.getUserId(),isFinish);
} catch (Exception e) {
logger.error("隐患详情异常", e.getMessage());
return CommonResponseUtil.failure("系统繁忙，请稍后再试");
}
}
@ApiOperation(value = "隐患执行记录", notes = "隐患执行记录")
@GetMapping(value = "/listFlowRecord")
public CommonResponse listFlowRecord(@ApiParam(value = "隐患编号", required = true) @RequestParam Long id) {
try {
AgencyUserModel user = getUserInfo();
if (ObjectUtils.isEmpty(user)) {
return CommonResponseUtil.failure("用户session过期");
}
return iLatentDangerService.listFlowRecord(getToken(), getProduct(), getAppKey(), id);
} catch (Exception e) {
logger.error("隐患执行记录异常", e.getMessage());
return CommonResponseUtil.failure("系统繁忙，请稍后再试");
}
}
@ApiOperation(value = "流程执行", notes = "流程执行")
@PostMapping(value = "/excute")
public CommonResponse excute(@ApiParam(value = "隐患对象", required = true) @RequestBody LatentDangerExcuteParam latentDangerExcuteParam) {
try {
AgencyUserModel user = getUserInfo();
if (ObjectUtils.isEmpty(user)) {
return CommonResponseUtil.failure("用户session过期");
}
ReginParams reginParams = getSelectedOrgInfo();
String deptId = getDepartmentId(reginParams);
String departmentName = getDepartmentName(reginParams);
String userRealName = user.getRealName();
String userId = user.getUserId();
RoleBo role = reginParams.getRole();
DangerExecuteSubmitDto executeSubmitDto = iLatentDangerService.execute(latentDangerExcuteParam, userId,
userRealName, deptId, departmentName, role);
// iLatentDangerService.freshRiskJudgmentLangerCount(latentDangerExcuteParam);//更新统计
if (executeSubmitDto.getIsOk()) {
if (!StringUtils.isEmpty(executeSubmitDto.getPointOriginalId())) {
iLatentDangerService.sendLatentDangerExcuteResult(executeSubmitDto);
}
return CommonResponseUtil.success();
} else {
return CommonResponseUtil.failure(executeSubmitDto.getMsg());
}
} catch (Exception e) {
logger.error("流程执行异常", e.getMessage());
return CommonResponseUtil.failure("系统繁忙，请稍后再试");
}
}
@ApiOperation(value = "根据流程实例编号获取隐患信息", notes = "根据流程实例编号获取隐患信息")
@GetMapping(value = "/getByInstanceId")
public CommonResponse getByInstanceId(@ApiParam(value = "流程实例编号", required = true) @RequestParam String instanceId) {
try {
AgencyUserModel user = getUserInfo();
if (ObjectUtils.isEmpty(user)) {
return CommonResponseUtil.failure("用户session过期");
}
return iLatentDangerService.getByInstanceId(instanceId);
} catch (Exception e) {
logger.error("根据流程实例编号获取隐患信息异常", e.getMessage());
return CommonResponseUtil.failure("系统繁忙，请稍后再试");
}
}
@ApiOperation(value = "隐患按错计划流程执行回调", notes = "隐患按错计划流程执行回调")
@PostMapping(value = "/plan/flow/excuteCallBack")
public CommonResponse excuteCallBack(@ApiParam(value = "隐患按错计划流程执行回调对象") @RequestBody JSONObject json) {
try {
AgencyUserModel user = getUserInfo();
if (ObjectUtils.isEmpty(user)) {
return CommonResponseUtil.failure("用户session过期");
}
String instanceId = json.getString("instanceId");
Integer actionType = json.getInteger("actionType");
String remark = json.getString("remark");
ReginParams reginParams = getSelectedOrgInfo();
String deptId = getDepartmentId(reginParams);
String departmentName = getDepartmentName(reginParams);
DangerExecuteSubmitDto executeSubmitDto = iLatentDangerService.excuteCallBack(instanceId, actionType, remark,
getToken(), user.getUserId(), user.getRealName(), deptId, departmentName);
if (executeSubmitDto.getIsOk()) {
if (!StringUtils.isEmpty(executeSubmitDto.getPointOriginalId())) {
iLatentDangerService.sendLatentDangerExcuteResult(executeSubmitDto);
}
return CommonResponseUtil.success();
} else {
return CommonResponseUtil.failure(executeSubmitDto.getMsg());
}
} catch (Exception e) {
logger.error("隐患按错计划流程执行回调异常", e.getMessage());
return CommonResponseUtil.failure("系统繁忙，请稍后再试");
}
}
@ApiOperation(value = "获取隐患等级", notes = "获取隐患等级")
@GetMapping(value = "/dangerLevel")
public CommonResponse getDangerLevel() {
return CommonResponseUtil.success(iLatentDangerService.getDangerLevel(getToken(), getProduct(), getAppKey(), DictTypeEnum.DANGERLEVEL.getCode()));
}
@ApiOperation(value = "获取隐患评审信息", notes = "获取隐患评审信息")
@GetMapping(value = "/review/info")
public CommonResponse getDangerReviewInfo(@ApiParam(value = "隐患id", required = true) @RequestParam Long dangerId) {
return CommonResponseUtil.success(iLatentDangerService.getReviewInfo(dangerId));
}
/**
* 隐患清单
*/
@ApiOperation(value = "隐患清单", notes = "隐患清单")
@PostMapping(value = "/page/list")
public CommonResponse listDanger(@ApiParam(value = "查询条件", required = true) @RequestBody PageParam pageParam) {
AgencyUserModel user = getUserInfo();
if (ObjectUtils.isEmpty(user)) {
return CommonResponseUtil.failure("用户session过期");
}
Page<DangerListResponse> result = iLatentDangerService.listDanger(pageParam);
return CommonResponseUtil.success(result);
}
/**
* 导出隐患清单
*/
@ApiOperation(value = "导出隐患清单", notes = "导出隐患清单")
@PostMapping(value = "/export")
public void exportDangerList(@ApiParam(value = "查询条件") @RequestBody PageParam pageParam,
HttpServletResponse response) {
AgencyUserModel user = getUserInfo();
if (ObjectUtils.isEmpty(user)) {
throw new RuntimeException("用户session过期");
}
pageParam.setPageSize(Integer.MAX_VALUE);
List<DangerListResponse> list = iLatentDangerService.export(pageParam);
String fileName = "隐患清单" + new Date().getTime();
FileHelper.exportExcel(list, "隐患清单", "隐患清单", DangerListResponse.class, fileName + ".xls", response);
}
/**
* <pre>
* @Description: 查询隐患日志
* </pre>
*
* @MethodName:
* @Param: [userId, date]
* @Return: CommonResponse
* @Throws
* @Author keyong
* @Date 2021/3/11 11:42
*/
@ApiOperation(value = "隐患日志", notes = "查询隐患节点信息")
@GetMapping(value = "/listDangerTimeAxis")
public CommonResponse listTimeAxis(@ApiParam(value = "时间") @RequestParam(required = false) Integer dateTime) {
AgencyUserModel user = getUserInfo();
if (ObjectUtils.isEmpty(user)) {
throw new RuntimeException("用户session过期");
}
try {
List<DangerTimeAxisVo> result = iLatentDangerService.queryExecuteLog(dateTime);
return CommonResponseUtil.success(result);
} catch (Exception e) {
return CommonResponseUtil.failure(e.getMessage());
}
}
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/controller/PlanTaskController.java
View file @ 3b4c9369
...@@ -46,6 +46,7 @@ public class PlanTaskController extends AbstractBaseController { ...@@ -46,6 +46,7 @@ public class PlanTaskController extends AbstractBaseController {
/** /**
* 计划执行查询 * 计划执行查询
*
* @param queryRequests * @param queryRequests
* @param commonPageable * @param commonPageable
* @return * @return
...@@ -185,27 +186,6 @@ public class PlanTaskController extends AbstractBaseController { ...@@ -185,27 +186,6 @@ public class PlanTaskController extends AbstractBaseController {
} }
} }
@TycloudOperation(ApiLevel = UserType.AGENCY)
@ApiOperation(value = "维保设施分页列表-mobile", notes = "维保设施分页列表-mobile")
@RequestMapping(value = "/point/{planTaskId}/list", produces = "application/json;charset=UTF-8", method = RequestMethod.GET)
public CommonResponse qryPlanTaskById(
@ApiParam(value = "巡检计划任务ID", required = true) @PathVariable Long planTaskId,
@ApiParam(value = "建筑id", required = true) @RequestParam(value = "buildingId", required = false) String buildingId,
@ApiParam(value = "维保状态", required = true) @RequestParam(value = "isFinish", required = false) String isFinish,
@ApiParam(value = "消防系统id", required = true) @RequestParam(value = "systemId", required = false) String systemId,
@ApiParam(value = "设备编号", required = true) @RequestParam(value = "pointNo", required = false) String pointNo,
@ApiParam(value = "设备名称", required = true) @RequestParam(value = "pointName", required = false) String pointName
) {
Map<String, Object> param = new HashMap<>();
param.put("planTaskId", planTaskId);
param.put("buildingId", buildingId);
param.put("isFinish", isFinish);
param.put("systemId", systemId);
param.put("pointNo", pointNo);
param.put("pointName", pointName);
return CommonResponseUtil.success(planTaskService.getPlanTaskPoints(param));
}
/** /**
* 查询任务列表 * 查询任务列表
* *
...@@ -241,8 +221,30 @@ public class PlanTaskController extends AbstractBaseController { ...@@ -241,8 +221,30 @@ public class PlanTaskController extends AbstractBaseController {
return CommonResponseUtil.success(planTaskService.getPlanTasks(params, pageable)); return CommonResponseUtil.success(planTaskService.getPlanTasks(params, pageable));
} }
@TycloudOperation(ApiLevel = UserType.AGENCY)
@ApiOperation(value = "维保设施分页列表-mobile", notes = "维保设施分页列表-mobile")
@RequestMapping(value = "/point/{planTaskId}/list", produces = "application/json;charset=UTF-8", method = RequestMethod.GET)
public CommonResponse qryPlanTaskById(
@ApiParam(value = "巡检计划任务ID", required = true) @PathVariable Long planTaskId,
@ApiParam(value = "建筑id") @RequestParam(value = "buildingId", required = false) String buildingId,
@ApiParam(value = "维保状态") @RequestParam(value = "isFinish", required = false) String isFinish,
@ApiParam(value = "消防系统id") @RequestParam(value = "systemId", required = false) String systemId,
@ApiParam(value = "设备编号") @RequestParam(value = "pointNo", required = false) String pointNo,
@ApiParam(value = "设备名称") @RequestParam(value = "pointName", required = false) String pointName
) {
Map<String, Object> param = new HashMap<>();
param.put("planTaskId", planTaskId);
param.put("buildingId", buildingId);
param.put("isFinish", isFinish);
param.put("systemId", systemId);
param.put("pointNo", pointNo);
param.put("pointName", pointName);
return CommonResponseUtil.success(planTaskService.getPlanTaskPoints(param));
}
@TycloudOperation(ApiLevel = UserType.AGENCY) @TycloudOperation(ApiLevel = UserType.AGENCY)
@ApiOperation(value = "查询维保设施，检查内容详情") @ApiOperation(value = "查询维保设施，检查内容详情-mobile")
@GetMapping(value = "/task-point-detail") @GetMapping(value = "/task-point-detail")
public CommonResponse planTaskPointDetail( public CommonResponse planTaskPointDetail(
@RequestParam(value = "routePointId") String routePointId, @RequestParam(value = "routePointId") String routePointId,
......
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/dao/mapper/LatentDangerFlowRecordMapper.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.dao.mapper;
import com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerFlowRecordBo;
import com.yeejoin.amos.maintenance.business.vo.DangerTimeAxisVo;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
public interface LatentDangerFlowRecordMapper extends BaseMapper {
Integer save(LatentDangerFlowRecordBo latentDangerFlowRecordBo);
LatentDangerFlowRecordBo getByDangerIdAndActionFlag(@Param("dangerId") Long dangerId, @Param("actionFlag") String actionFlag);
LatentDangerFlowRecordBo getByDangerIdAndCreate(@Param("dangerId") Long dangerId);
LatentDangerFlowRecordBo getById(Long id);
List<LatentDangerFlowRecordBo> listPassByDangerId(Long dangerId);
Integer update(LatentDangerFlowRecordBo latentDangerFlowRecordBo);
LatentDangerFlowRecordBo getNewestRecordByDangerId(Long dangerId);
List<LatentDangerFlowRecordBo> listNewestRecordByDangerIds(List<Long> dangerIds);
List<LatentDangerFlowRecordBo> listByDangerId(Long dangerId);
void deleteByLatentDangerIds(List<Long> dangerIds);
List<DangerTimeAxisVo> listExecuteLog(Map<String, Object> map);
LatentDangerFlowRecordBo getByIdOderByDate(Long dangerId);
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/dao/mapper/LatentDangerMapper.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.dao.mapper;
import com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerBo;
import com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerNoticeBo;
import com.yeejoin.amos.maintenance.business.param.LatentDangerListParam;
import com.yeejoin.amos.maintenance.business.param.PageParam;
import com.yeejoin.amos.maintenance.core.common.response.DangerListResponse;
import org.apache.ibatis.annotations.Param;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public interface LatentDangerMapper extends BaseMapper {
Integer save(LatentDangerBo latentDangerBo);
List<LatentDangerBo> listByMap(Map<String, Object> map);
Long countByMap(Map<String, Object> map);
LatentDangerBo getById(Long id);
Integer update(LatentDangerBo latentDangerBo);
LatentDangerBo getByInstanceId(String instanceId);
List<LatentDangerBo> listOfOvertime();
Integer countNotFinishByFlowId(String flowId);
List<LatentDangerBo> listNotFinishByPointId(HashMap<String, Object> params);
Long countByFlowUserIds(String userId);
Long countNotFinishByTypeAndDeptId(@Param("type") Integer type, @Param("departmentId") String departmentId);
String getNotFinishIdsByTypeAndDeptId(@Param("type") Integer type, @Param("departmentId") String departmentId);
void deleteByIds(List<Long> dangerIds);
/**
* 查询治理期限即将到期的隐患
*
* @return
*/
List<LatentDangerNoticeBo> listNeedNoticeDanger();
/**
* 根据隐患id获取评审信息
*
* @param dangerId
* @return
*/
List<HashMap<String, Object>> getReViewInfo(Long dangerId);
List<DangerListResponse> dangerListByMap(PageParam pageParam);
Long countDangerListByMap(PageParam pageParam);
List<LatentDangerBo> getByBathBusinessKeys(@Param("businessKeys") List<String> businessKeys, @Param("latentDangerListParam") LatentDangerListParam latentDangerListParam);
int countByBathBusinessKeys(@Param("businessKeys") List<String> businessKeys, @Param("latentDangerListParam") LatentDangerListParam latentDangerListParam);
int countByStatus(@Param("businessKeys") List<String> businessKeys);
void updateCheckInputDangerState(@Param("id") Long id, @Param("code") int code);
LatentDangerBo getbyBusinessKey(@Param("businessKey") String businessKey);
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/dao/mapper/LatentDangerPatrolMapper.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.dao.mapper;
import com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerPatrolBo;
import java.util.List;
import java.util.Map;
public interface LatentDangerPatrolMapper extends BaseMapper {
Integer save(LatentDangerPatrolBo latentDangerPatrolBo);
LatentDangerPatrolBo getByDangerId(Long dangerId);
List<LatentDangerPatrolBo> listByMap(Map<String, Object> map);
List<LatentDangerPatrolBo> listByPointId(Long pointId);
List<LatentDangerPatrolBo> queryByPointClassifyIds(List<String> pointClassifyIds);
void deleteByLatentDangerIds(List<Long> latentDangerIds);
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/dao/mapper/RiskJudgmentFillRecordMapper.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.dao.mapper;
import com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentFillRecordBo;
import org.apache.ibatis.annotations.Param;
import java.util.List;
import java.util.Map;
/**
* 风险研判填写记录表
*/
public interface RiskJudgmentFillRecordMapper {
Integer save(RiskJudgmentFillRecordBo riskJudgmentFillRecordBo);
Integer update(RiskJudgmentFillRecordBo riskJudgmentFillRecordBo);
Integer saveBatch(List<RiskJudgmentFillRecordBo> recordList);
void saveBatchWithStatus (List<RiskJudgmentFillRecordBo> recordList);
Integer updateBatch(List<RiskJudgmentFillRecordBo> recordList);
List<RiskJudgmentFillRecordBo> listFillRecordData(@Param("taskId") Long taskId, @Param("type") Integer itemType, @Param("level") Integer itemLevel, @Param("itemParentId") Long itemId);
Long countNotFinishRecordByTaskId(Long taskId);
void updateInputResultAndselectResult(Map<String, Object> map);
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/dao/mapper/RiskJudgmentItemMapper.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.dao.mapper;
import com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentItemBo;
import java.util.List;
/**
* 风险研判项表
*/
public interface RiskJudgmentItemMapper {
Integer save(RiskJudgmentItemBo riskJudgmentItemBo);
Integer update(RiskJudgmentItemBo riskJudgmentItemBo);
List<RiskJudgmentItemBo> listAllItemByDepartmentCode(String departmentCode);
RiskJudgmentItemBo findByItemId(Long itemId);
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/dao/mapper/RiskJudgmentTaskMapper.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.dao.mapper;
import com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentTaskBo;
import org.apache.ibatis.annotations.Param;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 风险研判任务表
*/
public interface RiskJudgmentTaskMapper {
Integer save(RiskJudgmentTaskBo riskJudgmentTaskBo);
Integer update(RiskJudgmentTaskBo riskJudgmentTaskBo);
Integer updateBatch(List<RiskJudgmentTaskBo> list);
List<RiskJudgmentTaskBo> listByDateAndStatus(@Param("date") String date, @Param("status") Integer status);
List<RiskJudgmentTaskBo> listByMap(Map<String, Object> map);
Long countByMap(Map<String, Object> map);
RiskJudgmentTaskBo getById(Long id);
Long countByFlowUserIds(String userId);
RiskJudgmentTaskBo getByInstanceIdAndTaskDefinitionKey(@Param("instanceId") String instanceId, @Param("taskDefinitionKey") String taskDefinitionKey);
void updatetTaskStatusByInstanceId(HashMap<String, Object> map);
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/entity/mybatis/LatentDangerFlowRecordBoExtend.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.entity.mybatis;
import lombok.Data;
@Data
public class LatentDangerFlowRecordBoExtend {
private String executeDepartmentName = "";
private String executeUserName;
private String executeTime;
private Integer dangerOvertimeState;
private Integer dangerState;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/entity/mybatis/LatentDangerPatrolBoExtend.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.entity.mybatis;
import lombok.Data;
@Data
public class LatentDangerPatrolBoExtend {
private String itemName;
private String itemBasis;
private String pointName;
private String pointLevel;
private String pointNo;
private String planName;
private String planType;
private String routeName;
private String itemRemark;
private String checkTime;
private String checkUserId;
private String classifyName;
private String pointDepartMentId;
private String classifyOriginalId;
private String pointOriginalId;
private String itemOriginalId;
private Integer executeRate;
private String checkDepartmentId;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/entity/mybatis/RiskJudgmentFillRecordBo.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.entity.mybatis;
import com.yeejoin.amos.maintenance.business.entity.mybatis.extend.RiskJudgmentFillRecordExtend;
import lombok.Data;
import java.util.Date;
/**
* 风险研判填写记录表
*/
@Data
public class RiskJudgmentFillRecordBo extends RiskJudgmentFillRecordExtend {
/**
* 主键自增
*/
private Long id;
/**
* 风险研判任务编号
*/
private Long taskId;
/**
* 风险研判项编号
*/
private Long itemId;
/**
* 选择结果
*/
private String selectResult;
/**
* 填写结果
*/
private String inputResult;
/**
* 备注结果
*/
private String remarkResult;
/**
* 拍照结果
*/
private String photoResult;
private Integer itemFinish;
private String orgCode;
/**
* 是否删除（0：否；1：是）
*/
private Integer deleted;
/**
* 记录创建时间
*/
private Date createDate;
/**
* 记录修改时间
*/
private Date updateDate;
/**
* 排序-0开始
*/
private Integer orderNum;
/**
* 危险作业/其他隐患风险id(逗号分隔)（一般风险、低风险不保存）
*/
private String extraIds;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/entity/mybatis/RiskJudgmentItemBo.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.entity.mybatis;
import lombok.Data;
import java.util.Date;
/**
* 风险研判项表
*/
@Data
public class RiskJudgmentItemBo {
/**
* 主键自增
*/
private Long id;
/**
* 唯一标识
*/
private String itemFlag;
/**
* 风险研判项级别
*/
private Integer itemLevel;
/**
* 风险研判项类型（1：风险研判表；2：风险研判采集表）
*/
private Integer itemType;
/**
* 节点名称
*/
private String itemName;
/**
* 父节点编号
*/
private Long itemParentId;
private Integer itemCanCopy;
/**
* 选项名称
*/
private String selectName;
/**
* 选项是否需要（0：否；1：是）
*/
private Integer selectIsNeed;
/**
* 选项是否必选（0：否；1：是）
*/
private Integer selectIsRequired;
/**
* 选项json[{"id":1,"name":"否"}]
*/
private String selectJson;
/**
* 输入项名称
*/
private String inputName;
private Integer inputType;
private Integer inputCanEdit;
/**
* 输入是否需要（0：否；1：是）
*/
private Integer inputIsNeed;
/**
* 输入项是否必填（0：否；1：是）
*/
private Integer inputIsRequired;
/**
* 备注是否需要（0：否；1：是）
*/
private Integer remarkIsNeed;
/**
* 备注是否必填（0：否；1：是）
*/
private Integer remarkIsRequired;
/**
* 拍照是否需要（0：否；1：是）
*/
private Integer photoIsNeed;
/**
* 拍照是否必填（0：否；1：是）
*/
private Integer photoIsRequired;
private String orgCode;
/**
* 是否删除（0：否；1：是）
*/
private Integer deleted;
/**
* 记录创建时间
*/
private Date createDate;
/**
* 记录修改时间
*/
private Date updateDate;
/**
* 排序-0开始
*/
private Integer orderNum;
/**
* 部门code
*/
private String deptCode;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/entity/mybatis/RiskJudgmentTaskBo.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.entity.mybatis;
import lombok.Data;
import java.util.Date;
/**
* 风险研判任务表
*/
@Data
public class RiskJudgmentTaskBo {
/**
* 主键自增
*/
private Long id;
/**
* 风险研判名称
*/
private String taskName;
/**
* 部门编号
*/
private String departmentId;
/**
* 状态（0：未开始；1：进行中；2：已超时；3：已提交）
*/
private Integer taskStatus;
/**
* 风险研判日期（今天8:00-明天8:00）
*/
private Date taskDate;
/**
* 提交时间
*/
private Date taskCommitDate;
private String currentFlowTaskId;
private String taskDefinitionKey;
/**
* 可执行用户（多个逗号隔开）
*/
private String flowUserIds;
/**
* 业务唯一标识
*/
private String businessKey;
/**
* 工作流实例编号
*/
private String flowInstanceId;
private String orgCode;
/**
* 是否删除（0：否；1：是）
*/
private Integer deleted;
/**
* 记录创建时间
*/
private Date createDate;
/**
* 记录修改时间
*/
private Date updateDate;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/entity/mybatis/extend/LatentDangerBo.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.entity.mybatis.extend;
import lombok.Data;
import java.util.Date;
/**
* 隐患表
*/
@Data
public class LatentDangerBo {
/**
* 主键自增
*/
private Long id;
/**
* 业务唯一标识
*/
private String businessKey;
/**
* 公司组织机构
*/
private String orgCode;
/**
* 隐患名称
*/
private String dangerName;
private String instanceId;
private Long currentFlowRecordId;
/**
* 隐患等级（1：一般隐患；2：重大隐患；0：安全问题）
*/
private Integer dangerLevel;
/**
* 隐患地点
*/
private String dangerPosition;
/**
* 隐患类型（1：普通隐患；2：巡检隐患）
*/
private Integer dangerType;
/**
* 备注
*/
private String remark;
/**
* 整改类型（1：常规整改；2：安措计划；3：延期整改）
*/
private Integer reformType;
/**
* 限制时间
*/
private Date reformLimitDate;
private Integer overtimeState;
private String reformJson;
/**
* 隐患状态（1：待评审；2：待治理；3：安措计划中；4：逾期未治理；5：待验证；6：治理完毕；7：已撤销）
*/
private Integer dangerState;
/**
* 发现人
*/
private String discovererUserId;
private String discovererDepartmentId;
private String photoUrls;
/**
* 是否删除（0：否；1：是）
*/
private Integer deleted;
/**
* 记录创建时间
*/
private Date createDate;
/**
* 记录修改时间
*/
private Date updateDate;
/**
* 延期治理时间
*/
private Date delayLimitDate;
/**
* 问题描述
*/
private String problemDescription;
/**
* 原因分析
*/
private String reasonAnalysis;
/**
* 举一反三
*/
private String inferOtherThings;
/**
* 检查记录创建的隐患检查项对应id
*/
private Long checkInputId;
/**
* 建筑id
*/
private Long structureId;
/**
* 建筑名称
*/
private String structureName;
private String instanceKey;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/entity/mybatis/extend/LatentDangerFlowRecordBo.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.entity.mybatis.extend;
import com.yeejoin.amos.maintenance.business.entity.mybatis.LatentDangerFlowRecordBoExtend;
import lombok.Data;
import java.util.Date;
@Data
public class LatentDangerFlowRecordBo extends LatentDangerFlowRecordBoExtend {
private Long id;
private Long dangerId;
private String actionFlag;
private String flowTaskName;
private String flowTaskUserIds;
private String flowTaskId;
private Integer excuteState;
private String excuteUserId;
private String excuteResult;
private String remark;
private String flowJson;
/**
* 是否删除（0：否；1：是）
*/
private Integer deleted;
/**
* 记录创建时间
*/
private Date createDate;
/**
* 记录修改时间
*/
private Date updateDate;
private String excuteDepartmentId;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/entity/mybatis/extend/LatentDangerNoticeBo.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.entity.mybatis.extend;
import java.util.Date;
public class LatentDangerNoticeBo {
/**
* 隐患id
*/
private Long dangerId;
private String orgCode;
/**
* 隐患状态
*/
private Integer dangerState;
/**
* 隐患名称
*/
private String dangerName;
/**
* 治理期限
*/
private Date reformLimitDate;
/**
* 消息接收人（隐患治理人）
*/
private String receiverIds;
private String instanceId;
public String getInstanceId() {
return instanceId;
}
public void setInstanceId(String instanceId) {
this.instanceId = instanceId;
}
public Long getDangerId() {
return dangerId;
}
public void setDangerId(Long dangerId) {
this.dangerId = dangerId;
}
public String getOrgCode() {
return orgCode;
}
public void setOrgCode(String orgCode) {
this.orgCode = orgCode;
}
public Integer getDangerState() {
return dangerState;
}
public void setDangerState(Integer dangerState) {
this.dangerState = dangerState;
}
public String getDangerName() {
return dangerName;
}
public void setDangerName(String dangerName) {
this.dangerName = dangerName;
}
public Date getReformLimitDate() {
return reformLimitDate;
}
public void setReformLimitDate(Date reformLimitDate) {
this.reformLimitDate = reformLimitDate;
}
public String getReceiverIds() {
return receiverIds;
}
public void setReceiverIds(String receiverIds) {
this.receiverIds = receiverIds;
}
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/entity/mybatis/extend/LatentDangerPatrolBo.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.entity.mybatis.extend;
import com.yeejoin.amos.maintenance.business.entity.mybatis.LatentDangerPatrolBoExtend;
import lombok.Data;
import java.util.Date;
/**
* 隐患巡检关系表
*/
@Data
public class LatentDangerPatrolBo extends LatentDangerPatrolBoExtend {
private Long id;
private Long latentDangerId;
private Long pointClassifyId;
private Long checkId;
private Long itemId;
private Long pointId;
private Long routeId;
private String riskFactorFlowId;
private Long routePointItemId;
/**
* 是否删除（0：否；1：是）
*/
private Integer deleted;
/**
* 检查类型-交大字段，只是前段显示用
*/
private String checkType;
/**
* 记录创建时间
*/
private Date createDate;
/**
* 记录修改时间
*/
private Date updateDate;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/param/LatentDangerExcuteParam.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.param;
import com.alibaba.fastjson.JSONObject;
import lombok.Data;
@Data
public class LatentDangerExcuteParam {
private Long flowRecordId;
private String taskId;
private Integer excuteType;
private String remark;
private String nextCanActionUser;
private String reformLimitDate;
private JSONObject flowJson;
private String delayLimitDate;
/**
* 隐患id
*/
private Long dangerId;
/**
* 延期治理是否需要公司审核
*/
private Integer needCompanyVerify;
/**
* 原因分析
*/
private String reasonAnalysis;
/**
* 举一反三
*/
private String inferOtherThings;
/**
*问题描述
*/
private String problemDescription;
private Integer dangerLevel;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/param/LatentDangerListParam.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.param;
import com.yeejoin.amos.maintenance.core.common.request.CommonPageable;
import lombok.Data;
/**
* @author keyong
* @title: LatentDangerListParam
* <pre>
* @description: TODO
* </pre>
* @date 2021/1/26 14:49
*/
@Data
public class LatentDangerListParam extends CommonPageable {
/**
* 0:全部；1：我的
*/
private Integer belongType;
/**
* 0:全部；1：待评审；2：待治理；3：安措计划中；4：待验证；5：治理完毕；6：已撤销；7：延期治理中；8：延期治理待车间部门审核；9：延期治理待公司审核
*/
private Integer dangerState;
/**
* 是否已处理（1：是；2：否）
*/
private Boolean isHandle;
/**
* -1:全部；1：一般隐患；2：重大隐患；0：安全问题
*/
private Integer dangerLevel;
private String dangerName;
private String userId;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/param/LatentDangerNormalParam.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.param;
import lombok.Data;
/**
* @author keyong
* @title: LatentDangerNormalParam
* <pre>
* @description: 隐患
* </pre>
* @date 2021/1/26 14:46
*/
@Data
public class LatentDangerNormalParam {
/**
* 隐患名称
*/
private String dangerName;
/**
* 隐患等级（1：一般隐患；2：重大隐患；3：安全问题）
*/
private Integer dangerLevel;
/**
* 隐患地点
*/
private String dangerPosition;
/**
* 备注
*/
private String remark;
/**
* 拍照路径集合（多个逗号分开）
*/
private String photoUrls;
/**
* 建筑id
*/
private Long structureId;
/**
* 建筑名称
*/
private String structureName;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/param/LatentDangerPatrolItemParam.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.param;
import lombok.Data;
/**
* @author keyong
* @title: LatentDangerPatrolItemParam
* <pre>
* @description: TODO
* </pre>
* @date 2021/1/26 14:48
*/
@Data
public class LatentDangerPatrolItemParam {
private Long itemId;
/**
* 隐患等级（1：一般隐患；2：重大隐患；0：安全问题）
*/
private Integer dangerLevel;
private Long routePointItemId;
/**
* 问题描述
*/
private String remark;
/**
* p_check_input 主键id
*/
private Long checkInputId;
/**
* 建筑id
*/
private Long structureId;
/**
* 建筑名称
*/
private String structureName;
private String instanceKey;
/*
* 隐患名称
* */
private String name;
private String limitDate;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/param/LatentDangerPatrolParam.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.param;
import lombok.Data;
import java.util.List;
/**
* @author keyong
* @title: LatentDangerPatrolParam
* <pre>
* @description: TODO
* </pre>
* @date 2021/1/26 14:47
*/
@Data
public class LatentDangerPatrolParam {
private List<LatentDangerPatrolItemParam> itemList;
private Long checkId;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/service/impl/AppServiceImpl.java
View file @ 3b4c9369
...@@ -3,145 +3,96 @@ package com.yeejoin.amos.maintenance.business.service.impl; ...@@ -3,145 +3,96 @@ package com.yeejoin.amos.maintenance.business.service.impl;
import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject; import com.alibaba.fastjson.JSONObject;
import com.yeejoin.amos.maintenance.business.dao.mapper.LatentDangerMapper;
import com.yeejoin.amos.maintenance.business.dao.mapper.PlanTaskMapper; import com.yeejoin.amos.maintenance.business.dao.mapper.PlanTaskMapper;
import com.yeejoin.amos.maintenance.business.dao.mapper.RiskJudgmentTaskMapper;
import com.yeejoin.amos.maintenance.business.dao.repository.AppVersionDao; import com.yeejoin.amos.maintenance.business.dao.repository.AppVersionDao;
import com.yeejoin.amos.maintenance.business.dao.repository.IMsgSubscribeDao; import com.yeejoin.amos.maintenance.business.dao.repository.IMsgSubscribeDao;
import com.yeejoin.amos.maintenance.business.param.UserMsgInitParam;
import com.yeejoin.amos.maintenance.business.service.intfc.IAppService; import com.yeejoin.amos.maintenance.business.service.intfc.IAppService;
import com.yeejoin.amos.maintenance.business.service.intfc.IMsgSubscribeService; import com.yeejoin.amos.maintenance.business.service.intfc.IMsgSubscribeService;
import com.yeejoin.amos.maintenance.common.remote.RemoteWorkFlowService; import com.yeejoin.amos.maintenance.common.enums.MsgSubscribeTypeEnum;
import com.yeejoin.amos.maintenance.common.enums.YesOrNoEnum; import com.yeejoin.amos.maintenance.common.enums.YesOrNoEnum;
import com.yeejoin.amos.maintenance.common.remote.RemoteWorkFlowService;
import com.yeejoin.amos.maintenance.dao.entity.AppVersion;
import com.yeejoin.amos.maintenance.dao.entity.MsgSubscribe;
import org.assertj.core.util.Lists; import org.assertj.core.util.Lists;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import com.yeejoin.amos.maintenance.business.param.UserMsgInitParam;
import com.yeejoin.amos.maintenance.common.enums.MsgSubscribeTypeEnum;
import com.yeejoin.amos.maintenance.dao.entity.AppVersion;
import com.yeejoin.amos.maintenance.dao.entity.MsgSubscribe;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
@Service("iAppService") @Service("iAppService")
public class AppServiceImpl implements IAppService { public class AppServiceImpl implements IAppService {
@Autowired @Autowired
private IMsgSubscribeDao msgSubscribeDao; private IMsgSubscribeDao msgSubscribeDao;
@Autowired @Autowired
private AppVersionDao appVersionDao; private AppVersionDao appVersionDao;
@Autowired @Autowired
private RemoteWorkFlowService remoteWorkFlowService; private RemoteWorkFlowService remoteWorkFlowService;
@Autowired private IMsgSubscribeService msgSubscribeService;
@Autowired @Autowired
private LatentDangerMapper latentDangerMapper; private IMsgSubscribeService msgSubscribeService;
@Autowired @Autowired
private PlanTaskMapper planTaskMapper; private PlanTaskMapper planTaskMapper;
@Autowired
private RiskJudgmentTaskMapper riskJudgmentTaskMapper;
@Override
public AppVersion queryAppLastVersion() {
// TODO Auto-generated method stub
return appVersionDao.findLastVersion();
}
@Override
public AppVersion queryAppLastVersion() {
// TODO Auto-generated method stub
return appVersionDao.findLastVersion();
}
/**
* 新增用户时初始化消息订阅(p_msg_subscribe)表
*
* @param userDTO
*/
@Override
public List<MsgSubscribe> saveUserMsgInit(UserMsgInitParam userInitParam) {
Long count = msgSubscribeDao.countByUserId(userInitParam.getUserId());
if (count > 0) { // 已存在用户订阅，直接返回
return msgSubscribeService.queryMsgSubscribes(userInitParam.getUserId());
}
List<MsgSubscribe> msgConfigs = new ArrayList<MsgSubscribe>();
for (MsgSubscribeTypeEnum type : MsgSubscribeTypeEnum.values()) {
MsgSubscribe msgSub = new MsgSubscribe();
msgSub.setOrgCode(userInitParam.getOrgCode());
msgSub.setUserId(userInitParam.getUserId());
if (type.equals(MsgSubscribeTypeEnum.PLANBEGIN)
|| type.equals(MsgSubscribeTypeEnum.PLANWARN)
|| type.equals(MsgSubscribeTypeEnum.PLANEND)) {
msgSub.setAttribute1("False");
msgSub.setAttribute2(10 + "");
} else if (type.equals(MsgSubscribeTypeEnum.CHECKTYPE)
|| type.equals(MsgSubscribeTypeEnum.CHECKEMAIL)) {
msgSub.setAttribute1("error");
}
/**else if (type.equals(MsgSubscribeTypeEnum.ROUTE) && !userInitParam.getInit()) {
// TODO 查询该用户下的路线
String roleTypeName = userInitParam.getRoleTypeName();
String orgCode = userInitParam.getOrgCode();
Specification<Route> spec = new Specification<Route>() {// 构建查询条件 /**
* 新增用户时初始化消息订阅(p_msg_subscribe)表
@Override *
public Predicate toPredicate(Root<Route> root, CriteriaQuery<?> query, CriteriaBuilder cb) { * @param userDTO
List<Predicate> predicate = new ArrayList<>(); */
if (!ObjectUtils.isEmpty(roleTypeName)) { @Override
if (XJConstant.ROLE_NAME_ADMIN.equals(roleTypeName) public List<MsgSubscribe> saveUserMsgInit(UserMsgInitParam userInitParam) {
|| XJConstant.ROLE_NAME_SUPERADMIN.equals(roleTypeName)) { Long count = msgSubscribeDao.countByUserId(userInitParam.getUserId());
predicate.add(cb.like(root.get("orgCode").as(String.class), orgCode + "%")); if (count > 0) { // 已存在用户订阅，直接返回
} else if (XJConstant.ROLE_NAME_DEPTADMIN.equals(roleTypeName)) { return msgSubscribeService.queryMsgSubscribes(userInitParam.getUserId());
String orgCode_ = orgCode; }
if (orgCode.indexOf("-") != -1) { List<MsgSubscribe> msgConfigs = new ArrayList<MsgSubscribe>();
orgCode_ = orgCode.substring(0, orgCode.indexOf("-")); for (MsgSubscribeTypeEnum type : MsgSubscribeTypeEnum.values()) {
} MsgSubscribe msgSub = new MsgSubscribe();
predicate.add(cb.like(root.get("orgCode").as(String.class), orgCode_ + "%")); msgSub.setOrgCode(userInitParam.getOrgCode());
} else { msgSub.setUserId(userInitParam.getUserId());
predicate.add(cb.equal(root.get("orgCode").as(String.class), orgCode)); if (type.equals(MsgSubscribeTypeEnum.PLANBEGIN)
} || type.equals(MsgSubscribeTypeEnum.PLANWARN)
} || type.equals(MsgSubscribeTypeEnum.PLANEND)) {
Predicate[] pre = new Predicate[predicate.size()]; msgSub.setAttribute1("False");
return query.where(predicate.toArray(pre)).getRestriction(); msgSub.setAttribute2(10 + "");
} } else if (type.equals(MsgSubscribeTypeEnum.CHECKTYPE)
|| type.equals(MsgSubscribeTypeEnum.CHECKEMAIL)) {
}; msgSub.setAttribute1("error");
List<Route> routeList = iRouteDao.findAll(spec); }
List<Long> routeIdList = new ArrayList<>(); msgSub.setMsgType(type.getName());
for (Route route : routeList) { msgSubscribeDao.saveAndFlush(msgSub);
routeIdList.add(route.getId()); msgConfigs.add(msgSub);
}
String routeIds = StringUtils.join(routeIdList.toArray(), ",");
msgSub.setAttribute1(routeIds);
}*/
msgSub.setMsgType(type.getName());
msgSubscribeDao.saveAndFlush(msgSub);
msgConfigs.add(msgSub);
} }
return msgConfigs; return msgConfigs;
} }
@Override @Override
public List<String> getHaveToDoList(String userId) { public List<String> getHaveToDoList(String userId) {
int taskCount = planTaskMapper.getCurrentPlanTaskCount(userId); int taskCount = planTaskMapper.getCurrentPlanTaskCount(userId);
List<String> havetoDoList = Lists.newArrayList(); List<String> havetoDoList = Lists.newArrayList();
if (taskCount > 0) { if (taskCount > 0) {
havetoDoList.add("planPatrol"); havetoDoList.add("planPatrol");
} }
JSONObject respBody = remoteWorkFlowService.pageTask(userId,Integer.parseInt(YesOrNoEnum.YES.getCode())); JSONObject respBody = remoteWorkFlowService.pageTask(userId, Integer.parseInt(YesOrNoEnum.YES.getCode()));
JSONArray taskJsonList = respBody.getJSONArray("data"); JSONArray taskJsonList = respBody.getJSONArray("data");
List<JSONObject> taskList = JSONObject.parseArray(taskJsonList.toJSONString(), JSONObject.class); List<JSONObject> taskList = JSONObject.parseArray(taskJsonList.toJSONString(), JSONObject.class);
List<String> bussinessKeys = new ArrayList<>(); List<String> bussinessKeys = new ArrayList<>();
for (JSONObject json : taskList) { for (JSONObject json : taskList) {
bussinessKeys.add(json.getString("businessKey")); bussinessKeys.add(json.getString("businessKey"));
} }
Integer dangerCount = latentDangerMapper.countByStatus(bussinessKeys);
if(dangerCount > 0){
havetoDoList.add("waitHandle");
}
return havetoDoList; return havetoDoList;
} }
} }
\ No newline at end of file
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/service/impl/LatentDangerServiceImpl.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.service.impl;
import static org.typroject.tyboot.core.foundation.context.RequestContext.getProduct;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.typroject.tyboot.core.foundation.context.RequestContext;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.yeejoin.amos.boot.biz.common.bo.DepartmentBo;
import com.yeejoin.amos.boot.biz.common.bo.RoleBo;
import com.yeejoin.amos.feign.privilege.model.AgencyUserModel;
import com.yeejoin.amos.feign.privilege.model.DepartmentModel;
import com.yeejoin.amos.maintenance.business.constants.XJConstant;
import com.yeejoin.amos.maintenance.business.dao.mapper.CheckInputMapper;
import com.yeejoin.amos.maintenance.business.dao.mapper.LatentDangerFlowRecordMapper;
import com.yeejoin.amos.maintenance.business.dao.mapper.LatentDangerMapper;
import com.yeejoin.amos.maintenance.business.dao.mapper.LatentDangerPatrolMapper;
import com.yeejoin.amos.maintenance.business.dao.mapper.RiskFactorCmMapper;
import com.yeejoin.amos.maintenance.business.dao.mapper.RiskFactorMapper;
import com.yeejoin.amos.maintenance.business.dao.mapper.RiskSourceMapper;
import com.yeejoin.amos.maintenance.business.dao.repository.ICheckDao;
import com.yeejoin.amos.maintenance.business.dao.repository.ICheckShotDao;
import com.yeejoin.amos.maintenance.business.dao.repository.IInputItemDao;
import com.yeejoin.amos.maintenance.business.dao.repository.IPointClassifyDao;
import com.yeejoin.amos.maintenance.business.dto.DangerExecuteSubmitDto;
import com.yeejoin.amos.maintenance.business.dto.InputCheckDto;
import com.yeejoin.amos.maintenance.business.entity.mybatis.DangerResultBo;
import com.yeejoin.amos.maintenance.business.entity.mybatis.DictBo;
import com.yeejoin.amos.maintenance.business.entity.mybatis.RiskFactorBo;
import com.yeejoin.amos.maintenance.business.entity.mybatis.RiskSourceBo;
import com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerBo;
import com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerFlowRecordBo;
import com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerNoticeBo;
import com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerPatrolBo;
import com.yeejoin.amos.maintenance.business.feign.Business;
import com.yeejoin.amos.maintenance.business.feign.EquipFeign;
import com.yeejoin.amos.maintenance.business.param.LatentDangerExcuteParam;
import com.yeejoin.amos.maintenance.business.param.LatentDangerListParam;
import com.yeejoin.amos.maintenance.business.param.LatentDangerNormalParam;
import com.yeejoin.amos.maintenance.business.param.LatentDangerPatrolItemParam;
import com.yeejoin.amos.maintenance.business.param.LatentDangerPatrolParam;
import com.yeejoin.amos.maintenance.business.param.PageParam;
import com.yeejoin.amos.maintenance.business.service.intfc.ILatentDangerService;
import com.yeejoin.amos.maintenance.business.service.intfc.IRiskJudgmentTaskService;
import com.yeejoin.amos.maintenance.business.util.CommonResponse;
import com.yeejoin.amos.maintenance.business.util.CommonResponseUtil;
import com.yeejoin.amos.maintenance.business.util.DateUtil;
import com.yeejoin.amos.maintenance.business.util.RandomUtil;
import com.yeejoin.amos.maintenance.business.vo.DangerTimeAxisVo;
import com.yeejoin.amos.maintenance.business.vo.LatentDangerDetailRiskVo;
import com.yeejoin.amos.maintenance.business.vo.LatentDangerDetailVo;
import com.yeejoin.amos.maintenance.business.vo.LatentDangerListVo;
import com.yeejoin.amos.maintenance.common.enums.CheckModeEnum;
import com.yeejoin.amos.maintenance.common.enums.DangerHandleStateEnum;
import com.yeejoin.amos.maintenance.common.enums.DictTypeEnum;
import com.yeejoin.amos.maintenance.common.enums.ExecuteStateEnum;
import com.yeejoin.amos.maintenance.common.enums.InstanceKeyEnum;
import com.yeejoin.amos.maintenance.common.enums.LatentDangerExcuteTypeEnum;
import com.yeejoin.amos.maintenance.common.enums.LatentDangerLevelEnum;
import com.yeejoin.amos.maintenance.common.enums.LatentDangerOvertimeStateEnum;
import com.yeejoin.amos.maintenance.common.enums.LatentDangerReformTypeEnum;
import com.yeejoin.amos.maintenance.common.enums.LatentDangerStateEnum;
import com.yeejoin.amos.maintenance.common.enums.LatentDangerTypeEnum;
import com.yeejoin.amos.maintenance.common.enums.RiskFactorsCmStatusEnum;
import com.yeejoin.amos.maintenance.common.remote.RemoteSpcService;
import com.yeejoin.amos.maintenance.common.remote.RemoteWebSocketServer;
import com.yeejoin.amos.maintenance.common.remote.RemoteWorkFlowService;
import com.yeejoin.amos.maintenance.core.async.AsyncTask;
import com.yeejoin.amos.maintenance.core.common.request.LatentDangerResultPushSpcRequest;
import com.yeejoin.amos.maintenance.core.common.response.DangerListResponse;
import com.yeejoin.amos.maintenance.core.util.StringUtil;
import com.yeejoin.amos.maintenance.dao.entity.Check;
import com.yeejoin.amos.maintenance.dao.entity.CheckShot;
import com.yeejoin.amos.maintenance.dao.entity.InputItem;
import com.yeejoin.amos.maintenance.dao.entity.PointClassify;
import com.yeejoin.amos.maintenance.exception.YeeException;
import com.yeejoin.amos.maintenance.feign.RemoteSecurityService;
import com.yeejoin.amos.maintenance.mqtt.WebMqttComponent;
@Service("latentDangerService")
public class LatentDangerServiceImpl implements ILatentDangerService {
private final Logger logger = LoggerFactory.getLogger(LatentDangerServiceImpl.class);
@Autowired
private RemoteWorkFlowService remoteWorkFlowService;
@Autowired
private RemoteSecurityService remoteSecurityService;
@Autowired
private LatentDangerMapper latentDangerMapper;
@Autowired
private RiskFactorMapper riskFactorMapper;
@Autowired
private RiskFactorCmMapper riskFactorCmMapper;
@Autowired
private RiskSourceMapper riskSourceMapper;
@Autowired
private LatentDangerFlowRecordMapper latentDangerFlowRecordMapper;
@Autowired
private LatentDangerPatrolMapper latentDangerPatrolMapper;
@Autowired
private IPointClassifyDao iPointClassifyDao;
@Autowired
private CheckInputMapper checkInputMapper;
@Autowired
private IInputItemDao iInputItemDao;
@Autowired
private RemoteSpcService remoteSpcService;
@Autowired
private ICheckShotDao iCheckShotDao;
@Autowired
private ICheckDao iCheckDao;
@Autowired
private AsyncTask asyncTask;
@Autowired
private RemoteWebSocketServer remoteWebSocketServer;
@Autowired
private IRiskJudgmentTaskService iRiskJudgmentTaskService;
@Autowired
private Business business;
@Autowired
EquipFeign equipFeign;
private static final String permissionType = "SUBMENU";
private static final String acctivePermissionType = "activitiItem";
private static final String path = "AppNormalLatentDangerReview";
@Value("${server.port}")
private String port;
// @Value("${LatentDanger.flow.photoUrls}")
// private String photoUrlPre;
@Value("${file.url}")
private String fileUrl;
@Value("${file.url}")
private String fileServerAddress;
@Value("${params.work.flow.processDefinitionKey}")
private String processDefinitionKey;
@Value("${params.work.flow.normalProcessDefinitionKey}")
private String normalProcessDefinitionKey;
@Value("${amosRefresh.danger.topic}")
private String dangerTopic;
@Autowired
private WebMqttComponent webMqttComponent;
@Transactional
@Override
public CommonResponse saveNormal(LatentDangerNormalParam latentDangerParam, String userId, String userRealName, String departmentId, String departmentName, String companyId, String orgCode, RoleBo role) {
String businessKey = RandomUtil.buildOrderNo();
LatentDangerBo latentDangerBo = saveLatentDanger("", "", latentDangerParam.getRemark(),
userId, departmentId, businessKey, orgCode, latentDangerParam.getDangerName(), latentDangerParam.getDangerLevel()
, latentDangerParam.getDangerPosition(), LatentDangerTypeEnum.随手拍,
latentDangerParam.getPhotoUrls(), 0L, latentDangerParam.getStructureId(), latentDangerParam.getStructureName(), InstanceKeyEnum.NORMAL.getCode());
// 更新p_check_input表state字段
updateCheckInputDangerState(latentDangerBo.getCheckInputId(), DangerHandleStateEnum.HANDLE.getCode());
Long dangerId = latentDangerBo.getId();
Date startDate = new Date();
JSONObject jsonObject = remoteWorkFlowService.startNew(dangerId, businessKey, processDefinitionKey);
// if(!jsonObject.getString("msg").equals("操作成功")){
// return CommonResponseUtil.failure(jsonObject.getString("msg"));
// }
Date endDate = new Date();
logger.info("-------------------------提交隐患时间" +(endDate.getTime()-startDate.getTime()));
if (jsonObject == null) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
return CommonResponseUtil.failure("启动流程失败");
}
JSONObject instance = jsonObject.getJSONObject("data");
if(instance==null){
return CommonResponseUtil.failure("无提交隐患权限");
}
//提交隐患
// jsonObject = remoteWorkFlowService.excute(instance.getString("id"), null);
// JSONObject task = jsonObject.getJSONObject("data");
latentDangerBo.setInstanceId(instance.getString("id"));
JSONObject flowJson = new JSONObject();
flowJson.put("photoUrls", latentDangerParam.getPhotoUrls());
LatentDangerFlowRecordBo record = saveFlowRecord(instance.getString("id"), "提交隐患", userId, departmentId, flowJson, dangerId, role, LatentDangerExcuteTypeEnum.填写隐患完成.getName(),latentDangerParam.getRemark());
latentDangerBo.setCurrentFlowRecordId(record.getId());
latentDangerMapper.update(latentDangerBo);
sendMessage(latentDangerBo, LatentDangerExcuteTypeEnum.填写隐患完成, null,
"隐患排查与治理", this.getNextExecuteUsers(latentDangerBo.getInstanceId()), userRealName, departmentName);
try {
webMqttComponent.publish(dangerTopic, "");
}catch (Exception e){
logger.error("隐患提交数字换流站页面推送失败-----------"+e.getMessage());
}
return CommonResponseUtil.success();
}
@Transactional
@Override
public CommonResponse savePatrol(LatentDangerPatrolParam latentDangerPatrolParam, String userId, String userRealName, String departmentId, String departmentName, String companyId, String orgCode, RoleBo role) {
List<LatentDangerPatrolItemParam> itemList = latentDangerPatrolParam.getItemList();
Long checkId = latentDangerPatrolParam.getCheckId();
Check check = iCheckDao.getById(checkId);
if (CollectionUtils.isEmpty(itemList)) {
return CommonResponseUtil.failure("请求参数有误");
}
// Set<String> inputUserIdsStr = getUserIdsStrByTypeAndDefKey("B_1");
// Set<String> reviewUserIdsStr = getUserIdsStrByTypeAndDefKey("B_2");
//获取装备全路径
LinkedHashMap<String,Object> positionAll = equipFeign.getBuildingAbsolutePosition();
LinkedHashMap<String,Object> position = new LinkedHashMap<>();
if("200".equals(positionAll.get("status").toString())){
position = (LinkedHashMap<String, Object>) positionAll.get("result");
}
for (LatentDangerPatrolItemParam param : itemList) {
InputCheckDto inputCheckDto = checkInputMapper.getByCheckIdAndItemIdAndRoutePointItemId(checkId,
param.getItemId(), param.getRoutePointItemId(), null);
if (CheckModeEnum.WEB_OUT.getCode().equals(check.getCheckMode())) {
// 如果是外来检查，这里itemList里面无法区分InputCheckDto...
// 在LatentDangerPatrolItemParam中增加checkInputId字段来区分
inputCheckDto = checkInputMapper.getByCheckIdAndItemIdAndRoutePointItemId(null, null,
null, param.getCheckInputId());
}
if (inputCheckDto == null) {
return CommonResponseUtil.failure("检查项不存在");
}
InputItem inputItem = iInputItemDao.getOne(inputCheckDto.getItemId());
if (inputItem == null && !CheckModeEnum.WEB_OUT.getCode().equals(check.getCheckMode())) {
return CommonResponseUtil.failure("检查项不存在");
}
String businessKey = RandomUtil.buildOrderNo();
LatentDangerLevelEnum levelEnum = LatentDangerLevelEnum.getByCode(param.getDangerLevel());
if (levelEnum == null) {
return CommonResponseUtil.failure("请求参数有误");
}
String remark = param.getRemark();
String photoUrls = "";
List<CheckShot> checkShots = iCheckShotDao.findAllByCheckIdAndCheckInputId(inputCheckDto.getCheckId(),
inputCheckDto.getCheckInputId());
if (!CollectionUtils.isEmpty(checkShots)) {
List<String> photos = checkShots.stream().map(e -> {
if (e != null) {
return fileServerAddress + e.getPhotoData().replaceAll("\\\\", "/");
} else {
return "";
}
}).collect(Collectors.toList());
photoUrls = Joiner.on(",").join(photos);
}
LatentDangerTypeEnum dangerTypeEnum = null;
String dangerName = "";
if (check.getPlanId() > 0) {
dangerTypeEnum = LatentDangerTypeEnum.计划检查;
} else if (CheckModeEnum.WEB_OUT.getCode().equals(check.getCheckMode())) {
dangerTypeEnum = LatentDangerTypeEnum.无码检查;
} else {
dangerTypeEnum = LatentDangerTypeEnum.无计划检查;
}
if(org.apache.commons.lang3.StringUtils.isNotEmpty(param.getName())){
dangerName = param.getName();
}else {
dangerName = inputItem.getName();
}
Long riskSourceId = null;
if(org.apache.commons.lang3.StringUtils.isNotEmpty(inputCheckDto.getRiskSourceId())){
riskSourceId = Long.parseLong(inputCheckDto.getRiskSourceId());
}
LatentDangerBo latentDangerBo = saveLatentDanger("", param.getRemark(), remark, userId, departmentId,
businessKey, orgCode, dangerName, levelEnum.getCode(),
null, dangerTypeEnum, photoUrls, inputCheckDto.getCheckInputId(), riskSourceId,
position.get(inputCheckDto.getRiskSourceId())==null?"":position.get(inputCheckDto.getRiskSourceId()).toString(), InstanceKeyEnum.PATROL.getCode());
// 更新p_check_input表state字段
updateCheckInputDangerState(latentDangerBo.getCheckInputId(), DangerHandleStateEnum.HANDLE.getCode());
Long dangerId = latentDangerBo.getId();
Date startDate = new Date();
JSONObject jsonObject = remoteWorkFlowService.startNew(dangerId, businessKey, processDefinitionKey);
Date endDate = new Date();
logger.info("-------------------------提交隐患时间" +(endDate.getTime()-startDate.getTime()));
if (jsonObject == null) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
return CommonResponseUtil.failure("启动流程失败");
}
JSONObject instance = jsonObject.getJSONObject("data");
if(instance==null){
return CommonResponseUtil.failure("无提交隐患权限");
}
LatentDangerFlowRecordBo inputRecord = saveFlowRecord(instance.getString("id"), "提交隐患", userId, departmentId,
null, dangerId, role, LatentDangerExcuteTypeEnum.填写隐患完成.getName(),latentDangerBo.getRemark());
JSONObject flowJson = new JSONObject();
flowJson.put("photoUrls", photoUrls);
updateFlowRecord(inputRecord, LatentDangerExcuteTypeEnum.填写隐患完成, userId, departmentId, remark, flowJson);
if (LatentDangerTypeEnum.计划检查.getCode().equals(latentDangerBo.getDangerType())
|| LatentDangerTypeEnum.无计划检查.getCode().equals(latentDangerBo.getDangerType())) {
LatentDangerPatrolBo latentDangerPatrolBo = new LatentDangerPatrolBo();
latentDangerPatrolBo.setCheckId(inputCheckDto.getCheckId());
latentDangerPatrolBo.setPointClassifyId(inputCheckDto.getPointClassifyId());
latentDangerPatrolBo.setItemId(inputCheckDto.getItemId());
latentDangerPatrolBo.setRouteId(inputCheckDto.getRouteId());
latentDangerPatrolBo.setPointId(inputCheckDto.getPointId());
latentDangerPatrolBo.setLatentDangerId(latentDangerBo.getId());
latentDangerPatrolBo.setRoutePointItemId(inputCheckDto.getRoutePointItemId());
latentDangerPatrolMapper.save(latentDangerPatrolBo);
}
latentDangerBo.setCurrentFlowRecordId(inputRecord.getId());
latentDangerBo.setInstanceId(instance.getString("id"));
latentDangerMapper.update(latentDangerBo);
//修改管控措施的状态为失效
LatentDangerPatrolBo patrolBo = latentDangerPatrolMapper.getByDangerId(latentDangerBo.getId());
sendMessage(latentDangerBo, LatentDangerExcuteTypeEnum.填写隐患完成, patrolBo,
"巡检隐患排查与治理", this.getNextExecuteUsers(latentDangerBo.getInstanceId()), userRealName, departmentName);
try {
webMqttComponent.publish(dangerTopic, "");
}catch (Exception e){
logger.error("巡检隐患提交数字换流站页面推送失败-----------"+e.getMessage());
}
}
return CommonResponseUtil.success();
}
private void updateCheckInputDangerState(Long id, int code) {
latentDangerMapper.updateCheckInputDangerState(id, code);
}
private String buildLocalHost() {
try {
String ip = InetAddress.getLocalHost().getHostAddress();
return "http://" + ip + ":" + port + "/";
} catch (Exception e) {
return "";
}
}
private void updateMeasuresContentStatus(Long riskFactorId, Long measuresContentId, String evaluateId, RiskFactorsCmStatusEnum riskFactorsCmStatusEnum) {
Map<String, Object> map = Maps.newHashMap();
map.put("riskFactorId", riskFactorId);
map.put("measuresContentId", measuresContentId);
map.put("evaluateId", evaluateId);
map.put("status", riskFactorsCmStatusEnum.getCode());
riskFactorCmMapper.updateStatusByMap(map);
RiskFactorBo riskFactorBo = new RiskFactorBo();
riskFactorBo.setId(riskFactorId);
Long outControlNumber = riskFactorCmMapper.countOutControl(map);
if (outControlNumber.equals(0L)) {
riskFactorBo.setControlStatus(RiskFactorsCmStatusEnum.Control.getName());
} else {
riskFactorBo.setControlStatus(RiskFactorsCmStatusEnum.outOfControl.getName());
}
riskFactorMapper.updateControlStatus(riskFactorBo);
}
public LatentDangerBo saveLatentDanger(String instanceId, String problemDescription, String remark, String userId,
String departmentId, String businessKey, String orgCode, String dangerName,
Integer level, String position, LatentDangerTypeEnum dangerTypeEnum,
String photoUrls, Long checkInputId, Long structureId, String structureName, String instanceKey) {
LatentDangerBo latentDangerBo = new LatentDangerBo();
latentDangerBo.setInstanceId(instanceId);
latentDangerBo.setProblemDescription(problemDescription);
latentDangerBo.setRemark(remark);
latentDangerBo.setDangerState(LatentDangerStateEnum.待评审.getCode());
latentDangerBo.setDiscovererUserId(userId);
latentDangerBo.setDiscovererDepartmentId(departmentId);
latentDangerBo.setBusinessKey(businessKey);
latentDangerBo.setOrgCode(orgCode);
latentDangerBo.setDangerName(dangerName);
latentDangerBo.setDangerLevel(level);
latentDangerBo.setDangerPosition(position);
latentDangerBo.setDangerType(dangerTypeEnum.getCode());
StringBuilder photoUrlsB = new StringBuilder();
if(org.apache.commons.lang3.StringUtils.isNotBlank(photoUrls)){
String[] photoUrlsList = photoUrls.split(",");
for (String url : photoUrlsList) {
if (!"".equals(url)){
photoUrlsB.append(fileUrl+url);
photoUrlsB.append(",");
}
}
}
latentDangerBo.setPhotoUrls(photoUrlsB.toString());
latentDangerBo.setCheckInputId(checkInputId);
latentDangerBo.setStructureId(structureId);
latentDangerBo.setStructureName(structureName);
latentDangerBo.setInstanceKey(instanceKey);
latentDangerMapper.save(latentDangerBo);
return latentDangerBo;
}
public LatentDangerFlowRecordBo saveFlowRecord(String taskId, String taskName, String userId, String departmentId,
JSONObject flowJson, Long dangerId, RoleBo role, String executeResult,String remark) {
LatentDangerFlowRecordBo record = new LatentDangerFlowRecordBo();
record.setFlowTaskId(taskId);
record.setExcuteUserId(userId);
record.setExcuteDepartmentId(departmentId);
if(flowJson != null && org.apache.commons.lang3.StringUtils.isNotBlank(flowJson.getString("photoUrls"))){
flowJson.put("photoUrls",fileUrl+flowJson.getString("photoUrls"));
}
record.setFlowJson(flowJson != null ? flowJson.toJSONString() : null);
record.setFlowTaskName(taskName);
record.setDangerId(dangerId);
// record.setExcuteUserId(RequestContext.getLoginId());
record.setExcuteResult(executeResult);
record.setDeleted(0);
record.setActionFlag(taskName);
record.setRemark(remark);
latentDangerFlowRecordMapper.save(record);
return record;
}
public LatentDangerFlowRecordBo saveFlowRecord(String taskId, String userIds, String taskName,
String taskDefinitionKey, Long dangerId) {
LatentDangerFlowRecordBo record = new LatentDangerFlowRecordBo();
record.setFlowTaskId(taskId);
record.setFlowTaskUserIds(userIds);
record.setFlowTaskName(taskName);
record.setActionFlag(taskDefinitionKey);
record.setDangerId(dangerId);
latentDangerFlowRecordMapper.save(record);
return record;
}
public void updateFlowRecord(LatentDangerFlowRecordBo flowRecord, LatentDangerExcuteTypeEnum excuteTypeEnum,
String userId, String departmentId, String remark, JSONObject flowJson) {
flowRecord.setExcuteState(excuteTypeEnum.getExcuteState().getCode());
flowRecord.setExcuteDepartmentId(departmentId);
flowRecord.setExcuteUserId(userId);
flowRecord.setExcuteResult(excuteTypeEnum.getName());
if (!StringUtils.isEmpty(remark)) {
flowRecord.setRemark(remark);
}
if (flowJson != null) {
flowRecord.setFlowJson(flowJson.toJSONString());
}
latentDangerFlowRecordMapper.update(flowRecord);
}
private Set<String> getUserIdsStrByTypeAndDefKey(String definitionKey) {
List<AgencyUserModel> users = remoteSecurityService.listUserByMenuCode(acctivePermissionType, definitionKey);
if (CollectionUtils.isEmpty(users)) {
return Sets.newHashSet();
} else {
return Sets.newHashSet(Lists.transform(users, AgencyUserModel::getUserId));
}
}
private Set<String> getUserIdsStrByPerTypeAndDefKey(JSONObject jsonObject) {
String taskDefinitionKey = jsonObject.getString("taskDefinitionKey");
// List<UserModel> users = remoteSecurityService.listUserByMenuCode(acctivePermissionType, taskDefinitionKey);
// if (CollectionUtils.isEmpty(users)) {
// return Sets.newHashSet();
// } else {
// return Sets.newHashSet(Lists.transform(users, UserModel::getUserId));
// }
return getUserIdsStrByTypeAndDefKey(taskDefinitionKey);
}
private Map<String, Object> buildQueryMapForList(LatentDangerListParam latentDangerListParam, String userId) {
Map<String, Object> map = Maps.newHashMap();
Long offset = latentDangerListParam.getOffset();
map.put("offset", offset);
map.put("limit", latentDangerListParam.getPageSize());
if (latentDangerListParam.getIsHandle() != null) {
List<Integer> states = Lists.newArrayList();
if (latentDangerListParam.getIsHandle()) {
states.add(LatentDangerStateEnum.治理完毕.getCode());
states.add(LatentDangerStateEnum.已撤销.getCode());
} else {
states.add(LatentDangerStateEnum.待验证.getCode());
states.add(LatentDangerStateEnum.延期治理申请.getCode());
states.add(LatentDangerStateEnum.安措计划中.getCode());
states.add(LatentDangerStateEnum.待治理.getCode());
states.add(LatentDangerStateEnum.待评审.getCode());
states.add(LatentDangerStateEnum.延期治理申请待车间部门审核.getCode());
states.add(LatentDangerStateEnum.延期治理申请待公司审核.getCode());
}
map.put("states", states);
}
if (!latentDangerListParam.getBelongType().equals(0)) {
map.put("userId", userId);
}
if (!latentDangerListParam.getDangerLevel().equals(-1)) {
map.put("dangerLevel", latentDangerListParam.getDangerLevel());
}
if (!latentDangerListParam.getDangerState().equals(0)) {
map.put("dangerState", latentDangerListParam.getDangerState());
}
if (!StringUtils.isEmpty(latentDangerListParam.getDangerName())) {
map.put("dangerName", latentDangerListParam.getDangerName());
}
return map;
}
@Override
public CommonResponse list(String toke, String product, String appKey, LatentDangerListParam latentDangerListParam, AgencyUserModel user, String loginOrgCode, String deptId) {
JSONObject respBody;
Date startDate = new Date();
if (latentDangerListParam.getIsHandle()) {
respBody = remoteWorkFlowService.completedPageTask(user.getUserName(),latentDangerListParam.getBelongType());
} else {
respBody = remoteWorkFlowService.pageTask(user.getUserId(),latentDangerListParam.getBelongType());
}
Date endDate = new Date();
logger.info("-------------------------工作流列表时间" +(endDate.getTime()-startDate.getTime()));
JSONArray taskJsonList = respBody.getJSONArray("data");
List<JSONObject> taskList = JSONObject.parseArray(taskJsonList.toJSONString(), JSONObject.class);
List<String> bussinessKeys = new ArrayList<>();
for (JSONObject json : taskList) {
bussinessKeys.add(json.getString("businessKey"));
}
if (0 == latentDangerListParam.getBelongType()) {
latentDangerListParam.setUserId(null);
}
if (-1 == latentDangerListParam.getDangerLevel()) {
latentDangerListParam.setDangerLevel(null);
}
if (0 == latentDangerListParam.getDangerState()) {
latentDangerListParam.setDangerState(null);
}
Date startDate1 = new Date();;
int dangerListSize = latentDangerMapper.countByBathBusinessKeys(bussinessKeys, latentDangerListParam);
List<LatentDangerBo> dangerList = latentDangerMapper.getByBathBusinessKeys(bussinessKeys, latentDangerListParam);
Date endDate1 = new Date();
logger.info("-------------------------sql时间" +(endDate1.getTime()-startDate1.getTime()));
// Map<String, Object> map = buildQueryMapForList(latentDangerListParam, userId);
// map.put("org_code", loginOrgCode);
// map.put("discoverer_department_id", deptId);
// String permissions = hasProcessBPermission(userId, acctivePermissionType);
// map.put("permissions", permissions);
// List<LatentDangerBo> list = latentDangerMapper.listByMap(map);
// Long count = 0L;
List<LatentDangerListVo> voList = Lists.newArrayList();
Date date = new Date();
if (!CollectionUtils.isEmpty(dangerList)) {
Set<String> userIds = Sets.newHashSet();
dangerList.forEach(e -> userIds.add(e.getDiscovererUserId()));
String userIdsStr = Joiner.on(",").join(userIds);
List<AgencyUserModel> users = remoteSecurityService.listUserByUserIds(toke, product, appKey, userIdsStr);
Map<String, AgencyUserModel> userMap = Maps.uniqueIndex(users, AgencyUserModel::getUserId);
for (LatentDangerBo bo : dangerList) {
JSONObject task = taskList.stream().filter(t -> t.getString("businessKey").equals(bo.getBusinessKey())).collect(Collectors.toList()).get(0);
LatentDangerListVo vo = new LatentDangerListVo();
vo.setTaskId(task.getString("id"));
vo.setDangerId(bo.getId());
vo.setOvertimeState(bo.getOvertimeState());
vo.setDangerName(bo.getDangerName());
vo.setDiscovererUserName(userMap.get(bo.getDiscovererUserId()).getRealName());
vo.setLevel(bo.getDangerLevel());
LatentDangerLevelEnum levelEnum = LatentDangerLevelEnum.getByCode(bo.getDangerLevel());
if (levelEnum != null) {
vo.setLevelDesc(levelEnum.getName());
}
vo.setState(bo.getDangerState());
LatentDangerStateEnum stateEnum = LatentDangerStateEnum.getByCode(bo.getDangerState());
if (stateEnum != null) {
vo.setStateDesc(stateEnum.getName());
}
vo.setLimitDesc(getLimitDesc(bo, date));
voList.add(vo);
}
// count = latentDangerMapper.countByMap(map);
}
// return CommonResponseUtil.success(new PageImpl<>(newList, latentDangerListParam, respBody.getLong("total")));
return CommonResponseUtil.success(new PageImpl<>(voList, latentDangerListParam, dangerListSize));
}
/**
* 获取指定用户具有隐患权限的code
*
* @param userId 指定用户id
* @param permissionType “activitiItem”
* @return permissions 具有隐患权限的code（逗号分割）
*/
private String hasProcessBPermission(String userId, String permissionType) {
String permissions = "";
// 根据用户id和许可类型获取用户所有的授权操作菜单路径（"B"、"B_1"、"G_1_1"、"A"、"A_1"、"C".....）
JSONArray jsonArray = remoteSecurityService.getMenuPathByUserIdAndPermissionType(userId, permissionType);
if (CollectionUtils.isEmpty(jsonArray)) {
return "";
}
// 过滤出隐患权限菜单路径（"B_1,B_2.....B_10"）
Object obj = jsonArray.stream().filter(i -> i.toString().matches("^B_\\d+")).collect(Collectors.toList());
if (StringUtil.isNotEmpty(obj) && ((List<String>) obj).size() > 0) {
permissions = Joiner.on(",").join((List<String>) obj);
}
return permissions;
}
private String getLimitDesc(LatentDangerBo bo, Date start) {
Integer dangerState = bo.getDangerState();
if (LatentDangerStateEnum.已撤销.getCode().equals(dangerState) || LatentDangerStateEnum.治理完毕.getCode().equals(dangerState)) {
if (bo.getOvertimeState().equals(LatentDangerOvertimeStateEnum.已超时.getCode())) {
return "逾期治理";
} else {
return "按期治理";
}
} else {
Date end = bo.getReformLimitDate();
if (end == null) {
return "";
}
if (bo.getOvertimeState().equals(LatentDangerOvertimeStateEnum.已超时.getCode())) {
return "逾期未治理";
} else {
long betweenSecond = (end.getTime() - start.getTime()) / 1000;
if (betweenSecond < 0) {
return "逾期未治理";
} else {
String str = "";
if (betweenSecond > 3600) {
long hour = betweenSecond / 3600;
str += hour + "时";
betweenSecond = betweenSecond % 3600;
}
if (betweenSecond > 60) {
long minute = betweenSecond / 60;
str += minute + "分";
betweenSecond = betweenSecond % 60;
}
if (betweenSecond > 0) {
str += betweenSecond + "秒";
}
return str;
}
}
}
}
@Transactional
@Override
public DangerExecuteSubmitDto execute(LatentDangerExcuteParam latentDangerExcuteParam, String userId, String userRealName, String departmentId, String departmentName, RoleBo role) {
DangerExecuteSubmitDto executeSubmitDto = new DangerExecuteSubmitDto();
LatentDangerBo latentDangerBo = null;
if (StringUtil.isNotEmpty(latentDangerExcuteParam.getDangerId())) {
latentDangerBo = latentDangerMapper.getById(latentDangerExcuteParam.getDangerId());
}
if(StringUtil.isNotEmpty(latentDangerExcuteParam.getReformLimitDate())){
latentDangerExcuteParam.setReformLimitDate(latentDangerExcuteParam.getReformLimitDate()+" 23:59:59");
}
LatentDangerExcuteTypeEnum executeTypeEnum = LatentDangerExcuteTypeEnum.getByCode(latentDangerExcuteParam.getExcuteType());
if (executeTypeEnum == null) {
executeSubmitDto.setIsOk(false);
executeSubmitDto.setMsg("执行类型有误");
return executeSubmitDto;
}
// 延期治理时，根据用户选择是否需要公司来构造参数调用工作流
if (StringUtil.isNotEmpty(latentDangerExcuteParam.getNeedCompanyVerify())
&& executeTypeEnum.equals(LatentDangerExcuteTypeEnum.隐患延期治理车间部门审核通过)) {
String requestBody = "";
if (latentDangerExcuteParam.getNeedCompanyVerify() == 0) {// 延期治理申请 不需要公司审核
requestBody = "{\"needCompanyApproval\": \"否\",\"approveResult\": \"通过\"}";
} else {// 延期治理申请 需要公司审核
requestBody = "{\"needCompanyApproval\": \"是\",\"approveResult\": \"通过\"}";
}
executeTypeEnum.setRequestBody(requestBody);
}
// 延期治理选择的延期日期不能早于整改日期校验
if (executeTypeEnum.equals(LatentDangerExcuteTypeEnum.隐患延期治理)) {
if (latentDangerBo.getReformLimitDate().compareTo(DateUtil.longStr2Date(latentDangerExcuteParam.getDelayLimitDate())) >= 0) {
executeSubmitDto.setIsOk(false);
executeSubmitDto.setMsg("延期日期不能早于整改期限");
return executeSubmitDto;
}
}
DangerExecuteSubmitDto dangerExecuteSubmitDto= executeSubmit(latentDangerExcuteParam, executeTypeEnum, latentDangerBo, userId, userRealName, departmentId, departmentName, executeSubmitDto, role);
try {
webMqttComponent.publish(dangerTopic, "");
}catch (Exception e){
logger.error("隐患执行提交数字换流站页面推送失败-----------"+e.getMessage());
}
return dangerExecuteSubmitDto;
}
@Override
public CommonResponse detail(String id, String userId,boolean isFinish) {
JSONObject jsonObject;
if(isFinish==true){
jsonObject = remoteWorkFlowService.queryFinishTaskDetail(id);
}else{
jsonObject = remoteWorkFlowService.queryTaskDetail(id);
}
JSONObject task = jsonObject.getJSONObject("data");
LatentDangerBo latentDangerBo = latentDangerMapper.getbyBusinessKey(task.getString("businessKey"));
// LinkedHashMap<String,Object> positionAll = equipFeign.getBuildingAbsolutePosition();
// LinkedHashMap<String,Object> position = new LinkedHashMap<>();
// if("200".equals(positionAll.get("status").toString())){
// position = (LinkedHashMap<String, Object>) positionAll.get("result");
// }
LatentDangerDetailVo detailVo = new LatentDangerDetailVo();
if (latentDangerBo != null) {
detailVo.setDangerId(latentDangerBo.getId());
detailVo.setDangerType(latentDangerBo.getDangerType());
// if(position.size()>0){
// detailVo.setPosition(position.get(latentDangerBo.getStructureId()).toString());
// }else {
// detailVo.setPosition(latentDangerBo.getDangerPosition());
// }
if(StringUtils.isEmpty(latentDangerBo.getDangerPosition())){
detailVo.setPosition(latentDangerBo.getStructureName());
}else{
detailVo.setPosition(latentDangerBo.getStructureName()+"·"+latentDangerBo.getDangerPosition());
}
detailVo.setDangerState(latentDangerBo.getDangerState());
detailVo.setProblemDescription(latentDangerBo.getProblemDescription());
detailVo.setReasonAnalysis(latentDangerBo.getReasonAnalysis());
detailVo.setInferOtherThings(latentDangerBo.getInferOtherThings());
detailVo.setProblemDescription(latentDangerBo.getProblemDescription());
LatentDangerStateEnum dangerStateEnum = LatentDangerStateEnum.getByCode(latentDangerBo.getDangerState());
if (dangerStateEnum != null) {
detailVo.setDangerStateDesc(dangerStateEnum.getName());
}
detailVo.setDangerName(latentDangerBo.getDangerName());
detailVo.setLevel(latentDangerBo.getDangerLevel());
LatentDangerLevelEnum levelEnum = LatentDangerLevelEnum.getByCode(latentDangerBo.getDangerLevel());
if (levelEnum != null) {
detailVo.setLevelDesc(levelEnum.getName());
}
detailVo.setRemark(latentDangerBo.getRemark());
if (latentDangerBo.getReformType() != null) {
LatentDangerReformTypeEnum typeEnum = LatentDangerReformTypeEnum.getByCode(latentDangerBo.getReformType());
if (typeEnum != null) {
detailVo.setReformTypeDesc(typeEnum.getName());
}
}
if (latentDangerBo.getReformLimitDate() != null) {
detailVo.setReformLimitDate(DateUtil.date2Str(latentDangerBo.getReformLimitDate(), DateUtil.DATETIME_DEFAULT_FORMAT));
}
if (latentDangerBo.getDelayLimitDate() != null) {
detailVo.setDelayLimitDate(DateUtil.date2Str(latentDangerBo.getDelayLimitDate(),
DateUtil.DATETIME_DEFAULT_FORMAT));
}
// detailVo.setCurrentUserCanExcute(false);
// if (!latentDangerBo.getCurrentFlowRecordId().equals(-1L)) {
// LatentDangerFlowRecordBo currentRecord = latentDangerFlowRecordMapper.getById(latentDangerBo.getCurrentFlowRecordId());
// String userIdsStr = currentRecord.getFlowTaskUserIds();
// List<String> userIds = Arrays.asList(userIdsStr.split(","));
// if (userIds.contains(userId) || hasProcessBPermission(userId, acctivePermissionType).contains(currentRecord.getActionFlag())) {
// detailVo.setCurrentUserCanExcute(true);
// }
// }
detailVo.setCurrentFlowRecordId(latentDangerBo.getCurrentFlowRecordId());
if (!StringUtils.isEmpty(latentDangerBo.getReformJson())) {
detailVo.setReformJson(JSONObject.parseObject(latentDangerBo.getReformJson()));
}
if (!StringUtils.isEmpty(latentDangerBo.getPhotoUrls())) {
List<String> photoUrls = Lists.newArrayList(latentDangerBo.getPhotoUrls().split(","));
detailVo.setPhotoUrls(photoUrls);
}
buildOfDifferentDangerType(latentDangerBo, detailVo);
detailVo.setTaskId(task.getString("id"));
}
return CommonResponseUtil.success(detailVo);
}
private void buildOfDifferentDangerType(LatentDangerBo latentDangerBo, LatentDangerDetailVo detailVo) {
if (latentDangerBo.getDangerType().equals(LatentDangerTypeEnum.计划检查.getCode())
|| latentDangerBo.getDangerType().equals(LatentDangerTypeEnum.无计划检查.getCode())) {
LatentDangerPatrolBo patrolBo = latentDangerPatrolMapper.getByDangerId(latentDangerBo.getId());
if (patrolBo != null) {
LatentDangerDetailRiskVo riskVo = new LatentDangerDetailRiskVo();
List<String> basis = new ArrayList<>();
if(!StringUtils.isEmpty(patrolBo.getItemBasis())){
basis.add(patrolBo.getItemBasis());
}
riskVo.setBasis(basis);
riskVo.setPointName(patrolBo.getPointName());
riskVo.setPointNo(patrolBo.getPointNo());
riskVo.setPointLevel(StringUtil.isNotEmpty(patrolBo.getPointLevel()) ? patrolBo.getPointLevel() : "");
riskVo.setPlanName(patrolBo.getPlanName());
riskVo.setCheckTime(patrolBo.getCheckTime());
AgencyUserModel checkUser = remoteSecurityService.getUserById(RequestContext.getToken(),RequestContext.getProduct(),RequestContext.getAppKey(), patrolBo.getCheckUserId());
if (StringUtil.isNotEmpty(checkUser)) {
riskVo.setCheckUser(checkUser.getRealName());
}
RiskFactorBo riskFactorBo = StringUtil.isNotEmpty(patrolBo.getClassifyOriginalId()) ? riskFactorMapper.getById(Long.valueOf(patrolBo.getClassifyOriginalId())) : null;
if (riskFactorBo != null && riskFactorBo.getEquipmentDepartmentId() != null) {
DepartmentModel department = remoteSecurityService.getDepartmentByDeptId(RequestContext.getToken(), getProduct(),RequestContext.getAppKey(),riskFactorBo.getEquipmentDepartmentId().toString());
if (department != null) {
riskVo.setBelongDepartmentName(department.getDepartmentName());
}
}
List<CheckShot> checkShots = iCheckShotDao.findAllByCheckIdAndCheckInputId(patrolBo.getCheckId(),
latentDangerBo.getCheckInputId());
if (!CollectionUtils.isEmpty(checkShots)) {
List<String> photos = Lists.transform(checkShots, e -> {
if (e != null) {
return fileServerAddress + e.getPhotoData().replaceAll("\\\\", "/");
} else {
return "";
}
});
detailVo.setPhotoUrls(photos);
}
detailVo.setRiskInfo(riskVo);
}
}
}
@Override
public CommonResponse getByInstanceId(String instanceId) {
LatentDangerBo latentDangerBo = latentDangerMapper.getByInstanceId(instanceId);
if (latentDangerBo == null) {
return CommonResponseUtil.failure("隐患不存在");
}
JSONObject result = new JSONObject();
JSONObject baseInfo = new JSONObject();
JSONObject reviewInfo = new JSONObject();
JSONObject dangerInfo = new JSONObject();
Set<String> userIds = Sets.newHashSet();
userIds.add(latentDangerBo.getDiscovererUserId());
LatentDangerPatrolBo patrolBo = null;
if (latentDangerBo.getDangerType().equals(LatentDangerTypeEnum.计划检查.getCode())) {
patrolBo = latentDangerPatrolMapper.getByDangerId(latentDangerBo.getId());
JSONArray checkTypeArry = remoteSecurityService.listDictionaryByDictCode(RequestContext.getToken(), getProduct(),
RequestContext.getAppKey(), XJConstant.CHECK_TYPE);
Map<String, String> checkTypeMap = Maps.newHashMap();
for (int i = 0; i < checkTypeArry.size(); i++) {
JSONObject categoryJson = checkTypeArry.getJSONObject(i);
checkTypeMap.put(categoryJson.getString("dictDataKey"), categoryJson.getString("dictDataValue"));
}
if (patrolBo != null) {
PointClassify classify = iPointClassifyDao.getOne(patrolBo.getPointClassifyId());
RiskFactorBo riskFactorBo = riskFactorMapper.getById(Long.valueOf(classify.getOriginalId()));
String jsonStr = patrolBo.getItemBasis();
String itemBasis = "";
if (!StringUtils.isEmpty(jsonStr)) {
StringBuilder itemBasisBuilder = new StringBuilder();
JSONArray arr = JSONArray.parseArray(jsonStr);
for (int i = 0; i < arr.size(); i++) {
JSONObject object = arr.getJSONObject(i);
itemBasisBuilder.append(object.getString("name")).append(",");
}
itemBasis = itemBasisBuilder.length() > 0 ? itemBasisBuilder.substring(0, itemBasisBuilder.length() - 1) : itemBasis;
}
if (riskFactorBo != null) {
userIds.add(patrolBo.getCheckUserId());
dangerInfo.put("type", "设备设施类");
dangerInfo.put("equipmentCode", riskFactorBo.getEquipmentCode());
dangerInfo.put("isCheckWithPlan", "是");
dangerInfo.put("planName", patrolBo.getPlanName());
dangerInfo.put("planType", checkTypeMap.get(patrolBo.getCheckType()));
dangerInfo.put("routeName", patrolBo.getRouteName());
dangerInfo.put("classifyName", patrolBo.getClassifyName());
dangerInfo.put("itemName", patrolBo.getItemName());
dangerInfo.put("itemBasis", itemBasis);
dangerInfo.put("itemRemark", patrolBo.getItemRemark());
dangerInfo.put("checkTime", DateUtil.str2Date(patrolBo.getCheckTime(), DateUtil.DATETIME_DEFAULT_FORMAT));
}
}
}
LatentDangerFlowRecordBo reviewRecordBo = latentDangerFlowRecordMapper.getByDangerIdAndActionFlag(latentDangerBo.getId(), "B_2");
LatentDangerFlowRecordBo reformRecordBo = latentDangerFlowRecordMapper.getByDangerIdAndActionFlag(latentDangerBo.getId(), "B_3");
if (reviewRecordBo != null) {
userIds.add(reviewRecordBo.getExcuteUserId());
}
if (reformRecordBo != null) {
userIds.add(reformRecordBo.getExcuteUserId());
}
userIds.removeAll(Collections.singleton(null));
List<AgencyUserModel> userModels = remoteSecurityService.listUserByUserIds(Joiner.on(",").join(userIds));
Map<String, AgencyUserModel> userMap = Maps.uniqueIndex(userModels, AgencyUserModel::getUserId);
AgencyUserModel user = userMap.get(latentDangerBo.getDiscovererUserId());
baseInfo.put("orderNo", latentDangerBo.getBusinessKey());
baseInfo.put("startTime", latentDangerBo.getCreateDate());
if (user != null) {
baseInfo.put("userName", user.getRealName());
}
DepartmentBo departmentBo = remoteSecurityService.getDepartmentByDeptId(latentDangerBo.getDiscovererDepartmentId().toString());
if (departmentBo != null) {
baseInfo.put("department", departmentBo.getDepartmentName());
}
LatentDangerLevelEnum levelEnum = LatentDangerLevelEnum.getByCode(latentDangerBo.getDangerLevel());
if (levelEnum != null) {
dangerInfo.put("latentDangerLevel", levelEnum.getName());
}
dangerInfo.put("latentDangerName", latentDangerBo.getDangerName());
if (!StringUtils.isEmpty(latentDangerBo.getReformJson())) {
String str = JSONObject.parseObject(latentDangerBo.getReformJson()).getString("rectMeasures");
dangerInfo.put("reformJson", str.replace("\\n", "\\\\n"));
}
dangerInfo.put("reformLimitDate", latentDangerBo.getReformLimitDate());
if (reformRecordBo != null) {
AgencyUserModel reformUser = userMap.get(reformRecordBo.getExcuteUserId());
if (reformUser != null) {
dangerInfo.put("reformUserName", reformUser.getRealName());
}
}
if (patrolBo != null) {
if (patrolBo.getCheckUserId() != null) {
AgencyUserModel checkUser = userMap.get(patrolBo.getCheckUserId());
if (checkUser != null) {
dangerInfo.put("checkUserName", checkUser.getRealName());
}
}
if (patrolBo.getCheckDepartmentId() != null) {
DepartmentBo checkDepartment = remoteSecurityService.getDepartmentByDeptId(patrolBo.getCheckDepartmentId());
if (checkDepartment != null) {
dangerInfo.put("checkUserDeptName", checkDepartment.getDepartmentName());
}
}
}
if (reviewRecordBo != null) {
AgencyUserModel reviewUser = userMap.get(reviewRecordBo.getExcuteUserId());
reviewInfo.put("reviewUserName", StringUtil.isNotEmpty(reviewUser) ? reviewUser.getRealName() : "");
reviewInfo.put("reviewDate", StringUtil.isNotEmpty(reviewUser) ? reviewRecordBo.getUpdateDate() : "");
reviewInfo.put("reviewResult", StringUtil.isNotEmpty(reviewUser) ? reviewRecordBo.getExcuteResult() : "");
}
result.put("baseInfo", baseInfo);
result.put("dangerInfo", dangerInfo);
result.put("reviewInfo", reviewInfo);
result.put("latentDangerType", latentDangerBo.getDangerType());
LatentDangerTypeEnum typeEnum = LatentDangerTypeEnum.getByCode(latentDangerBo.getDangerType());
if (typeEnum != null) {
result.put("latentDangerTypeDesc", typeEnum.getName());
}
return CommonResponseUtil.success(result);
}
@Transactional
@Override
public DangerExecuteSubmitDto excuteCallBack(String instanceId, Integer actionType, String remark, String token,
String userId, String userRealName, String departmentId, String departmentName) {
DangerExecuteSubmitDto executeSubmitDto = new DangerExecuteSubmitDto();
executeSubmitDto.setIsOk(true);
LatentDangerBo latentDangerBo = latentDangerMapper.getByInstanceId(instanceId);
if (latentDangerBo != null) {
LatentDangerFlowRecordBo currentRecord = latentDangerFlowRecordMapper.getById(latentDangerBo.getCurrentFlowRecordId());
if (actionType.equals(1)) {
//通过
LatentDangerExcuteTypeEnum excuteTypeEnum = LatentDangerExcuteTypeEnum.公司负责人审核通过;
updateFlowRecord(currentRecord, excuteTypeEnum, userId, departmentId, remark, null);
JSONObject flowJson = remoteWorkFlowService.allTasksInProcessInstanceId(latentDangerBo.getInstanceId());
if (flowJson == null) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
return executeSubmitDto;
}
LatentDangerPatrolBo patrolBo = null;
String userIds;
if (latentDangerBo.getDangerType().equals(LatentDangerTypeEnum.计划检查.getCode())) {
patrolBo = latentDangerPatrolMapper.getByDangerId(latentDangerBo.getId());
userIds = Joiner.on(",").join(getUserIdsStrByPerTypeAndDefKey(flowJson));
} else {
LatentDangerFlowRecordBo recordBo = latentDangerFlowRecordMapper.getByDangerIdAndActionFlag(latentDangerBo.getId(), "B_8");
userIds = recordBo.getFlowTaskUserIds();
}
LatentDangerFlowRecordBo record = saveFlowRecord(flowJson.getString("id"), userIds,
flowJson.getString("name"), flowJson.getString("taskDefinitionKey"), latentDangerBo.getId());
latentDangerBo.setCurrentFlowRecordId(record.getId());
latentDangerBo.setDangerState(excuteTypeEnum.getNextState().getCode());
latentDangerMapper.update(latentDangerBo);
///web推送刷新消息
// dangerStateChangeWebSockte(latentDangerBo);
// Set<String> nextExecuteUserIds = Sets.newHashSet(Arrays.asList(userIds.split(",")));
sendMessage(latentDangerBo, excuteTypeEnum, patrolBo, currentRecord.getFlowTaskName(), this.getNextExecuteUsers(latentDangerBo.getInstanceId()), userRealName, departmentName);
} else if (actionType.equals(2)) {
//终止
latentDangerBo.setDangerState(LatentDangerStateEnum.已撤销.getCode());
latentDangerMapper.update(latentDangerBo);
// remoteWorkFlowService.stop(latentDangerBo.getInstanceId());
if (latentDangerBo.getDangerType().equals(LatentDangerTypeEnum.计划检查.getCode())) {
LatentDangerPatrolBo patrolBo = latentDangerPatrolMapper.getByDangerId(latentDangerBo.getId());
if (patrolBo.getClassifyOriginalId() != null && patrolBo.getItemOriginalId() != null) {
updateMeasuresContentStatus(Long.valueOf(patrolBo.getClassifyOriginalId()), Long.valueOf(patrolBo.getItemOriginalId()),
patrolBo.getRiskFactorFlowId(), RiskFactorsCmStatusEnum.Control);
}
LatentDangerLevelEnum levelEnum = LatentDangerLevelEnum.getByCode(latentDangerBo.getDangerLevel());
if (levelEnum != null) {
updateRiskSourceDangerState(false, Long.valueOf(patrolBo.getPointOriginalId()), levelEnum, patrolBo.getPointId(), latentDangerBo.getId());
}
executeSubmitDto.setDangerId(latentDangerBo.getId());
executeSubmitDto.setDangerName(latentDangerBo.getDangerName());
executeSubmitDto.setPointOriginalId(patrolBo.getPointOriginalId());
executeSubmitDto.setPointId(patrolBo.getPointId());
executeSubmitDto.setExecuteTypeEnum(LatentDangerExcuteTypeEnum.隐患评审拒绝);
}
} else if (actionType.equals(3)) {
//拒绝
LatentDangerExcuteTypeEnum excuteTypeEnum = LatentDangerExcuteTypeEnum.公司负责人审核拒绝;
updateFlowRecord(currentRecord, excuteTypeEnum, userId, departmentId, remark, null);
JSONObject flowJson = remoteWorkFlowService.allTasksInProcessInstanceId(latentDangerBo.getInstanceId());
if (flowJson == null) {
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
return executeSubmitDto;
}
LatentDangerPatrolBo patrolBo = null;
String userIds;
if (latentDangerBo.getDangerType().equals(LatentDangerTypeEnum.计划检查.getCode())) {
patrolBo = latentDangerPatrolMapper.getByDangerId(latentDangerBo.getId());
userIds = Joiner.on(",").join(getUserIdsStrByPerTypeAndDefKey(flowJson));
} else {
LatentDangerFlowRecordBo recordBo = latentDangerFlowRecordMapper.getByDangerIdAndActionFlag(latentDangerBo.getId(), "B_3");
userIds = recordBo.getFlowTaskUserIds();
}
LatentDangerFlowRecordBo record = saveFlowRecord(flowJson.getString("id"), userIds,
flowJson.getString("name"), flowJson.getString("taskDefinitionKey"), latentDangerBo.getId());
latentDangerBo.setCurrentFlowRecordId(record.getId());
latentDangerBo.setDangerState(excuteTypeEnum.getNextState().getCode());
latentDangerMapper.update(latentDangerBo);
///web推送刷新消息
// dangerStateChangeWebSockte(latentDangerBo);
// Set<String> nextExecuteUserIds = Sets.newHashSet(Arrays.asList(userIds.split(",")));
sendMessage(latentDangerBo, excuteTypeEnum, patrolBo, currentRecord.getFlowTaskName(), this.getNextExecuteUsers(latentDangerBo.getInstanceId()), userRealName, departmentName);
}
}
return executeSubmitDto;
}
@Override
public void updateDangerStateOfOvertime() {
logger.info("修改治理过期隐患的逾期状态");
List<LatentDangerBo> overtimeList = latentDangerMapper.listOfOvertime();
for (LatentDangerBo latentDangerBo : overtimeList) {
latentDangerBo.setOvertimeState(LatentDangerOvertimeStateEnum.已超时.getCode());
latentDangerMapper.update(latentDangerBo);
if (latentDangerBo.getDangerType().equals(LatentDangerTypeEnum.计划检查.getCode())) {
LatentDangerPatrolBo patrolBo = latentDangerPatrolMapper.getByDangerId(latentDangerBo.getId());
LatentDangerResultPushSpcRequest spcRequest = new LatentDangerResultPushSpcRequest();
spcRequest.setProcessingTime(DateUtil.date2Str(new Date(), DateUtil.DATETIME_DEFAULT_FORMAT));
spcRequest.setHiddenTroubleName(latentDangerBo.getDangerName());
spcRequest.setRiskSourceId(patrolBo.getPointOriginalId());
spcRequest.setHiddenTroubleStatus("治理逾期");
spcRequest.setTroubleList(getTroubleList(patrolBo.getPointId()));
remoteSpcService.pushLatentDangerExcuteResult(spcRequest);
}
}
//推送页面刷新
// remoteWebSocketServer.wsDataRefresh("dangerOverdue");
// 即将逾期的隐患发送消息提醒用户
List<LatentDangerNoticeBo> needNoticeDangerList = latentDangerMapper.listNeedNoticeDanger();
if (!CollectionUtils.isEmpty(needNoticeDangerList)) {
logger.info("隐患治理即将逾期通知》》》》");
needNoticeDangerList.forEach(danger -> {
asyncTask.pushLatentDangerReformLimitDateExpireMessage(this.getNextExecuteUsers(danger.getInstanceId()),
danger.getOrgCode(),
danger.getDangerName(), DateUtil.date2Str(danger.getReformLimitDate(), DateUtil.DATETIME_DEFAULT_FORMAT),
danger.getDangerId(),
danger.getDangerState(),"");
});
}
}
/**
* web安全态势预控 （ 隐患按车间/部门统计） 模块推送刷新消息
*/
private void dangerStateChangeWebSockte(LatentDangerBo latentDangerBo) {
Integer state = latentDangerBo.getDangerState();
Integer type = latentDangerBo.getDangerType();
if (LatentDangerTypeEnum.计划检查.getCode().equals(type)
|| LatentDangerTypeEnum.无计划检查.getCode().equals(type)) {
if (LatentDangerStateEnum.待治理.getCode().equals(state)
// || LatentDangerStateEnum.安措计划中.getCode().equals(state)
|| LatentDangerStateEnum.待验证.getCode().equals(state)) {
remoteWebSocketServer.wsDataRefresh("dangerExecute");
}
}
}
@Override
public CommonResponse listFlowRecord(String token, String product, String appKey, Long id) {
LatentDangerBo latentDangerBo = latentDangerMapper.getById(id);
if (latentDangerBo == null) {
return CommonResponseUtil.failure("隐患不存在");
}
LatentDangerDetailVo detailVo = new LatentDangerDetailVo();
detailVo.setDangerName(latentDangerBo.getDangerName());
detailVo.setLevel(latentDangerBo.getDangerLevel());
detailVo.setPosition(latentDangerBo.getStructureName());
LatentDangerLevelEnum levelEnum = LatentDangerLevelEnum.getByCode(latentDangerBo.getDangerLevel());
if (levelEnum != null) {
detailVo.setLevelDesc(levelEnum.getName());
}
List<LatentDangerFlowRecordBo> records = latentDangerFlowRecordMapper.listByDangerId(latentDangerBo.getId());
if (!CollectionUtils.isEmpty(records)) {
Set<String> userIds = Sets.newHashSet();
Set<String> deptIds = Sets.newHashSet();
records.forEach(e -> {
if (!StringUtils.isEmpty(e.getExcuteUserId())) {
userIds.add(e.getExcuteUserId());
}
if (!StringUtils.isEmpty(e.getExcuteDepartmentId())) {
deptIds.add(e.getExcuteDepartmentId());
}
});
List<DepartmentModel> departmentBos = remoteSecurityService.getlistDepartmentByDeptIds(token,product,appKey,Joiner.on(",").join(deptIds));
List<AgencyUserModel> userModels = remoteSecurityService.listUserByUserIds(token,product,appKey,Joiner.on(",").join(userIds));
Map<String, AgencyUserModel> userMap = Maps.uniqueIndex(userModels, AgencyUserModel::getUserId);
Map<Long, DepartmentModel> departmentBoMap = Maps.uniqueIndex(departmentBos, DepartmentModel::getSequenceNbr);
for (LatentDangerFlowRecordBo recordBo : records) {
AgencyUserModel user = userMap.get(recordBo.getExcuteUserId());
if (user != null) {
recordBo.setExecuteUserName(user.getRealName());
}
DepartmentModel departmentBo = departmentBoMap.get(recordBo.getExcuteDepartmentId());
if (departmentBo != null) {
recordBo.setExecuteDepartmentName(departmentBo.getDepartmentName());
}
recordBo.setExecuteTime(DateUtil.date2Str(recordBo.getCreateDate(), DateUtil.DATETIME_DEFAULT_FORMAT));
}
detailVo.setRecords(records);
}
return CommonResponseUtil.success(detailVo);
}
// private void resetMeasuresContentStatus(LatentDangerBo latentDangerBo) {
// if (latentDangerBo.getDangerType().equals(LatentDangerTypeEnum.巡检隐患.getCode())
// || latentDangerBo.getDangerType().equals(LatentDangerTypeEnum.有码无计划隐患.getCode())) {
// logger.info("重置管控内容的状态为受控");
// //重置管控内容的状态为受控
//
// }
// }
public DangerExecuteSubmitDto executeSubmit(LatentDangerExcuteParam param,
LatentDangerExcuteTypeEnum executeTypeEnum,
LatentDangerBo latentDangerBo,
String userId,
String userRealName,
String departmentId,
String departmentName,
DangerExecuteSubmitDto executeSubmitDto,
RoleBo role) {
JSONObject executeJson = remoteWorkFlowService.excute(param.getTaskId(), executeTypeEnum.getRequestBody());
if (executeJson == null) {
executeSubmitDto.setIsOk(false);
executeSubmitDto.setMsg("执行失败");
return executeSubmitDto;
}
LatentDangerPatrolBo patrolBo = null;
if (latentDangerBo.getDangerType().equals(LatentDangerTypeEnum.计划检查.getCode())) {
patrolBo = latentDangerPatrolMapper.getByDangerId(latentDangerBo.getId());
}
JSONObject data = executeJson.getJSONObject("data");
if (executeTypeEnum.getNextState().equals(LatentDangerStateEnum.已撤销)) {
latentDangerBo.setDangerState(executeTypeEnum.getNextState().getCode());
saveFlowRecord(executeJson.getString("id"), data.getString("name"), userId, departmentId,
param.getFlowJson(), param.getDangerId(), role, executeTypeEnum.getName(),param.getRemark());
} else if (executeTypeEnum.getNextState().equals(LatentDangerStateEnum.治理完毕)) {
latentDangerBo.setDangerState(executeTypeEnum.getNextState().getCode());
saveFlowRecord(executeJson.getString("id"), data.getString("name"), userId, departmentId,
param.getFlowJson(), param.getDangerId(), role, executeTypeEnum.getName(),param.getRemark());
} else {
LatentDangerFlowRecordBo flowRecord = saveFlowRecord(executeJson.getString("id"), data.getString("name"), userId, departmentId,
param.getFlowJson(), param.getDangerId(), role, executeTypeEnum.getName(),param.getRemark());
latentDangerBo.setCurrentFlowRecordId(flowRecord.getId());
latentDangerBo.setDangerState(executeTypeEnum.getNextState().getCode());
if (executeTypeEnum.equals(LatentDangerExcuteTypeEnum.隐患常规治理)) {
latentDangerBo.setReformType(LatentDangerReformTypeEnum.常规整改.getCode());
latentDangerBo.setReformJson(param.getFlowJson().toJSONString());
latentDangerBo.setInferOtherThings(param.getInferOtherThings());
latentDangerBo.setProblemDescription(param.getReasonAnalysis());
latentDangerBo.setReasonAnalysis(param.getRemark());
} else if (executeTypeEnum.equals(LatentDangerExcuteTypeEnum.隐患延期治理)) {
latentDangerBo.setReformType(LatentDangerReformTypeEnum.延期治理.getCode());
latentDangerBo.setReformJson(param.getFlowJson().toJSONString());
latentDangerBo.setInferOtherThings(param.getInferOtherThings());
latentDangerBo.setProblemDescription(param.getReasonAnalysis());
latentDangerBo.setReasonAnalysis(param.getRemark());
latentDangerBo.setDelayLimitDate(DateUtil.str2Date(param.getDelayLimitDate(), DateUtil.DATETIME_DEFAULT_FORMAT));
}
if (executeTypeEnum.equals(LatentDangerExcuteTypeEnum.隐患评审通过)) {
latentDangerBo.setReformLimitDate(DateUtil.str2Date(param.getReformLimitDate(), DateUtil.DATETIME_DEFAULT_FORMAT));
latentDangerBo.setDangerLevel(param.getDangerLevel());
}
}
if (executeTypeEnum.equals(LatentDangerExcuteTypeEnum.隐患延期治理车间部门审核通过)) {
// 延期治理评审通过且 不需要 公司审核
if (param.getNeedCompanyVerify() == 0) {
latentDangerBo.setDangerState(LatentDangerStateEnum.延期治理申请.getCode());
latentDangerBo.setReformLimitDate(latentDangerBo.getDelayLimitDate());
} else {// 延期治理评审通过且 需要 公司审核
latentDangerBo.setDangerState(LatentDangerStateEnum.延期治理申请待公司审核.getCode());
LatentDangerFlowRecordBo recordBo =
latentDangerFlowRecordMapper.getByDangerIdAndCreate(latentDangerBo.getId());
String flowJsonStr = recordBo.getFlowJson();
JSONObject flowJson = JSONObject.parseObject(flowJsonStr);
flowJson.put("needCompanyVerify", param.getNeedCompanyVerify());
recordBo.setFlowJson(flowJson.toJSONString());
latentDangerFlowRecordMapper.update(recordBo);
}
} else if (executeTypeEnum.equals(LatentDangerExcuteTypeEnum.隐患延期治理车间部门审核拒绝)) {
latentDangerBo.setDangerState(LatentDangerStateEnum.待治理.getCode());
} else if (executeTypeEnum.equals(LatentDangerExcuteTypeEnum.隐患延期治理公司审核通过)) {
latentDangerBo.setDangerState(LatentDangerStateEnum.延期治理申请.getCode());
latentDangerBo.setReformLimitDate(latentDangerBo.getDelayLimitDate());
} else if (executeTypeEnum.equals(LatentDangerExcuteTypeEnum.隐患延期治理公司审核拒绝)) {
latentDangerBo.setDangerState(LatentDangerStateEnum.延期治理申请待车间部门审核.getCode());
}
latentDangerMapper.update(latentDangerBo);
if (patrolBo != null) {
executeSubmitDto.setPointOriginalId(patrolBo.getPointOriginalId());
executeSubmitDto.setPointId(patrolBo.getPointId());
}
executeSubmitDto.setIsOk(true);
executeSubmitDto.setExecuteTypeEnum(executeTypeEnum);
executeSubmitDto.setDangerName(latentDangerBo.getDangerName());
executeSubmitDto.setDangerId(latentDangerBo.getId());
sendMessage(latentDangerBo, executeTypeEnum, patrolBo, executeTypeEnum.getName(), this.getNextExecuteUsers(latentDangerBo.getInstanceId()), userRealName, departmentName);
return executeSubmitDto;
}
private void sendMessage(LatentDangerBo latentDangerBo, LatentDangerExcuteTypeEnum excuteTypeEnum,
LatentDangerPatrolBo patrolBo, String flowTaskName, String informerList,
String userRealName, String departmentName) {
try {
if (excuteTypeEnum.equals(LatentDangerExcuteTypeEnum.隐患评审拒绝)) {
String pointName = null;
if (patrolBo != null) {
pointName = patrolBo.getPointName();
}
Set<String> sendUserIds = Sets.newHashSet(latentDangerBo.getDiscovererUserId());
asyncTask.pushLatentDangerExecuteMessage(informerList, latentDangerBo.getOrgCode(),
latentDangerBo.getDangerName(), pointName,
departmentName, latentDangerBo.getId(), userRealName,
flowTaskName, ExecuteStateEnum.驳回.getName(),
DateUtil.date2Str(new Date(), DateUtil.DATETIME_DEFAULT_FORMAT),
latentDangerBo.getDangerState());
} else if (excuteTypeEnum.equals(LatentDangerExcuteTypeEnum.隐患验证通过)) {
if (patrolBo != null) {
// RiskFactorBo riskFactorBo = riskFactorMapper.getById(Long.valueOf(patrolBo.getClassifyOriginalId()));
// Set<String> sendUserIds = Sets.newHashSet();
// if (riskFactorBo != null) {
// sendUserIds.addAll(Arrays.asList(riskFactorBo.getUserIds().split(",")));
// sendUserIds.add(riskFactorBo.getFirstEvaluateUserId());
// sendUserIds.add(riskFactorBo.getSecondEvaluateUserId());
// asyncTask.pushRiskWarnMessage(sendUserIds, latentDangerBo.getOrgCode(),
// latentDangerBo.getDangerName(), riskFactorBo.getId(),
// riskFactorBo.getName(), patrolBo.getPointName(),
// DateUtil.date2Str(new Date(), DateUtil.DATETIME_DEFAULT_FORMAT));
// }
// 更新p_check_input表state字段
updateCheckInputDangerState(latentDangerBo.getCheckInputId(), DangerHandleStateEnum.COMPLETED.getCode());
DangerResultBo dangerResultBo = new DangerResultBo();
try {
business.processProtalDataFromDanger(dangerResultBo);
} catch (Exception e) {
throw new RuntimeException("隐患治理完成调用站端接口出错！");
}
}
} else {
String pointName = null;
if (patrolBo != null) {
pointName = patrolBo.getPointName();
}
asyncTask.pushLatentDangerExecuteMessage(informerList, latentDangerBo.getOrgCode(),
latentDangerBo.getDangerName(), pointName,
departmentName, latentDangerBo.getId(), userRealName,
flowTaskName, excuteTypeEnum.getExcuteState().getName(),
DateUtil.date2Str(new Date(), DateUtil.DATETIME_DEFAULT_FORMAT),
latentDangerBo.getDangerState());
if (excuteTypeEnum.equals(LatentDangerExcuteTypeEnum.隐患评审通过)) {
// 隐患治理到期时间为当天，则立即提示消息
Date reformLimitDate = latentDangerBo.getReformLimitDate();
if (DateUtil.getDateFormat(new Date()).equals(DateUtil.getDateFormat(reformLimitDate))) {
asyncTask.pushLatentDangerReformLimitDateExpireMessage(informerList,
latentDangerBo.getOrgCode(), latentDangerBo.getDangerName(),
DateUtil.date2Str(latentDangerBo.getReformLimitDate(), DateUtil.DATETIME_DEFAULT_FORMAT),
latentDangerBo.getId(),
latentDangerBo.getDangerState(),userRealName);
}
}
}
} catch (Exception e) {
logger.error("隐患执行发送消息失败", e);
}
}
private void updateSpcStateToControl(LatentDangerPatrolBo patrolBo, LatentDangerBo latentDangerBo) {
if (patrolBo.getClassifyOriginalId() != null && patrolBo.getItemOriginalId() != null) {
updateMeasuresContentStatus(Long.valueOf(patrolBo.getClassifyOriginalId()), Long.valueOf(patrolBo.getItemOriginalId()),
patrolBo.getRiskFactorFlowId(), RiskFactorsCmStatusEnum.Control);
}
LatentDangerLevelEnum levelEnum = LatentDangerLevelEnum.getByCode(latentDangerBo.getDangerLevel());
if (levelEnum != null) {
updateRiskSourceDangerState(false, Long.valueOf(patrolBo.getPointOriginalId()), levelEnum, patrolBo.getPointId(), latentDangerBo.getId());
}
}
// private void wakeUpRiskFactorFlow(LatentDangerPatrolBo patrolBo, String token) {
// Integer notFinishFlow = latentDangerMapper.countNotFinishByFlowId(patrolBo.getRiskFactorFlowId());
// if (notFinishFlow == 0) {
// logger.info("解冻原来的A流程");
// //解冻原来的A流程
// remoteSpcService.wakeUpOrRestartRiskFactorFlow(patrolBo.getRiskFactorFlowId(), WorkFlowRiskFactorUriEnum.流程回调, token, RiskFactorWorkFlowActionTypeEnum.唤起流程);
// }
// }
@Async
@Override
public void sendLatentDangerExcuteResult(DangerExecuteSubmitDto executeSubmitDto) {
LatentDangerExcuteTypeEnum excuteTypeEnum = executeSubmitDto.getExecuteTypeEnum();
String dangerName = executeSubmitDto.getDangerName();
String pointOriginalId = executeSubmitDto.getPointOriginalId();
Long pointId = executeSubmitDto.getPointId();
String status = null;
if (excuteTypeEnum.equals(LatentDangerExcuteTypeEnum.隐患评审通过)) {
status = "隐患评审通过";
} else if (excuteTypeEnum.equals(LatentDangerExcuteTypeEnum.隐患评审拒绝)) {
status = "隐患评审不通过";
} else if (excuteTypeEnum.equals(LatentDangerExcuteTypeEnum.隐患验证拒绝)) {
status = "治理验证不通过";
} else if (excuteTypeEnum.equals(LatentDangerExcuteTypeEnum.隐患验证通过)) {
status = "治理验证完成";
}
if (status != null) {
LatentDangerResultPushSpcRequest spcRequest = new LatentDangerResultPushSpcRequest();
spcRequest.setProcessingTime(DateUtil.date2Str(new Date(), DateUtil.DATETIME_DEFAULT_FORMAT));
spcRequest.setHiddenTroubleName(dangerName);
spcRequest.setRiskSourceId(pointOriginalId);
spcRequest.setHiddenTroubleStatus(status);
spcRequest.setTroubleList(getTroubleList(pointId));
remoteSpcService.pushLatentDangerExcuteResult(spcRequest);
}
}
private List<String> getTroubleList(Long pointId) {
List<String> troubleList = Lists.newArrayList();
List<LatentDangerPatrolBo> patrolList = latentDangerPatrolMapper.listByPointId(pointId);
if (!CollectionUtils.isEmpty(patrolList)) {
List<Long> dangerIds = Lists.transform(patrolList, LatentDangerPatrolBo::getLatentDangerId);
List<LatentDangerFlowRecordBo> flowRecordBos = latentDangerFlowRecordMapper.listNewestRecordByDangerIds(dangerIds);
flowRecordBos.forEach(l -> {
String status = null;
if (l.getDangerState().equals(LatentDangerStateEnum.待治理.getCode())
&& l.getDangerOvertimeState().equals(LatentDangerOvertimeStateEnum.已超时.getCode())) {
status = "治理逾期";
} else {
if (l.getExcuteResult().equals(LatentDangerExcuteTypeEnum.隐患评审通过.getName())) {
status = "隐患评审通过";
} else if (l.getExcuteResult().equals(LatentDangerExcuteTypeEnum.隐患评审拒绝.getName())) {
status = "隐患评审不通过";
} else if (l.getExcuteResult().equals(LatentDangerExcuteTypeEnum.隐患验证拒绝.getName())) {
status = "治理验证不通过";
} else if (l.getExcuteResult().equals(LatentDangerExcuteTypeEnum.隐患验证通过.getName())) {
status = "治理验证完成";
}
}
if (status != null) {
troubleList.add(status);
}
});
}
return troubleList;
}
private void updateRiskSourceDangerState(Boolean isSave, Long riskSourceId, LatentDangerLevelEnum
levelEnum, Long pointId, Long dangerId) {
RiskSourceBo riskSourceBo = riskSourceMapper.getById(riskSourceId);
if (riskSourceBo != null) {
if (isSave) {
//添加隐患
riskSourceBo.setIsDanger(true);
if (riskSourceBo.getDangerLevel() == null) {
riskSourceBo.setDangerLevel(levelEnum.getRiskSourceDangerLevelCode());
} else {
// if (riskSourceBo.getDangerLevel().equals(LatentDangerLevelEnum.一般隐患.getRiskSourceDangerLevelCode())
// && levelEnum.equals(LatentDangerLevelEnum.重大隐患)) {
// riskSourceBo.setDangerLevel(levelEnum.getRiskSourceDangerLevelCode());
// }
if (Integer.parseInt(riskSourceBo.getDangerLevel()) < Integer.parseInt(levelEnum.getRiskSourceDangerLevelCode())) {
riskSourceBo.setDangerLevel(levelEnum.getRiskSourceDangerLevelCode());
}
}
} else {
//撤销、完成隐患
HashMap<String, Object> params = new HashMap<>();
params.put("pointId", pointId);
params.put("dangerId", dangerId);
List<LatentDangerBo> latentDangerBos = latentDangerMapper.listNotFinishByPointId(params);
if (CollectionUtils.isEmpty(latentDangerBos)) {
riskSourceBo.setIsDanger(false);
} else {
riskSourceBo.setIsDanger(true);
String dangerLevel = checkHasSeriousDanger(latentDangerBos);
riskSourceBo.setDangerLevel(dangerLevel);
}
}
riskSourceMapper.updateDangerState(riskSourceBo);
}
}
private String checkHasSeriousDanger(List<LatentDangerBo> latentDangerBos) {
String dangerLevel = LatentDangerLevelEnum.安全问题.getRiskSourceDangerLevelCode();
for (LatentDangerBo latentDangerBo : latentDangerBos) {
// if (latentDangerBo.getDangerLevel().equals(LatentDangerLevelEnum.重大隐患.getCode())) {
// return LatentDangerLevelEnum.重大隐患.getRiskSourceDangerLevelCode();
// }
}
int code = latentDangerBos.stream().mapToInt(LatentDangerBo::getDangerLevel).max().getAsInt();
dangerLevel = LatentDangerLevelEnum.getByCode(code).getRiskSourceDangerLevelCode();
return dangerLevel;
}
@Override
public void freshRiskJudgmentLangerCount(LatentDangerExcuteParam latentDangerExcuteParam) {
Long currentFlowRecordId = latentDangerExcuteParam.getFlowRecordId();
LatentDangerFlowRecordBo currentRecord = latentDangerFlowRecordMapper.getById(currentFlowRecordId);
if (currentRecord == null) {
return;
}
LatentDangerBo latentDangerBo = latentDangerMapper.getById(currentRecord.getDangerId());
if (latentDangerBo == null) {
return;
}
LatentDangerPatrolBo patrolBo = latentDangerPatrolMapper.getByDangerId(latentDangerBo.getId());
if (patrolBo != null && StringUtil.isNotEmpty(patrolBo.getPointOriginalId())) {
iRiskJudgmentTaskService.freshRiskJudgmentLangerCount(Long.parseLong(patrolBo.getPointOriginalId()));
}
}
@Override
public Object getDangerLevel(String token, String product, String appKey, String dictCode) {
JSONArray jsonArray = remoteSecurityService.listDictionaryByDictCode(token, product, appKey, dictCode);
return jsonArray;
}
@Override
public JSONObject getDangerLevelJsonObject(String dangerLevelStr, String token, String product, String appKey, String dictCode) {
JSONArray dangerLevelList = (JSONArray) this.getDangerLevel(token, product, appKey, dictCode);
JSONObject dangerLevel = new JSONObject();
List<Object> objs =
dangerLevelList.stream().filter(level -> ((JSONObject) level).get("dictDataKey").equals(dangerLevelStr)).collect(Collectors.toList());
if (!CollectionUtils.isEmpty(objs)) {
dangerLevel = (JSONObject) objs.get(0);
}
return dangerLevel;
}
@Override
public JSONObject getReviewInfo(Long dangerId) {
List<HashMap<String, Object>> result = latentDangerMapper.getReViewInfo(dangerId);
Set<String> userIdSet = Sets.newHashSet();
result.forEach(r -> {
userIdSet.add((String) r.get("executeUserId"));
if (StringUtil.isNotEmpty(r.get("handleUserIds"))) {
List<String> handleUserIds = Arrays.asList(r.get("handleUserIds").toString().split(","));
userIdSet.addAll(handleUserIds);
}
});
userIdSet.removeAll(Collections.singleton(null));
List<AgencyUserModel> userModels = remoteSecurityService.listUserByUserIds(Joiner.on(",").join(userIdSet));
if (StringUtil.isNotEmpty(userModels)) {
Map<String, AgencyUserModel> userMap = Maps.uniqueIndex(userModels, AgencyUserModel::getUserId);
result.forEach(r -> {
r.put("executeUserName", StringUtil.isNotEmpty(r.get("executeUserId")) ? userMap.get(r.get(
"executeUserId")).getRealName() : "");
List<String> handleUserNames = Lists.newArrayList();
if (StringUtil.isNotEmpty(r.get("handleUserIds"))) {
List<String> handleUserIds = Arrays.asList(r.get("handleUserIds").toString().split(","));
handleUserIds.forEach(id -> handleUserNames.add(userMap.get(id).getRealName()));
}
r.put("handleUserName", Joiner.on(",").join(handleUserNames));
});
}
JSONObject resultObjJson = new JSONObject();
result.forEach(r -> {
r.put("flowJson", JSON.parseObject((String) r.get("flowJson")));
resultObjJson.put((String) r.get("actionFlag"), JSONObject.toJSON(r));
});
return resultObjJson;
}
@Override
public Page<DangerListResponse> listDanger(PageParam pageParam) {
String idsStr = (String) pageParam.get("dangerIds");
if (StringUtil.isNotEmpty(idsStr)) {
List<String> dangerIdList = Lists.newArrayList(idsStr.split(","));
pageParam.put("dangerIds", dangerIdList);
}
if (StringUtil.isNotEmpty(pageParam.get("pageNumber")) && StringUtil.isNotEmpty(pageParam.get("pageSize"))) {
int offSet = (int) pageParam.get("pageNumber") * (int) pageParam.get("pageSize");
pageParam.put("offset", offSet);
}
// 获取隐患地点的子节点
Object structureId = pageParam.get("structureId");
List<Long> structureIdList = null;
if (structureId != null && structureId.toString().trim().length() > 0) {
LinkedHashMap<String,Object> o = equipFeign.getBuildingTree();
if(o==null||!"200".equals(o.get("status").toString())) {
throw new YeeException("获取建筑树出错");
}
List<Map<String, Object>> buildingTree = (List<Map<String, Object>>) o.get("result");
Map<String, Object> node = getAllNodes(buildingTree).stream().filter(map -> structureId.equals(map.get("id"))).findFirst().orElse(null);
if (node != null) {
structureIdList = findBuildChildrenIds(node);
}
}
pageParam.put("structureId", structureIdList);
List<DangerListResponse> dangerListResponseList = latentDangerMapper.dangerListByMap(pageParam);
Map<Long, String> buildingAbsolutePositionMap = new HashMap<>();
try {
LinkedHashMap<String, Object> buildingAbsolutePosition = equipFeign.getBuildingAbsolutePosition();
if (buildingAbsolutePosition == null || !"200".equals(buildingAbsolutePosition.get("status").toString())) {
throw new YeeException("获取建筑树出错");
}
buildingAbsolutePositionMap = (Map<Long, String>) buildingAbsolutePosition.get("result");
} catch (Exception e) {
}
if (!dangerListResponseList.isEmpty()) {
Map<Long, String> finalBuildingAbsolutePositionMap = buildingAbsolutePositionMap;
dangerListResponseList.forEach(danger->danger.setStructureName(finalBuildingAbsolutePositionMap.get(danger.getStructureId())));
}
Long count = latentDangerMapper.countDangerListByMap(pageParam);
if (CollectionUtils.isEmpty(dangerListResponseList)) {
return new PageImpl<>(dangerListResponseList, pageParam, 0L);
}
return new PageImpl<>(dangerList(dangerListResponseList), pageParam, count);
}
private List<Map<String, Object>> getAllNodes(List<Map<String, Object>> buildingTree) {
List<Map<String, Object>> res = new LinkedList<>();
if (buildingTree != null && !buildingTree.isEmpty()) {
res.addAll(buildingTree);
buildingTree.forEach(building -> {
List<Map<String, Object>> childrenTree = (List<Map<String, Object>>) building.get("children");
res.addAll(getAllNodes(childrenTree));
});
}
return res;
}
private List<Long> findBuildChildrenIds(Map<String, Object> building) {
List<Map<String, Object>> buildingTree = getAllNodes(Collections.singletonList(building));
return buildingTree.stream().map(building123 -> Long.valueOf(building123.get("id").toString())).collect(Collectors.toList());
}
@Override
public List<DangerListResponse> export(PageParam pageParam) {
String idsStr = (String) pageParam.get("dangerIds");
if (StringUtil.isNotEmpty(idsStr)) {
List<String> dangerIdList = Lists.newArrayList(idsStr.split(","));
pageParam.put("dangerIds", dangerIdList);
}
List<DangerListResponse> dangerListResponseList = latentDangerMapper.dangerListByMap(pageParam);
return dangerList(dangerListResponseList);
}
@Override
public List<DangerTimeAxisVo> queryExecuteLog(Integer dateTime) {
Map<String, Object> param = new HashMap<>();
// String endTime = com.yeejoin.amos.maintenance.core.util.DateUtil.getShortCurrentDate();
String beginTime = "";
if (dateTime != null && dateTime == 7) {
beginTime = com.yeejoin.amos.maintenance.core.util.DateUtil.getIntervalDateStr(new Date(), -7, "yyyy-MM-dd");
} else if (dateTime != null && dateTime == 30) {
beginTime = com.yeejoin.amos.maintenance.core.util.DateUtil.getIntervalDateStr(new Date(), -30, "yyyy-MM-dd");
} else {
beginTime = com.yeejoin.amos.maintenance.core.util.DateUtil.getShortCurrentDate();
}
param.put("beginTime", beginTime + " 00:00:00");
// param.put("endTime",endTime + " 23:59:59");
List<DangerTimeAxisVo> list = latentDangerFlowRecordMapper.listExecuteLog(param);
String d;
if (0 < list.size()) {
for (DangerTimeAxisVo vo : list) {
AgencyUserModel userModel = remoteSecurityService.getUserById(RequestContext.getToken(), getProduct(), RequestContext.getAppKey(), vo.getExecuteUserId().toString());
vo.setUserName(userModel.getRealName());
vo.setDangerState(LatentDangerStateEnum.getEnumName(Integer.valueOf(vo.getDangerState())));
vo.setXAxis(null == vo.getUpdateDate() ? DateUtil.getDateFormat(new Date(), DateUtil.DATETIME_DEFAULT_FORMAT) : DateUtil.getDateFormat(vo.getUpdateDate(), DateUtil.DATETIME_DEFAULT_FORMAT));
vo.setRow1(vo.getUserName() + "-" + vo.getDangerState() + "-" + vo.getDangerName());
if ("3".equals(vo.getReformType())) {
d = null == vo.getDelayLimitDate() ? "无" : DateUtil.getDateFormat(vo.getDelayLimitDate(), DateUtil.DATETIME_DEFAULT_FORMAT);
} else {
d = null == vo.getReformLimitDate() ? "无" : DateUtil.getDateFormat(vo.getReformLimitDate(), DateUtil.DATETIME_DEFAULT_FORMAT);
}
vo.setRow2(vo.getStructureName() + "-" + d);
}
}
return list;
}
private List<DangerListResponse> dangerList(List<DangerListResponse> dangerListResponseList) {
JSONArray array = remoteSecurityService.listDictionaryByDictCode(RequestContext.getToken(), getProduct(), RequestContext.getAppKey(),
DictTypeEnum.DANGERLEVEL.getCode());
List<DictBo> dangerLevelList = JSONArray.parseArray(array.toJSONString(), DictBo.class);
for (DangerListResponse e : dangerListResponseList) {
e.setDangerState(LatentDangerStateEnum.getEnumName(Integer.valueOf(e.getDangerState())));
DictBo dangerLevel =
dangerLevelList.stream().filter(item -> item.getDictDataKey().equals(e.getDangerLevel())).collect(Collectors.toList()).get(0);
e.setDangerLevel(dangerLevel.getDictDataValue());
e.setReformType(!StringUtil.isNotEmpty(e.getReformType()) ? "" :
LatentDangerReformTypeEnum.getByCode(Integer.valueOf(e.getReformType())).getName());
e.setOvertimeState("0".equals(e.getOvertimeState()) ? "否" : "是");
e.setDangerTypeName(LatentDangerTypeEnum.getEnumName(Integer.valueOf(e.getDangerType())));
e.setDeadline(null == e.getDeadlineDate() ? "" : DateUtil.getLongDate(e.getDeadlineDate()));
}
return dangerListResponseList;
}
//获取下一节点需要发消息的用户信息
public String getNextExecuteUsers(String instanceId) {
String informerList= "";
JSONObject object = remoteWorkFlowService.getChildNodeDetail(instanceId);
if(object!=null){
JSONArray array = object.getJSONArray("data");
if(array.size()>0){
JSONObject workFlowDetail = array.getJSONObject(0);
informerList = workFlowDetail.getString("informerList");
}
}
return informerList;
}
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/service/impl/PlanTaskServiceImpl.java
View file @ 3b4c9369
...@@ -24,6 +24,7 @@ import com.yeejoin.amos.maintenance.business.util.Toke; ...@@ -24,6 +24,7 @@ import com.yeejoin.amos.maintenance.business.util.Toke;
import com.yeejoin.amos.maintenance.business.vo.CalDateVo; import com.yeejoin.amos.maintenance.business.vo.CalDateVo;
import com.yeejoin.amos.maintenance.business.vo.LeavePlanTaskVo; import com.yeejoin.amos.maintenance.business.vo.LeavePlanTaskVo;
import com.yeejoin.amos.maintenance.business.vo.PlanTaskVo; import com.yeejoin.amos.maintenance.business.vo.PlanTaskVo;
import com.yeejoin.amos.maintenance.common.enums.PlanTaskFinishStatusEnum;
import com.yeejoin.amos.maintenance.core.common.request.CommonPageable; import com.yeejoin.amos.maintenance.core.common.request.CommonPageable;
import com.yeejoin.amos.maintenance.core.common.response.AppCheckInputRespone; import com.yeejoin.amos.maintenance.core.common.response.AppCheckInputRespone;
import com.yeejoin.amos.maintenance.core.common.response.AppPointCheckRespone; import com.yeejoin.amos.maintenance.core.common.response.AppPointCheckRespone;
...@@ -569,6 +570,10 @@ public class PlanTaskServiceImpl implements IPlanTaskService { ...@@ -569,6 +570,10 @@ public class PlanTaskServiceImpl implements IPlanTaskService {
params.put("offset", pageParam.getOffset()); params.put("offset", pageParam.getOffset());
params.put("pageSize", pageParam.getPageSize()); params.put("pageSize", pageParam.getPageSize());
content = planTaskMapper.getPlanTasks(params); content = planTaskMapper.getPlanTasks(params);
content.forEach(r->{
String finishStatusDesc = PlanTaskFinishStatusEnum.getName(Integer.parseInt(r.get("finishStatus").toString()));
r.put("finishStatusDesc",finishStatusDesc);
});
return new PageImpl<>(content, pageParam, total); return new PageImpl<>(content, pageParam, total);
} }
......
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/service/impl/RiskJudgmentTaskServiceImpl.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.service.impl;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.assertj.core.util.Sets;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.typroject.tyboot.core.foundation.context.RequestContext;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.yeejoin.amos.boot.biz.common.bo.CompanyBo;
import com.yeejoin.amos.boot.biz.common.bo.DepartmentBo;
import com.yeejoin.amos.feign.privilege.model.AgencyUserModel;
import com.yeejoin.amos.feign.privilege.model.DepartmentModel;
import com.yeejoin.amos.maintenance.business.constants.XJConstant;
import com.yeejoin.amos.maintenance.business.dao.mapper.LatentDangerMapper;
import com.yeejoin.amos.maintenance.business.dao.mapper.RiskFactorMapper;
import com.yeejoin.amos.maintenance.business.dao.mapper.RiskJudgmentFillRecordMapper;
import com.yeejoin.amos.maintenance.business.dao.mapper.RiskJudgmentItemMapper;
import com.yeejoin.amos.maintenance.business.dao.mapper.RiskJudgmentTaskMapper;
import com.yeejoin.amos.maintenance.business.dao.mapper.RiskSourceMapper;
import com.yeejoin.amos.maintenance.business.dao.mapper.TaskworkMapper;
import com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentFillRecordBo;
import com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentItemBo;
import com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentTaskBo;
import com.yeejoin.amos.maintenance.business.entity.mybatis.RiskSourceBo;
import com.yeejoin.amos.maintenance.business.service.intfc.IRiskJudgmentTaskService;
import com.yeejoin.amos.maintenance.business.util.RandomUtil;
import com.yeejoin.amos.maintenance.business.util.StringUtil;
import com.yeejoin.amos.maintenance.common.enums.BooleanEnum;
import com.yeejoin.amos.maintenance.common.enums.RiskJudgeTaskworkTypeEnum;
import com.yeejoin.amos.maintenance.common.enums.RiskJudgmentSelectStatusEnum;
import com.yeejoin.amos.maintenance.common.enums.RiskJudgmentStatusEnum;
import com.yeejoin.amos.maintenance.common.enums.RiskJudgmentTaskStatusEnum;
import com.yeejoin.amos.maintenance.common.enums.RiskLevelEnum;
import com.yeejoin.amos.maintenance.common.enums.TaskworkTypeEnum;
import com.yeejoin.amos.maintenance.common.enums.WorkFlowDefinitionKeyEnum;
import com.yeejoin.amos.maintenance.common.remote.RemoteWorkFlowService;
import com.yeejoin.amos.maintenance.core.async.AsyncTask;
import com.yeejoin.amos.maintenance.core.util.DateUtil;
import com.yeejoin.amos.maintenance.feign.RemoteSecurityService;
@Service("iSpcRiskJudgmentTaskService")
public class RiskJudgmentTaskServiceImpl implements IRiskJudgmentTaskService {
private final Logger logger = LoggerFactory.getLogger(RiskJudgmentTaskServiceImpl.class);
@Autowired
private RiskJudgmentTaskMapper riskJudgmentTaskMapper;
@Autowired
private RiskSourceMapper riskSourceMapper;
@Autowired
private RiskJudgmentItemMapper riskJudgmentItemMapper;
@Autowired
private RiskJudgmentFillRecordMapper riskJudgmentFillRecordMapper;
@Autowired
private RiskFactorMapper riskFactorMapper;
@Autowired
private LatentDangerMapper latentDangerMapper;
@Autowired
private TaskworkMapper taskworkMapper;
@Autowired
private RemoteSecurityService remoteSecurityService;
@Autowired
private RemoteWorkFlowService remoteWorkFlowService;
@Autowired
private AsyncTask asyncTask;
private static final String permissionType = "activitiItem";
@Override
public void initRiskJudgmentTask(Date date) {
List<CompanyBo> companyBoList = remoteSecurityService.listCompanyTree();
if (CollectionUtils.isEmpty(companyBoList)) {
return;
}
List<CompanyBo> companyBos = Lists.newArrayList();
writeCompany(companyBoList, companyBos);
Map<String, String> deptWorkflowMap = buildDeptWorkflowMap(RequestContext.getToken(), RequestContext.getProduct(), RequestContext.getAppKey());
for (CompanyBo c : companyBos) {
List<DepartmentBo> departmentBos = Lists.newArrayList();
String companyId = c.getSequenceNbr().toString();
List<DepartmentBo> list = remoteSecurityService.getDepartmentTreeByCompanyId(companyId);
writeDepartment(list, departmentBos);
if (CollectionUtils.isEmpty(departmentBos)) {
continue;
}
JSONObject body = new JSONObject();
String businessKey = RandomUtil.buildOrderNo();
body.put("processDefinitionKey", WorkFlowDefinitionKeyEnum.风险研判评审.getProcessDefinitionKey());
body.put("businessKey", businessKey);
body.put("companyId", c.getSequenceNbr());
JSONObject startJson = remoteWorkFlowService.startWithAppKey(body);
if (startJson == null) {
logger.error(c.getCompanyName() + "启动风险研判流程失败");
continue;
}
JSONObject dataList = startJson.getJSONObject("dataList");
String instanceId = dataList.getJSONObject("historicInstance").getString("id");
JSONArray taskInstances = dataList.getJSONArray("taskInstances");
Map<String, JSONObject> taskDefinitionKeyMap = buildTaskDefinitionKeyMap(taskInstances);
for (DepartmentBo departmentBo : departmentBos) {
JSONObject taskInstance = getTaskInstanceByDeptCode(departmentBo.getDepartmentCode(), taskDefinitionKeyMap, deptWorkflowMap);
if (taskInstance != null) {
List<RiskJudgmentItemBo> items = riskJudgmentItemMapper.listAllItemByDepartmentCode(departmentBo.getDepartmentCode());
if (CollectionUtils.isEmpty(items)) {
logger.error("初始化风险研判任务失败,检查项表未配置该部门，部门编号===================>" + departmentBo.getSequenceNbr());
continue;
}
boolean success = initRiskJudgment(taskInstance, departmentBo, date, items, c.getOrgCode(), companyId, instanceId, businessKey);
if (!success) {
logger.error("初始化风险研判任务失败，部门编号===================>" + departmentBo.getSequenceNbr());
}
}
}
}
}
private JSONObject getTaskInstanceByDeptCode(String departmentCode, Map<String, JSONObject> taskDefinitionKeyMap,
Map<String, String> deptWorkflowMap) {
return taskDefinitionKeyMap.get(deptWorkflowMap.get(departmentCode));
}
private Map<String, String> buildDeptWorkflowMap(String token, String product, String appKey) {
Map<String, String> deptWorkflowMap = Maps.newHashMap();
JSONArray deptWorkflowArray = remoteSecurityService.listDictionaryByDictCode(token, product, appKey, XJConstant.DEPT_WF_MAP_DIC_CODE);
for (int i = 0; i < deptWorkflowArray.size(); i++) {
JSONObject deptWorkJson = deptWorkflowArray.getJSONObject(i);
deptWorkflowMap.put(deptWorkJson.getString("dictDataKey"), deptWorkJson.getString("dictDataValue"));
}
return deptWorkflowMap;
}
private Map<String, JSONObject> buildTaskDefinitionKeyMap(JSONArray arr) {
Map<String, JSONObject> map = Maps.newHashMap();
for (int i = 0; i < arr.size(); i++) {
JSONObject object = arr.getJSONObject(i);
map.put(object.getString("taskDefinitionKey"), object);
}
return map;
}
private boolean initRiskJudgment(JSONObject taskInstance, DepartmentBo departmentBo, Date date, List<RiskJudgmentItemBo> items, String orgCode, String companyId, String instanceId, String businessKey) {
try {
RiskJudgmentTaskBo riskJudgmentTaskBo = new RiskJudgmentTaskBo();
String currentFlowTaskId = taskInstance.getString("id");
String taskDefinitionKey = taskInstance.getString("taskDefinitionKey");
// 获取该departmentBo部门具有研判审批权限的用户ID
String reviewUserIds = getUserIds(taskDefinitionKey, companyId, departmentBo.getSequenceNbr().toString());
riskJudgmentTaskBo.setBusinessKey(businessKey);
riskJudgmentTaskBo.setFlowInstanceId(instanceId);
riskJudgmentTaskBo.setTaskStatus(RiskJudgmentStatusEnum.未开始.getCode());
riskJudgmentTaskBo.setTaskDefinitionKey(taskDefinitionKey);
riskJudgmentTaskBo.setCurrentFlowTaskId(currentFlowTaskId);
riskJudgmentTaskBo.setFlowUserIds(reviewUserIds);
riskJudgmentTaskBo.setTaskName("风险研判任务");
riskJudgmentTaskBo.setDepartmentId(departmentBo.getSequenceNbr().toString());
riskJudgmentTaskBo.setTaskDate(date);
riskJudgmentTaskBo.setOrgCode(orgCode);
riskJudgmentTaskMapper.save(riskJudgmentTaskBo);
List<RiskJudgmentFillRecordBo> records = Lists.newArrayList();
for (RiskJudgmentItemBo item : items) {
RiskJudgmentFillRecordBo record = new RiskJudgmentFillRecordBo();
record.setTaskId(riskJudgmentTaskBo.getId());
record.setItemId(item.getId());
String selectResultStr = null;
if (item.getSelectIsNeed().equals(BooleanEnum.YES.getCode())) {
StringBuilder selectResult = new StringBuilder();
JSONArray arr = JSONArray.parseArray(item.getSelectJson());
for (int i = 0; i < arr.size(); i++) {
JSONObject jsonObject = arr.getJSONObject(i);
if (jsonObject.getBoolean("defaultSelect")) {
selectResult.append(jsonObject.getString("id")).append(",");
}
}
if (selectResult.length() > 0) {
selectResultStr = selectResult.substring(0, selectResult.length() - 1);
}
}
record.setSelectResult(selectResultStr);
Long count = getCount(item.getItemFlag(), departmentBo.getSequenceNbr().toString());
if (count != null) {//数量回显
record.setInputResult(String.valueOf(count));
}
String defaultSelectId = getDefaultSelectId(item.getItemFlag(), departmentBo.getSequenceNbr().toString());
if (defaultSelectId != null) {//作业活动是否可控回显
record.setSelectResult(defaultSelectId);
}
record.setOrgCode(orgCode);
records.add(record);
}
riskJudgmentFillRecordMapper.saveBatch(records);
} catch (Exception e) {
logger.error("风险研判填写记录表初始化失败");
return false;
}
return true;
}
private String getDefaultSelectId(String itemFlag, String deptId) {
String defaultSelectId = null;
Long count = null;
switch (itemFlag) {
case "danger_work_control_a"://重大工艺操作
count = taskworkMapper.countViolateState(TaskworkTypeEnum.重大工艺操作.getCode(), deptId);
break;
case "danger_work_control_b"://检维修作业
count = taskworkMapper.countViolateState(TaskworkTypeEnum.检维修作业.getCode(), deptId);
break;
case "danger_work_control_c"://特殊动火作业
count = taskworkMapper.countViolateState(TaskworkTypeEnum.特殊动火作业.getCode(), deptId);
break;
case "danger_work_control_d"://一级动火作业
count = taskworkMapper.countViolateState(TaskworkTypeEnum.一级动火作业.getCode(), deptId);
break;
case "danger_work_control_e"://二级动火作业
count = taskworkMapper.countViolateState(TaskworkTypeEnum.二级动火作业.getCode(), deptId);
break;
case "danger_work_control_f"://进入受限空间作业
count = taskworkMapper.countViolateState(TaskworkTypeEnum.进入受限空间作业.getCode(), deptId);
break;
default:
break;
}
if (count != null && count > 0) {
defaultSelectId = RiskJudgmentSelectStatusEnum.不可控.getCode();//不可控
} else if (count != null && count == 0) {
defaultSelectId = RiskJudgmentSelectStatusEnum.可控.getCode();//可控
}
return defaultSelectId;
}
private String getUserIds(String path, String companyId, String departmentId) {
String reviewUserIds = "";
List<AgencyUserModel> userModels = remoteSecurityService.listUserByMenuCode(permissionType, path);
if (!CollectionUtils.isEmpty(userModels)) {
List<String> userIds = Lists.newArrayList();
for (AgencyUserModel userModel : userModels) {
String userId = getUserIdIsInDepartmentId(departmentId, userModel, companyId);
if (userId != null) {
userIds.add(userId);
}
}
if (!CollectionUtils.isEmpty(userIds)) {
reviewUserIds = Joiner.on(",").join(userIds);
}
}
return reviewUserIds;
}
private String getUserIdIsInDepartmentId(String departmentId, AgencyUserModel userModel, String companyId) {
Map<Long, List<DepartmentModel>> companyDepartments = userModel.getCompanyDepartments();
List<DepartmentModel> departments = companyDepartments.get(Long.valueOf(companyId));
if (!CollectionUtils.isEmpty(departments)) {
for (DepartmentModel departmentModel : departments) {
if (departmentModel.getSequenceNbr().toString().equals(departmentId)) {
return userModel.getUserId();
}
}
}
return null;
}
public Long getCount(String flag, String deptId) {
Long count = null;
switch (flag) {
case "other_latent_danger_state_"://安全问题--
count = latentDangerMapper.countNotFinishByTypeAndDeptId(0, deptId);
break;
case "other_latent_danger_state_a"://一般隐患--
count = latentDangerMapper.countNotFinishByTypeAndDeptId(1, deptId);
break;
case "other_latent_danger_state_b"://重大隐患--
count = latentDangerMapper.countNotFinishByTypeAndDeptId(2, deptId);
break;
case "other_latent_danger_state_c"://重大风险-1级
count = riskFactorMapper.countByLevelCodeAndDeptId(RiskLevelEnum.level_1.getCode(), deptId);
break;
case "other_latent_danger_state_d"://较大风险-2级
count = riskFactorMapper.countByLevelCodeAndDeptId(RiskLevelEnum.level_2.getCode(), deptId);
break;
case "other_latent_danger_state_e"://一般风险-3级
count = riskFactorMapper.countByLevelCodeAndDeptId(RiskLevelEnum.level_3.getCode(), deptId);
break;
case "other_latent_danger_state_f"://低风险-4级
count = riskFactorMapper.countByLevelCodeAndDeptId(RiskLevelEnum.level_4.getCode(), deptId);
break;
case "danger_work_control_a"://重大工艺操作
count = taskworkMapper.countByTypeAndDeptId(TaskworkTypeEnum.重大工艺操作.getCode(), deptId);
break;
case "danger_work_control_b"://检维修作业
count = taskworkMapper.countByTypeAndDeptId(TaskworkTypeEnum.检维修作业.getCode(), deptId);
break;
case "danger_work_control_c"://特殊动火作业
count = taskworkMapper.countByTypeAndDeptId(TaskworkTypeEnum.特殊动火作业.getCode(), deptId);
break;
case "danger_work_control_d"://一级动火作业
count = taskworkMapper.countByTypeAndDeptId(TaskworkTypeEnum.一级动火作业.getCode(), deptId);
break;
case "danger_work_control_e"://二级动火作业
count = taskworkMapper.countByTypeAndDeptId(TaskworkTypeEnum.二级动火作业.getCode(), deptId);
break;
case "danger_work_control_f"://进入受限空间作业
count = taskworkMapper.countByTypeAndDeptId(TaskworkTypeEnum.进入受限空间作业.getCode(), deptId);
break;
default:
break;
}
return count;
}
private void writeCompany(List<CompanyBo> tree, List<CompanyBo> companyBos) {
tree.forEach(d -> {
companyBos.add(d);
if (!CollectionUtils.isEmpty(d.getChildren())) {
writeCompany(d.getChildren(), companyBos);
}
});
}
private void writeDepartment(List<DepartmentBo> tree, List<DepartmentBo> departmentBos) {
tree.forEach(d -> {
if (d.getLevel().equals("shop")) {
departmentBos.add(d);
}
if (!CollectionUtils.isEmpty(d.getChildren())) {
writeDepartment(d.getChildren(), departmentBos);
}
});
}
@Override
public void updateRiskJudgmentTaskToOverTime(Date date) {
String dateStr = DateUtil.formatDatrToStr(date, DateUtil.SHORT_PATTERN);
RiskJudgmentTaskStatusEnum statusEnum = RiskJudgmentTaskStatusEnum.已超时;
List<RiskJudgmentTaskBo> taskBos = riskJudgmentTaskMapper.listByDateAndStatus(dateStr, RiskJudgmentTaskStatusEnum.进行中.getCode());
taskBos.forEach(e -> {
e.setTaskStatus(statusEnum.getCode());
try {
String cdate = DateUtil.formatDatrToStr(e.getTaskDate(), "yyyy年MM月dd日");
String userIds = e.getFlowUserIds();
Set<String> userIdSet = Sets.newHashSet(Arrays.asList(userIds.split(",")));
List<AgencyUserModel> reviewUserModels = remoteSecurityService.listUserByMenuCode(permissionType, e.getTaskDefinitionKey() + "_1");
List<AgencyUserModel> companyReviewUserModels = remoteSecurityService.listUserByMenuCode(permissionType, "G_9");
if (!CollectionUtils.isEmpty(reviewUserModels)) {
userIdSet.addAll(Lists.transform(reviewUserModels, AgencyUserModel::getUserId));
}
if (!CollectionUtils.isEmpty(companyReviewUserModels)) {
userIdSet.addAll(Lists.transform(companyReviewUserModels, AgencyUserModel::getUserId));
}
DepartmentBo departmentBo = remoteSecurityService.getDepartmentByDeptId(e.getDepartmentId());
asyncTask.pushRiskJudgmentMessage(this.getNextExecuteUsers(e.getFlowInstanceId()), e.getOrgCode(), e.getTaskName(),
cdate, departmentBo.getDepartmentName(),
statusEnum.getName(), e.getId(), statusEnum.getCode());
} catch (Exception ex) {
logger.error("风险研判推送异常", ex);
}
});
if (taskBos.size() > 0) {
riskJudgmentTaskMapper.updateBatch(taskBos);
}
}
@Override
public void updateRiskJudgmentTaskToProcess(Date date) {
String dateStr = DateUtil.formatDatrToStr(date, DateUtil.SHORT_PATTERN);
RiskJudgmentTaskStatusEnum statusEnum = RiskJudgmentTaskStatusEnum.进行中;
List<RiskJudgmentTaskBo> taskBos = riskJudgmentTaskMapper.listByDateAndStatus(dateStr, RiskJudgmentTaskStatusEnum.未开始.getCode());
taskBos.forEach(e -> {
e.setTaskStatus(statusEnum.getCode());
try {
String cdate = DateUtil.formatDatrToStr(e.getTaskDate(), "yyyy年MM月dd日");
DepartmentBo departmentBo = remoteSecurityService.getDepartmentByDeptId(e.getDepartmentId());
Set<String> userIds = Sets.newHashSet(Arrays.asList(e.getFlowUserIds().split(",")));
asyncTask.pushRiskJudgmentMessage(this.getNextExecuteUsers(e.getFlowInstanceId()), e.getOrgCode(),
e.getTaskName(), cdate, departmentBo.getDepartmentName(),
statusEnum.getName(), e.getId(), e.getTaskStatus());
} catch (Exception ex) {
logger.error("风险研判推送异常", ex);
}
});
if (taskBos.size() > 0) {
riskJudgmentTaskMapper.updateBatch(taskBos);
}
}
@Override
public void freshRiskJudgmentLangerCount(Long riskSourceId) {
RiskSourceBo riskSource = riskSourceMapper.getById(riskSourceId);
if (riskSource != null && StringUtil.isNotEmpty(riskSource.getBelongDepartmentId())) {
Long count1 = latentDangerMapper.countNotFinishByTypeAndDeptId(1, riskSource.getBelongDepartmentId());
Long count2 = latentDangerMapper.countNotFinishByTypeAndDeptId(2, riskSource.getBelongDepartmentId());
Long count0 = latentDangerMapper.countNotFinishByTypeAndDeptId(0, riskSource.getBelongDepartmentId());
Map<String, Object> map = new HashMap<String, Object>();
map.put("departmentId", riskSource.getBelongDepartmentId());
map.put("inputResult", count1);
map.put("taskStatus", RiskJudgmentTaskStatusEnum.进行中.getCode());
map.put("itemFlag", "other_latent_danger_state_a");
riskJudgmentFillRecordMapper.updateInputResultAndselectResult(map);//更新一般隐患数量
map.put("inputResult", count2);
map.put("itemFlag", "other_latent_danger_state_b");
riskJudgmentFillRecordMapper.updateInputResultAndselectResult(map);//更新重大隐患数量
map.put("inputResult", count0);
map.put("itemFlag", "other_latent_danger_state_z");
riskJudgmentFillRecordMapper.updateInputResultAndselectResult(map);//更新安全问题数量
}
}
@Override
public void freshRiskJudgmentTaskwork(String deptId) {
//循环更新riskJudgmentFillRecordMapper 的 select_result and input_result
Long count = 0L;
String defaultSelectId = null;
Map<String, Object> paramMap = new HashMap<String, Object>();
for (RiskJudgeTaskworkTypeEnum eum : RiskJudgeTaskworkTypeEnum.values()) {
count = getCount(eum.getIntemFlag(), deptId);//查询条件: 部门 + 类型
defaultSelectId = getDefaultSelectId(eum.getIntemFlag(), deptId);//查询条件: 部门 + 类型
paramMap.clear();
paramMap.put("departmentId", deptId);
paramMap.put("inputResult", count);
paramMap.put("selectResult", defaultSelectId);
paramMap.put("taskStatus", RiskJudgmentTaskStatusEnum.进行中.getCode());
paramMap.put("itemFlag", eum.getIntemFlag());
riskJudgmentFillRecordMapper.updateInputResultAndselectResult(paramMap);
}
}
//获取下一节点需要发消息的用户信息
public String getNextExecuteUsers(String instanceId) {
String informerList= "";
JSONObject object = remoteWorkFlowService.getChildNodeDetail(instanceId);
if(object!=null){
JSONArray array = object.getJSONArray("data");
JSONObject workFlowDetail = array.getJSONObject(0);
informerList = workFlowDetail.getString("informerList");
}
return informerList;
}
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/service/intfc/ILatentDangerService.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.service.intfc;
import java.util.List;
import org.springframework.data.domain.Page;
import com.alibaba.fastjson.JSONObject;
import com.yeejoin.amos.boot.biz.common.bo.RoleBo;
import com.yeejoin.amos.feign.privilege.model.AgencyUserModel;
import com.yeejoin.amos.maintenance.business.dto.DangerExecuteSubmitDto;
import com.yeejoin.amos.maintenance.business.param.LatentDangerExcuteParam;
import com.yeejoin.amos.maintenance.business.param.LatentDangerListParam;
import com.yeejoin.amos.maintenance.business.param.LatentDangerNormalParam;
import com.yeejoin.amos.maintenance.business.param.LatentDangerPatrolParam;
import com.yeejoin.amos.maintenance.business.param.PageParam;
import com.yeejoin.amos.maintenance.business.util.CommonResponse;
import com.yeejoin.amos.maintenance.business.vo.DangerTimeAxisVo;
import com.yeejoin.amos.maintenance.core.common.response.DangerListResponse;
/**
* @author keyong
* @title: ILatentDangerService
* <pre>
* @description: TODO
* </pre>
* @date 2021/1/26 14:44
*/
public interface ILatentDangerService {
CommonResponse saveNormal(LatentDangerNormalParam latentDangerParam, String userId, String userRealName,
String departmentId, String departmentName, String companyId, String orgCode, RoleBo role);
CommonResponse savePatrol(LatentDangerPatrolParam latentDangerPatrolParam, String userId, String userRealName,
String departmentId, String departmentName, String companyId, String orgCode, RoleBo role);
CommonResponse list(String toke, String product, String appKey, LatentDangerListParam latentDangerListParam, AgencyUserModel user, String loginOrgCode, String deptId);
DangerExecuteSubmitDto execute(LatentDangerExcuteParam latentDangerExcuteParam, String userId,
String userRealName, String departmentId, String departmentName, RoleBo role);
CommonResponse detail(String id, String userId,boolean isFinish);
CommonResponse getByInstanceId(String instanceId);
DangerExecuteSubmitDto excuteCallBack(String instanceId, Integer actionType, String remark, String token, String userId,
String userRealName, String departmentId, String departmentName);
void updateDangerStateOfOvertime();
CommonResponse listFlowRecord(String token, String product, String appKey, Long id);
void sendLatentDangerExcuteResult(DangerExecuteSubmitDto executeSubmitDto);
void freshRiskJudgmentLangerCount(LatentDangerExcuteParam latentDangerExcuteParam);
/**
* 获取隐患等级字典值
*
* @return
*/
Object getDangerLevel(String token, String product, String appKey, String dictCode);
/**
* 根据等级字符串获取等级字典对象
*
* @param dangerLevelStr 等级（"1","2","0"）
* @return
*/
JSONObject getDangerLevelJsonObject(String dangerLevelStr, String token, String product, String appKey, String dictCode);
/**
* 根据隐患id获取评审信息
*
* @param dangerId
* @return
*/
JSONObject getReviewInfo(Long dangerId);
Page<DangerListResponse> listDanger(PageParam pageParam);
List<DangerListResponse> export(PageParam pageParam);
List<DangerTimeAxisVo> queryExecuteLog(Integer dateTime);
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/vo/LatentDangerDetailRiskVo.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.vo;
import lombok.Data;
import java.util.List;
@Data
public class LatentDangerDetailRiskVo {
private String pointName;
private String pointNo;
private String belongDepartmentName;
private String pointLevel;
private List<String> basis;
/**
* 计划名称
*/
private String planName;
/**
* 检查时间
*/
private String checkTime;
/**
* 检查人
*/
private String checkUser;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/vo/LatentDangerDetailVo.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.vo;
import com.alibaba.fastjson.JSONObject;
import com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerFlowRecordBo;
import lombok.Data;
import java.util.List;
@Data
public class LatentDangerDetailVo {
private Long dangerId;
private String dangerName;
private Integer level;
private String levelDesc;
private String remark;
private String position;
private String reformTypeDesc;
private String reformLimitDate;
private JSONObject reformJson;
private Long currentFlowRecordId;
private Integer dangerState;
private Integer dangerType;
private String dangerStateDesc;
private Boolean currentUserCanExcute;
private List<String> photoUrls;
private LatentDangerDetailRiskVo riskInfo;
private JSONObject reviewInfo;
private JSONObject reformInfo;
private JSONObject recheckInfo;
private List<LatentDangerFlowRecordBo> records;
private String delayLimitDate;
private String problemDescription;
private String reasonAnalysis;
private String inferOtherThings;
private String taskId;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/business/vo/LatentDangerListVo.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.business.vo;
import lombok.Data;
@Data
public class LatentDangerListVo {
private Long dangerId;
private String dangerName;
private String discovererUserName;
private Integer level;
private String levelDesc;
private String limitDesc;
private Integer state;
private String stateDesc;
private Integer overtimeState;
private String taskId;
}
amos-boot-module/amos-boot-module-biz/amos-boot-module-maintenance-biz/src/main/java/com/yeejoin/amos/maintenance/schedule/LatentDanerScheduled.java deleted 100644 → 0
View file @ 6b9dc633
package com.yeejoin.amos.maintenance.schedule;
import com.yeejoin.amos.maintenance.business.service.intfc.ILatentDangerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
/**
* 隐患定时任务
*/
@Configuration("latentDanerScheduled")
@EnableScheduling
public class LatentDanerScheduled {
@Autowired
private ILatentDangerService iLatentDangerService;
/**
* 每1分钟执行一次：查询逾期的隐患，修改状态
*/
// @Scheduled(cron = "0 0/1 * * * ?")
public void updateDangerStateOfOvertime() {
iLatentDangerService.updateDangerStateOfOvertime();
}
}
\ No newline at end of file
amos-boot-system-maintenance/src/main/resources/db/mapper/LatentDangerFlowRecordMapper.xml deleted 100644 → 0
View file @ 6b9dc633
<?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.yeejoin.amos.maintenance.business.dao.mapper.LatentDangerFlowRecordMapper">
<insert id="save" keyColumn="id" keyProperty="id"
parameterType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerFlowRecordBo"
useGeneratedKeys="true">
insert into p_latent_danger_flow_record
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="dangerId != null">
danger_id,
</if>
<if test="actionFlag != null">
action_flag,
</if>
<if test="flowTaskName != null">
flow_task_name,
</if>
<if test="flowTaskUserIds != null">
flow_task_user_ids,
</if>
<if test="flowTaskId != null">
flow_task_id,
</if>
<if test="excuteState != null">
excute_state,
</if>
<if test="excuteUserId != null">
excute_user_id,
</if>
<if test="excuteDepartmentId != null">
excute_department_id,
</if>
<if test="excuteResult != null">
excute_result,
</if>
<if test="remark != null">
remark,
</if>
<if test="flowJson != null">
flow_json,
</if>
<if test="deleted != null">
deleted,
</if>
<if test="createDate != null">
create_date,
</if>
<if test="updateDate != null">
update_date,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="dangerId != null">
#{dangerId},
</if>
<if test="actionFlag != null">
#{actionFlag},
</if>
<if test="flowTaskName != null">
#{flowTaskName},
</if>
<if test="flowTaskUserIds != null">
#{flowTaskUserIds},
</if>
<if test="flowTaskId != null">
#{flowTaskId},
</if>
<if test="excuteState != null">
#{excuteState},
</if>
<if test="excuteUserId != null">
#{excuteUserId},
</if>
<if test="excuteDepartmentId != null">
#{excuteDepartmentId},
</if>
<if test="excuteResult != null">
#{excuteResult},
</if>
<if test="remark != null">
#{remark},
</if>
<if test="flowJson != null">
#{flowJson},
</if>
<if test="deleted != null">
#{deleted},
</if>
<if test="createDate != null">
#{createDate},
</if>
<if test="updateDate != null">
#{updateDate},
</if>
</trim>
</insert>
<update id="update" parameterType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerFlowRecordBo">
update p_latent_danger_flow_record
<set>
<if test="dangerId != null">
danger_id = #{dangerId},
</if>
<if test="actionFlag != null">
action_flag = #{actionFlag},
</if>
<if test="flowTaskName != null">
flow_task_name = #{flowTaskName},
</if>
<if test="flowTaskUserIds != null">
flow_task_user_ids = #{flowTaskUserIds},
</if>
<if test="flowTaskId != null">
flow_task_id = #{flowTaskId},
</if>
<if test="excuteState != null">
excute_state = #{excuteState},
</if>
<if test="excuteUserId != null">
excute_user_id = #{excuteUserId},
</if>
<if test="excuteDepartmentId != null">
excute_department_id = #{excuteDepartmentId},
</if>
<if test="excuteResult != null">
excute_result = #{excuteResult},
</if>
<if test="remark != null">
remark = #{remark},
</if>
<if test="flowJson != null">
flow_json = #{flowJson},
</if>
<if test="deleted != null">
deleted = #{deleted},
</if>
<if test="createDate != null">
create_date = #{createDate},
</if>
<if test="updateDate != null">
update_date = #{updateDate},
</if>
</set>
where id = #{id}
</update>
<select id="getById" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerFlowRecordBo">
select * from p_latent_danger_flow_record where deleted = 0 and id = #{id} limit 1
</select>
<select id="getNewestRecordByDangerId" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerFlowRecordBo">
select * from p_latent_danger_flow_record where deleted = 0 and danger_id = #{dangerId} order by create_date desc limit 1
</select>
<select id="listPassByDangerId" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerFlowRecordBo">
select
*
from
p_latent_danger_flow_record
where
id in
(
select
max(id)
from
p_latent_danger_flow_record
where
deleted = 0
and
danger_id = #{dangerId}
and
excute_state = 2
group by action_flag
)
</select>
<select id="listByDangerId" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerFlowRecordBo">
select
*
from
p_latent_danger_flow_record
where
deleted = 0
and
danger_id = #{dangerId}
</select>
<select id="getByDangerIdAndActionFlag" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerFlowRecordBo">
select
*
from
p_latent_danger_flow_record
where
danger_id = #{dangerId}
and
action_flag = #{actionFlag}
order by create_date desc
limit 1
</select>
<select id="getByDangerIdAndCreate" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerFlowRecordBo">
select
*
from
p_latent_danger_flow_record
where
danger_id = #{dangerId}
order by create_date desc
limit 1
</select>
<select id="listNewestRecordByDangerIds" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerFlowRecordBo">
select
a.*,b.overtime_state as dangerOvertimeState,b.danger_state as dangerState
from
p_latent_danger_flow_record as a
left join
p_latent_danger as b on a.danger_id = b.id
where
a.id in
(
select
max(id)
from
p_latent_danger_flow_record
where
deleted = 0
and
danger_id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
and
excute_state in (2,3)
group by danger_id
)
</select>
<delete id="deleteByLatentDangerIds">
update p_latent_danger_flow_record set deleted = 1 where danger_id in
<foreach collection="list" index="index" item="dangerId" open="(" separator="," close=")">
#{dangerId}
</foreach>
</delete>
<select id="listExecuteLog" resultType="com.yeejoin.amos.maintenance.business.vo.DangerTimeAxisVo">
SELECT
pld.id AS dangerId,
pldfr.excute_user_id AS executeUserId,
pldfr.excute_result AS executeResult,
pld.create_date AS createDate,
pld.update_date AS updateDate,
pld.danger_name AS dangerName,
pld.danger_state AS dangerState,
pld.structure_id AS structureId,
pld.reform_limit_date AS reformLimitDate,
pld.reform_type AS reformType,
pld.delay_limit_date AS delayLimitDate,
wws.full_name AS structureName
FROM
p_latent_danger pld
LEFT JOIN p_latent_danger_flow_record pldfr ON pldfr.id = pld.current_flow_record_id
LEFT JOIN wl_warehouse_structure wws ON wws.id = pld.structure_id
<!-- WHERE-->
<!-- <if test="beginTime != null and beginTime != ''">-->
<!-- pld.reform_limit_date <![CDATA[>=]]> #{beginTime}-->
<!-- </if>-->
ORDER BY
pld.update_date DESC
</select>
<select id="getByIdOderByDate"
resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerFlowRecordBo">
select * from p_latent_danger_flow_record where deleted = 0 and danger_id = #{dangerId} ORDER BY create_date DESC LIMIT 1
</select>
</mapper>
\ No newline at end of file
amos-boot-system-maintenance/src/main/resources/db/mapper/LatentDangerMapper.xml deleted 100644 → 0
View file @ 6b9dc633
<?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.yeejoin.amos.maintenance.business.dao.mapper.LatentDangerMapper">
<insert id="save" keyColumn="id" keyProperty="id"
parameterType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerBo"
useGeneratedKeys="true">
insert into p_latent_danger
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="businessKey != null">
business_key,
</if>
<if test="orgCode != null">
org_code,
</if>
<if test="dangerName != null">
danger_name,
</if>
<if test="currentFlowRecordId != null">
current_flow_record_id,
</if>
<if test="instanceId != null">
instance_id,
</if>
<if test="dangerLevel != null">
danger_level,
</if>
<if test="dangerPosition != null">
danger_position,
</if>
<if test="dangerType != null">
danger_type,
</if>
<if test="remark != null">
remark,
</if>
<if test="overtimeState != null">
overtime_state,
</if>
<if test="reformType != null">
reform_type,
</if>
<if test="reformLimitDate != null">
reform_limit_date,
</if>
<if test="reformJson != null">
reform_json,
</if>
<if test="dangerState != null">
danger_state,
</if>
<if test="discovererUserId != null">
discoverer_user_id,
</if>
<if test="discovererDepartmentId != null">
discoverer_department_id,
</if>
<if test="photoUrls != null">
photo_urls,
</if>
<if test="deleted != null">
deleted,
</if>
<if test="createDate != null">
create_date,
</if>
<if test="updateDate != null">
update_date,
</if>
<if test="problemDescription != null">
problem_description,
</if>
<if test="checkInputId != null">
check_input_id,
</if>
<if test="structureId != null">
structure_id,
</if>
<if test="structureName != null">
structure_name,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="businessKey != null">
#{businessKey},
</if>
<if test="orgCode != null">
#{orgCode},
</if>
<if test="dangerName != null">
#{dangerName},
</if>
<if test="currentFlowRecordId != null">
#{currentFlowRecordId},
</if>
<if test="instanceId != null">
#{instanceId},
</if>
<if test="dangerLevel != null">
#{dangerLevel},
</if>
<if test="dangerPosition != null">
#{dangerPosition},
</if>
<if test="dangerType != null">
#{dangerType},
</if>
<if test="remark != null">
#{remark},
</if>
<if test="overtimeState != null">
#{overtimeState},
</if>
<if test="reformType != null">
#{reformType},
</if>
<if test="reformLimitDate != null">
#{reformLimitDate},
</if>
<if test="reformJson != null">
#{reformJson},
</if>
<if test="dangerState != null">
#{dangerState},
</if>
<if test="discovererUserId != null">
#{discovererUserId},
</if>
<if test="discovererDepartmentId != null">
#{discovererDepartmentId},
</if>
<if test="photoUrls != null">
#{photoUrls},
</if>
<if test="deleted != null">
#{deleted},
</if>
<if test="createDate != null">
#{createDate},
</if>
<if test="updateDate != null">
#{updateDate},
</if>
<if test="problemDescription != null">
#{problemDescription},
</if>
<if test="checkInputId != null">
#{checkInputId},
</if>
<if test="structureId != null">
#{structureId},
</if>
<if test="structureName != null">
#{structureName},
</if>
</trim>
</insert>
<update id="update" parameterType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerBo">
update p_latent_danger
<set>
<if test="businessKey != null">
business_key = #{businessKey},
</if>
<if test="orgCode != null">
org_code = #{orgCode},
</if>
<if test="dangerName != null">
danger_name = #{dangerName},
</if>
<if test="currentFlowRecordId != null">
current_flow_record_id = #{currentFlowRecordId},
</if>
<if test="instanceId != null">
instance_id = #{instanceId},
</if>
<if test="dangerLevel != null">
danger_level = #{dangerLevel},
</if>
<if test="dangerPosition != null">
danger_position = #{dangerPosition},
</if>
<if test="dangerType != null">
danger_type = #{dangerType},
</if>
<if test="remark != null">
remark = #{remark},
</if>
<if test="overtimeState != null">
overtime_state = #{overtimeState},
</if>
<if test="currentFlowRecordId != null">
current_flow_record_id = #{currentFlowRecordId},
</if>
<if test="reformType != null">
reform_type = #{reformType},
</if>
<if test="reformLimitDate != null">
reform_limit_date = #{reformLimitDate},
</if>
<if test="reformJson != null">
reform_json = #{reformJson},
</if>
<if test="dangerState != null">
danger_state = #{dangerState},
</if>
<if test="discovererUserId != null">
discoverer_user_id = #{discovererUserId},
</if>
<if test="discovererDepartmentId != null">
discoverer_department_id = #{discovererDepartmentId},
</if>
<if test="photoUrls != null">
photo_urls = #{photoUrls},
</if>
<if test="deleted != null">
deleted = #{deleted},
</if>
<if test="createDate != null">
create_date = #{createDate},
</if>
<if test="updateDate != null">
update_date = #{updateDate},
</if>
<if test="delayLimitDate != null">
delay_limit_date = #{delayLimitDate},
</if>
<if test="reasonAnalysis != null">
reason_analysis = #{reasonAnalysis},
</if>
<if test="inferOtherThings != null">
infer_other_things = #{inferOtherThings},
</if>
<if test="problemDescription != null">
problem_description = #{problemDescription},
</if>
</set>
where id = #{id}
</update>
<update id="deleteByIds">
update p_latent_danger set deleted = 1 where id in
<foreach collection="list" index="index" item="id" open="(" separator="," close=")">
#{id}
</foreach>
</update>
<select id="getById" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerBo">
select * from p_latent_danger where deleted = 0 and id = #{id}
</select>
<select id="getByInstanceId" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerBo">
select * from p_latent_danger where deleted = 0 and instance_id = #{instanceId} and danger_state = 3 limit 1
</select>
<select id="listByMap" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerBo">
select
a.*
from
p_latent_danger as a
left join
p_latent_danger_flow_record as b on a.current_flow_record_id = b.id
<where>
<!-- case-->
<!-- when a.danger_type = 1 and find_in_set(b.action_flag, 'B_3,B_4') then-->
<!-- 1=1-->
<!-- <if test="userId != null and userId != ''">-->
<!-- and find_in_set( #{userId}, b.flow_task_user_ids )-->
<!-- </if>-->
<!-- else-->
<!-- 1=1-->
<!-- <if test="userId != null and userId != ''">-->
<!-- and (find_in_set(#{userId}, b.flow_task_user_ids) or find_in_set(b.action_flag, #{permissions}))-->
<!-- </if>-->
<!-- end-->
<!-- and a.deleted = 0-->
<!-- and b.deleted = 0-->
<if test="dangerLevel != null and dangerLevel != -1">
and a.danger_level=#{dangerLevel}
</if>
<if test="dangerState != null and dangerState != ''">
and a.danger_state=#{dangerState}
</if>
<if test="states != null">
and a.danger_state in
<foreach collection="states" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</if>
<if test="dangerName != null and dangerName != ''">
and a.danger_name like concat('%',#{dangerName},'%')
</if>
<if test="org_code != null and org_code != ''">
and a.org_code = #{org_code}
</if>
<!-- <if test="discoverer_department_id != null and discoverer_department_id != ''">-->
<!-- and (a.discoverer_department_id = #{discoverer_department_id} or ISNULL(a.discoverer_department_id))-->
<!-- </if>-->
</where>
order by a.create_date desc
<if test="limit != null and offset != null">
limit #{offset},#{limit}
</if>
</select>
<select id="countByMap" resultType="java.lang.Long">
select
count(1)
from
p_latent_danger as a
left join
p_latent_danger_flow_record as b on a.current_flow_record_id = b.id
<where>
case
when a.danger_type = 1 and find_in_set(b.action_flag, 'B_3,B_4') then
1=1
<if test="userId != null and userId != ''">
and find_in_set( #{userId}, b.flow_task_user_ids )
</if>
else
1=1
<if test="userId != null and userId != ''">
and (find_in_set(#{userId}, b.flow_task_user_ids) or find_in_set(b.action_flag, #{permissions}))
</if>
end
and a.deleted = 0
and b.deleted = 0
<if test="dangerLevel != null and dangerLevel != -1">
and a.danger_level=#{dangerLevel}
</if>
<if test="dangerState != null and dangerState != ''">
and a.danger_state=#{dangerState}
</if>
<if test="states != null">
and a.danger_state in
<foreach collection="states" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</if>
<if test="dangerName != null and dangerName != ''">
and a.danger_name like concat('%',#{dangerName},'%')
</if>
<if test="org_code != null and org_code != ''">
and a.org_code = #{org_code}
</if>
<if test="discoverer_department_id != null and discoverer_department_id != ''">
and (a.discoverer_department_id = #{discoverer_department_id} or ISNULL(a.discoverer_department_id))
</if>
</where>
</select>
<select id="listOfOvertime" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerBo">
select * from p_latent_danger where now()>reform_limit_date and overtime_state = 0 and deleted = 0 and danger_state in (2,3,4)
</select>
<select id="countNotFinishByFlowId" resultType="java.lang.Integer">
select
count(1)
from
p_latent_danger
where
deleted = 0
and
danger_state in (1,2,3,4)
and
id in
(
select
latent_danger_id
from
p_latent_danger_patrol
where
risk_factor_flow_id = #{value}
and
deleted = 0
)
</select>
<select id="listNotFinishByPointId" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerBo">
select
*
from
p_latent_danger
where
deleted = 0
and
danger_state in (1,2,3,4)
and
id in
(
select
latent_danger_id
from
p_latent_danger_patrol
where
point_id = #{pointId}
and
deleted = 0
)
and id !=#{dangerId}
</select>
<select id="countByFlowUserIds" resultType="java.lang.Long">
select
count(1)
from
p_latent_danger as a
left join
p_latent_danger_flow_record as b on a.current_flow_record_id = b.id
where
find_in_set(#{userId},b.flow_task_user_ids)
and
a.deleted = 0
and
a.danger_state in (1,2,4)
</select>
<select id="countNotFinishByTypeAndDeptId" resultType="java.lang.Long">
SELECT
count(1)
FROM
p_latent_danger a,
p_latent_danger_patrol b,
p_point c,
spc_risk_source d
WHERE
a.danger_level = #{type}
<if test="departmentId != null and departmentId != -1">
and d.belong_department_id = #{departmentId}
</if>
and a.danger_type IN (2, 3)
AND (
a.danger_state IN (2, 3, 4)
OR a.danger_state = 5
AND DATEDIFF(a.update_date, CURDATE()) = 0
)
and b.latent_danger_id = a.id
and b.point_id = c.id
and c.original_id = d.id
</select>
<select id="getNotFinishIdsByTypeAndDeptId" resultType="java.lang.String">
SELECT
GROUP_CONCAT(DISTINCT a.id ) extraIds
FROM
p_latent_danger a,
p_latent_danger_patrol b,
p_point c,
spc_risk_source d
WHERE
a.danger_level = #{type} -- (1,2)
<if test="departmentId != null and departmentId != -1">
and d.belong_department_id = #{departmentId}
</if>
AND a.danger_type IN ( 2, 3 ) -- 2：巡检隐患；3：有码无计划隐患
AND (
a.danger_state IN ( 2, 3, 4 ) -- 2：待治理；3：安措计划中；4：待验证；5：治理完毕
OR a.danger_state = 5
AND DATEDIFF( a.update_date, CURDATE( ) ) = 0
)
AND b.latent_danger_id = a.id
AND b.point_id = c.id
AND c.original_id = d.id;
</select>
<select id="listNeedNoticeDanger"
resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerNoticeBo">
SELECT
ld.id dangerId,
ld.org_code orgCode,
ld.danger_state dangerState,
ld.danger_name dangerName,
ld.instance_id instanceId,
ld.reform_limit_date reformLimitDate
FROM
p_latent_danger ld
WHERE
TIMESTAMPDIFF( MINUTE, now(), ld.reform_limit_date ) = TIMESTAMPDIFF( MINUTE, (SELECT DATE_ADD(CURDATE(),
INTERVAL 8 HOUR)), ld.reform_limit_date ) -- 截止日期到当天早上8:00:00分钟数
AND ld.overtime_state = 0
AND ld.deleted = 0
AND ld.danger_state = 2;
</select>
<select id="getReViewInfo" resultType="java.util.HashMap">
SELECT
f.id,
f.danger_id dangerId,
f.action_flag actionFlag,
f.flow_task_name flowTaskName,
CASE
WHEN f.excute_state = 2 THEN
'通过'
WHEN f.excute_state = 3 THEN
'驳回'
END executeState,
f.excute_user_id executeUserId,
f.update_date reViewDate,
ld.reform_limit_date reformLimitDate,
f.flow_json flowJson,
f.remark,
ld.infer_other_things inferOtherThings,
(select ff.flow_task_user_ids from p_latent_danger_flow_record ff where ff.danger_id = f.danger_id and
ff.action_flag = 'B_3' limit 1 ) handleUserIds,
CASE
WHEN ld.reform_type = 1 THEN
'常规整改'
WHEN ld.reform_type = 2 THEN
'安措计划'
WHEN ld.reform_type = 3 THEN
'延期治理'
END reformTypeName,
ld.reform_type reformType,
ld.delay_limit_date delayLimitDate
FROM
p_latent_danger_flow_record f
LEFT JOIN p_latent_danger ld ON ld.id = f.danger_id
WHERE
f.action_flag != 'B_1'
AND NOT ISNULL( f.update_date )
AND f.excute_state != 1
AND f.danger_id = #{dangerId}
</select>
<select id="dangerListByMap" resultType="com.yeejoin.amos.maintenance.core.common.response.DangerListResponse">
SELECT
*
FROM
(
SELECT
pld.id,
pld.danger_name dangerName,
pld.danger_position dangerPosition,
pld.danger_level dangerLevel,
pld.reform_type reformType,
pld.reform_limit_date deadlineDate,
pld.danger_state dangerState,
pld.overtime_state overtimeState,
pld.problem_description problemDescription,
pld.reason_analysis reasonAnalysis,
pld.infer_other_things inferOtherThings,
pld.remark,
pp.plan_type planType,
pp.`name` planName,
pr.`name` routeName,
pld.danger_type dangerType,
pc.check_time checkTimeDate,
pii.`name` checkContent,
pc.user_id checkUser,
pc.error checkResult,
pc.is_ok checkStatus,
pld.id dangerId,
pld.reform_json measures,
pld.instance_id processInstanceId,
pld.discoverer_user_id discoverUser,
p.original_id riskSourceId,
pld.structure_id structureId,
pld.structure_name structureName
FROM
p_latent_danger pld
LEFT JOIN p_latent_danger_patrol ldp ON pld.id = ldp.latent_danger_id
LEFT JOIN p_point p ON p.id = ldp.point_id
LEFT JOIN p_point_classify ppc ON ppc.id = ldp.point_classify_id
LEFT JOIN p_input_item pii ON pii.id = ldp.item_id
LEFT JOIN p_check pc ON pc.id = ldp.check_id
LEFT JOIN p_plan pp ON pp.id = pc.plan_id
LEFT JOIN p_route pr ON pr.id = pc.route_id
<where>
<if test="dangerIds != null">
pld.id IN
<foreach collection="dangerIds" item="id" index="index" open="(" separator="," close=")" >
#{id}
</foreach>
</if>
</where>
) temp
WHERE
1 = 1
<if test="type != null and type !=''">
AND type = #{type}
</if>
<if test="eqCode != null and eqCode !=''">
AND eqCode LIKE concat('%',#{eqCode},'%')
</if>
<if test="dangerName != null and dangerName !=''">
AND dangerName LIKE concat('%',#{dangerName},'%')
</if>
<if test="planType != null and planType !=''">
AND planType = #{planType}
</if>
<if test="structureId != null and structureId.size > 0">
AND structureId in
<foreach collection="structureId" open="(" close=")" separator="," item="sid">
#{sid}
</foreach>
</if>
<if test="routeName != null and routeName !=''">
AND routeName LIKE concat('%',#{routeName},'%')
</if>
<if test="planName != null and planName !=''">
AND planName LIKE concat('%',#{planName},'%')
</if>
<if test="beginCheckTime != null and beginCheckTime !=''">
AND checkTimeDate <![CDATA[>=]]> #{beginCheckTime}
</if>
<if test="endCheckTime != null and endCheckTime !=''">
AND checkTimeDate <![CDATA[<=]]> #{endCheckTime}
</if>
<if test="checkDep != null and checkDep !=''">
AND checkDep = #{checkDep}
</if>
<if test="checkUser != null and checkUser !=''">
AND checkUser = #{checkUser}
</if>
<if test="checkResult != null and checkResult !=''">
AND checkResult LIKE concat('%',#{checkResult},'%')
</if>
<if test="beginDeadline != null and beginDeadline !=''">
AND deadlineDate <![CDATA[>=]]> #{beginDeadline}
</if>
<if test="endDeadline != null and endDeadline !=''">
AND deadlineDate <![CDATA[<=]]> #{endDeadline}
</if>
<if test="governDep != null and governDep !=''">
AND governDep = #{governDep}
</if>
<if test="governUser != null and governUser !=''">
AND governUser = #{governUser}
</if>
<if test="dangerLevel != null and dangerLevel !=''">
AND dangerLevel = #{dangerLevel}
</if>
<if test="dangerType != null and dangerType !=''">
AND dangerType = #{dangerType}
</if>
<if test="reformType != null and reformType !=''">
AND reformType = #{reformType}
</if>
<if test="overtimeState != null and overtimeState !=''">
AND overtimeState = #{overtimeState}
</if>
<if test="dangerState != null and dangerState !=''">
AND dangerState = #{dangerState}
</if>
<if test="verifyDep != null and verifyDep !=''">
AND verifyDep = #{verifyDep}
</if>
<if test="verifyUser != null and verifyUser !=''">
AND verifyUser = #{verifyUser}
</if>
<if test="riskSourceId != null and riskSourceId !=''">
AND riskSourceId = #{riskSourceId}
</if>
ORDER BY temp.id desc
<if test="offset != null and pageSize != null">
limit #{offset},#{pageSize}
</if>
</select>
<select id="countDangerListByMap" resultType="java.lang.Long">
SELECT
COUNT(1)
FROM
(
SELECT
pld.danger_name dangerName,
pld.danger_position dangerPosition,
pld.structure_name structureName,
pld.structure_id structureId,
pld.danger_level dangerLevel,
pld.reform_type reformType,
pld.reform_limit_date deadlineDate,
pld.danger_state dangerState,
pld.overtime_state overtimeState,
pp.plan_type planType,
pp.`name` planName,
pr.`name` routeName,
pld.danger_type dangerType,
pc.check_time checkTimeDate,
pii.`name` checkContent,
pc.user_id checkUser,
pc.error checkResult,
pc.is_ok checkStatus,
pld.id dangerId,
dangerFlow.governDep,
dangerFlow.governUser,
dangerFlow.governDate,
dangerFlow.verifyDep,
dangerFlow.verifyUser,
dangerFlow.verifyResult,
pld.reform_json measures
FROM
p_latent_danger pld
LEFT JOIN p_latent_danger_patrol ldp ON pld.id = ldp.latent_danger_id
LEFT JOIN p_point_classify ppc ON ppc.id = ldp.point_classify_id
LEFT JOIN p_input_item pii ON pii.id = ldp.item_id
LEFT JOIN p_check pc ON pc.id = ldp.check_id
LEFT JOIN p_plan pp ON pp.id = pc.plan_id
LEFT JOIN p_route pr ON pr.id = pc.route_id
LEFT JOIN (
SELECT
GROUP_CONCAT(
CASE
WHEN action_flag = 'B_3' THEN
excute_department_id
ELSE
NULL
END
) governDep,
GROUP_CONCAT(
CASE
WHEN action_flag = 'B_3' THEN
excute_user_id
ELSE
NULL
END
) governUser,
GROUP_CONCAT(
CASE
WHEN action_flag = 'B_3' THEN
update_date
ELSE
NULL
END
) governDate,
GROUP_CONCAT(
CASE
WHEN action_flag = 'B_4' THEN
excute_department_id
ELSE
NULL
END
) verifyDep,
GROUP_CONCAT(
CASE
WHEN action_flag = 'B_4' THEN
excute_user_id
ELSE
NULL
END
) verifyUser,
GROUP_CONCAT(
CASE
WHEN action_flag = 'B_4' THEN
pldfr.excute_result
ELSE
NULL
END
) verifyResult,
pldfr.danger_id dangerId
FROM
(
SELECT
*
FROM
p_latent_danger_flow_record
WHERE
id IN (
SELECT
max(id)
FROM
p_latent_danger_flow_record
WHERE
deleted = 0
AND action_flag IN ('B_3', 'B_4')
GROUP BY
action_flag,
danger_id
)
) pldfr
GROUP BY
pldfr.danger_id
) dangerFlow ON dangerFlow.dangerId = pld.id
<where>
<if test="dangerIds != null">
pld.id IN
<foreach collection="dangerIds" item="id" index="index" open="(" separator="," close=")" >
#{id}
</foreach>
</if>
</where>
) temp
WHERE
1 = 1
<if test="type != null and type !=''">
AND type = #{type}
</if>
<if test="eqCode != null and eqCode !=''">
AND eqCode LIKE concat('%',#{eqCode},'%')
</if>
<if test="dangerName != null and dangerName !=''">
AND dangerName LIKE concat('%',#{dangerName},'%')
</if>
<if test="planType != null and planType !=''">
AND planType = #{planType}
</if>
<if test="structureId != null and structureId.size > 0">
AND structureId in
<foreach collection="structureId" open="(" close=")" separator="," item="sid">
#{sid}
</foreach>
</if>
<if test="routeName != null and routeName !=''">
AND routeName LIKE concat('%',#{routeName},'%')
</if>
<if test="planName != null and planName !=''">
AND planName LIKE concat('%',#{planName},'%')
</if>
<if test="beginCheckTime != null and beginCheckTime !=''">
AND checkTimeDate <![CDATA[>=]]> #{beginCheckTime}
</if>
<if test="endCheckTime != null and endCheckTime !=''">
AND checkTimeDate <![CDATA[<=]]> #{endCheckTime}
</if>
<if test="checkDep != null and checkDep !=''">
AND checkDep = #{checkDep}
</if>
<if test="checkUser != null and checkUser !=''">
AND checkUser = #{checkUser}
</if>
<if test="checkResult != null and checkResult !=''">
AND checkResult LIKE concat('%',#{checkResult},'%')
</if>
<if test="beginDeadline != null and beginDeadline !=''">
AND deadlineDate <![CDATA[>=]]> #{beginDeadline}
</if>
<if test="endDeadline != null and endDeadline !=''">
AND deadlineDate <![CDATA[<=]]> #{endDeadline}
</if>
<if test="governDep != null and governDep !=''">
AND governDep = #{governDep}
</if>
<if test="governUser != null and governUser !=''">
AND governUser = #{governUser}
</if>
<if test="dangerLevel != null and dangerLevel !=''">
AND dangerLevel = #{dangerLevel}
</if>
<if test="dangerType != null and dangerType !=''">
AND dangerType = #{dangerType}
</if>
<if test="reformType != null and reformType !=''">
AND reformType = #{reformType}
</if>
<if test="overtimeState != null and overtimeState !=''">
AND overtimeState = #{overtimeState}
</if>
<if test="dangerState != null and dangerState !=''">
AND dangerState = #{dangerState}
</if>
<if test="verifyDep != null and verifyDep !=''">
AND verifyDep = #{verifyDep}
</if>
<if test="verifyUser != null and verifyUser !=''">
AND verifyUser = #{verifyUser}
</if>
<if test="riskSourceId != null and riskSourceId !=''">
AND riskSourceId = #{riskSourceId}
</if>
</select>
<select id="getByBathBusinessKeys" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerBo">
SELECT
*
FROM
p_latent_danger pld
WHERE
pld.business_key IN
<foreach collection = "businessKeys" item = "businessKey" index="index" open = "(" close = ")" separator = "," >
#{businessKey}
</foreach>
<if test="latentDangerListParam.dangerLevel != null and latentDangerListParam.dangerLevel != -1">
and pld.danger_level=#{latentDangerListParam.dangerLevel}
</if>
<if test="latentDangerListParam.dangerState != null and latentDangerListParam.dangerState != ''">
and pld.danger_state=#{latentDangerListParam.dangerState}
</if>
<if test="latentDangerListParam.userId != null and latentDangerListParam.userId != ''">
and pld.discoverer_user_id=#{latentDangerListParam.userId}
</if>
<if test="latentDangerListParam.dangerName != null and latentDangerListParam.dangerName !=''">
AND pld.danger_name LIKE concat('%',#{latentDangerListParam.dangerName},'%')
</if>
ORDER BY create_date DESC
<if test="latentDangerListParam.pageSize != null and latentDangerListParam.offset != null">
limit #{latentDangerListParam.offset}, #{latentDangerListParam.pageSize}
</if>
</select>
<select id="countByBathBusinessKeys" resultType="java.lang.Integer">
SELECT
count(*)
FROM
p_latent_danger pld
WHERE
pld.business_key IN
<foreach collection = "businessKeys" item = "businessKey" index="index" open = "(" close = ")" separator = "," >
#{businessKey}
</foreach>
<if test="latentDangerListParam.dangerLevel != null and latentDangerListParam.dangerLevel != -1">
and pld.danger_level=#{latentDangerListParam.dangerLevel}
</if>
<if test="latentDangerListParam.dangerState != null and latentDangerListParam.dangerState != ''">
and pld.danger_state=#{latentDangerListParam.dangerState}
</if>
<if test="latentDangerListParam.userId != null and latentDangerListParam.userId != ''">
and pld.discoverer_user_id=#{latentDangerListParam.userId}
</if>
<if test="latentDangerListParam.dangerName != null and latentDangerListParam.dangerName !=''">
AND pld.danger_name LIKE concat('%',#{latentDangerListParam.dangerName},'%')
</if>
</select>
<select id="countByStatus" resultType="java.lang.Integer">
SELECT
count(*)
FROM
p_latent_danger pld
WHERE
pld.deleted = 0
AND
pld.danger_state in (1,2,4,7,8,9)
AND
pld.business_key IN
<foreach collection = "businessKeys" item = "businessKey" index="index" open = "(" close = ")" separator = "," >
#{businessKey}
</foreach>
</select>
<update id="updateCheckInputDangerState">
update
p_check_input
set danger_handle_state = #{code}
where id = #{id};
</update>
<select id="getbyBusinessKey" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerBo">
SELECT
*
FROM
p_latent_danger pld
WHERE
pld.business_key = #{businessKey}
</select>
</mapper>
\ No newline at end of file
amos-boot-system-maintenance/src/main/resources/db/mapper/LatentDangerPatrolMapper.xml deleted 100644 → 0
View file @ 6b9dc633
<?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.yeejoin.amos.maintenance.business.dao.mapper.LatentDangerPatrolMapper">
<insert id="save" keyColumn="id" keyProperty="id"
parameterType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerPatrolBo"
useGeneratedKeys="true">
insert into p_latent_danger_patrol
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="latentDangerId != null">
latent_danger_id,
</if>
<if test="pointClassifyId != null">
point_classify_id,
</if>
<!-- <if test="riskFactorFlowId != null">-->
<!-- risk_factor_flow_id,-->
<!-- </if>-->
<if test="checkId != null">
check_id,
</if>
<if test="itemId != null">
item_id,
</if>
<if test="pointId != null">
point_id,
</if>
<if test="routeId != null">
route_id,
</if>
<if test="routePointItemId != null">
route_point_item_id,
</if>
<if test="deleted != null">
deleted,
</if>
<if test="createDate != null">
create_date,
</if>
<if test="updateDate != null">
update_date,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="latentDangerId != null">
#{latentDangerId},
</if>
<if test="pointClassifyId != null">
#{pointClassifyId},
</if>
<!-- <if test="riskFactorFlowId != null">-->
<!-- #{riskFactorFlowId},-->
<!-- </if>-->
<if test="checkId != null">
#{checkId},
</if>
<if test="itemId != null">
#{itemId},
</if>
<if test="pointId != null">
#{pointId},
</if>
<if test="routeId != null">
#{routeId},
</if>
<if test="routePointItemId != null">
#{routePointItemId},
</if>
<if test="deleted != null">
#{deleted},
</if>
<if test="createDate != null">
#{createDate},
</if>
<if test="updateDate != null">
#{updateDate},
</if>
</trim>
</insert>
<update id="update" parameterType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerPatrolBo">
update p_latent_danger_patrol
<set>
<if test="latentDangerId != null">
latent_danger_id = #{latentDangerId},
</if>
<if test="pointClassifyId != null">
point_classify_id = #{pointClassifyId},
</if>
<if test="checkId != null">
check_id = #{checkId},
</if>
<if test="riskFactorFlowId != null">
risk_factor_flow_id = #{riskFactorFlowId},
</if>
<if test="itemId != null">
item_id = #{itemId},
</if>
<if test="pointId != null">
point_id = #{pointId},
</if>
<if test="routeId != null">
route_id = #{routeId},
</if>
<if test="routePointItemId != null">
route_point_item_id = #{routePointItemId},
</if>
<if test="deleted != null">
deleted = #{deleted},
</if>
<if test="createDate != null">
create_date = #{createDate},
</if>
<if test="updateDate != null">
update_date = #{updateDate},
</if>
</set>
where id = #{id}
</update>
<delete id="deleteByLatentDangerIds">
update p_latent_danger_patrol set deleted = 1 where latent_danger_id in
<foreach collection="list" index="index" item="latentDangerId" open="(" separator="," close=")">
#{latentDangerId}
</foreach>
</delete>
<select id="getByDangerId" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerPatrolBo">
select
a.*,
b.name as itemName,
b.original_id as itemOriginalId,
b.basis_json as itemBasis,
b.remark as itemRemark,
c.name as pointName,
c.point_no as pointNo,
c.level as pointLevel,
c.charge_dept_id as pointDepartMentId,
c.original_id as pointOriginalId,
d.name as routeName,
e.check_time as checkTime,
e.user_id as checkUserId,
e.dep_id as checkDepartmentId,
f.name as planName,
f.plan_type as planType,
f.execute_rate as executeRate,
g.original_id as classifyOriginalId,
g.name as classifyName
from
p_latent_danger_patrol as a
left join
p_input_item as b on a.item_id = b.id
left join
p_point as c on a.point_id = c.id
left join
p_route as d on a.route_id = d.id
left join
p_check as e on a.check_id = e.id
left join
p_plan as f on e.plan_id = f.id
left join
p_point_classify as g on a.point_classify_id = g.id
where
a.deleted = 0
and
a.latent_danger_id = #{dangerId}
</select>
<select id="listByMap" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerPatrolBo">
select
a.*
from
p_latent_danger_patrol as a
left join
p_latent_danger as b
<where>
<if test="pointId != null">
and a.point_id = #{pointId}
</if>
<if test="itemId != null">
and a.item_id = #{itemId}
</if>
<if test="pointClassifyId != null">
and a.point_classify_id = #{pointClassifyId}
</if>
<if test="dangerType != null">
and b.danger_type = #{dangerType}
</if>
</where>
</select>
<select id="listByPointId" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerPatrolBo">
select
*
from
p_latent_danger_patrol
where
point_id = #{pointId}
</select>
<select id="queryByPointClassifyIds"
resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.extend.LatentDangerPatrolBo">
select * from p_latent_danger_patrol where point_classify_id in
<foreach collection="list" index="index" item="pointClassifyId" open="(" separator="," close=")">
#{pointClassifyId}
</foreach>
</select>
</mapper>
\ No newline at end of file
amos-boot-system-maintenance/src/main/resources/db/mapper/SpcRiskJudgmentFillRecordMapper.xml deleted 100644 → 0
View file @ 6b9dc633
<?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.yeejoin.amos.maintenance.business.dao.mapper.RiskJudgmentFillRecordMapper">
<insert id="save" keyColumn="id" keyProperty="id"
parameterType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentFillRecordBo"
useGeneratedKeys="true">
insert into spc_risk_judgment_fill_record
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="taskId != null">
task_id,
</if>
<if test="itemId != null">
item_id,
</if>
<if test="selectResult != null">
select_result,
</if>
<if test="inputResult != null">
input_result,
</if>
<if test="remarkResult != null">
remark_result,
</if>
<if test="photoResult != null">
photo_result,
</if>
<if test="itemFinish != null">
item_finish,
</if>
<if test="deleted != null">
deleted,
</if>
<if test="createDate != null">
create_date,
</if>
<if test="updateDate != null">
update_date,
</if>
<if test="orgCode != null">
org_code,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="taskId != null">
#{taskId},
</if>
<if test="itemId != null">
#{itemId},
</if>
<if test="selectResult != null">
#{selectResult},
</if>
<if test="inputResult != null">
#{inputResult},
</if>
<if test="remarkResult != null">
#{remarkResult},
</if>
<if test="photoResult != null">
#{photoResult},
</if>
<if test="itemFinish != null">
#{itemFinish},
</if>
<if test="deleted != null">
#{deleted},
</if>
<if test="createDate != null">
#{createDate},
</if>
<if test="updateDate != null">
#{updateDate},
</if>
<if test="orgCode != null">
#{orgCode},
</if>
</trim>
</insert>
<update id="update" parameterType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentFillRecordBo">
update spc_risk_judgment_fill_record
<set>
<if test="taskId != null">
task_id = #{taskId},
</if>
<if test="itemId != null">
item_id = #{itemId},
</if>
<if test="selectResult != null">
select_result = #{selectResult},
</if>
<if test="inputResult != null">
input_result = #{inputResult},
</if>
<if test="remarkResult != null">
remark_result = #{remarkResult},
</if>
<if test="itemFinish != null">
item_finish = #{itemFinish},
</if>
<if test="photoResult != null">
photo_result = #{photoResult},
</if>
<if test="deleted != null">
deleted = #{deleted},
</if>
<if test="createDate != null">
create_date = #{createDate},
</if>
<if test="updateDate != null">
update_date = #{updateDate},
</if>
<if test="orgCode != null">
org_code = #{orgCode},
</if>
</set>
where id = #{id}
</update>
<insert id="saveBatch" keyColumn="id" keyProperty="id"
parameterType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentFillRecordBo"
useGeneratedKeys="true">
insert into spc_risk_judgment_fill_record
(
task_id,
item_id,
select_result,
input_result,
remark_result,
photo_result,
org_code
)
values
<foreach collection="list" item="item" index="index" separator=",">
(
#{item.taskId},
#{item.itemId},
#{item.selectResult},
#{item.inputResult},
#{item.remarkResult},
#{item.photoResult},
#{item.orgCode}
)
</foreach>
</insert>
<insert id="saveBatchWithStatus" keyColumn="id" keyProperty="id"
parameterType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentFillRecordBo"
useGeneratedKeys="true">
insert into spc_risk_judgment_fill_record
(
task_id,
item_id,
select_result,
input_result,
remark_result,
photo_result,
org_code,
item_finish
)
values
<foreach collection="list" item="item" index="index" separator=",">
(
#{item.taskId},
#{item.itemId},
#{item.selectResult},
#{item.inputResult},
#{item.remarkResult},
#{item.photoResult},
#{item.orgCode},
#{item.itemFinish}
)
</foreach>
</insert>
<update id="updateBatch" parameterType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentFillRecordBo">
<foreach collection="list" item="item" index="index" separator=";">
update spc_risk_judgment_fill_record
<set>
<if test="item.taskId != null">
task_id = #{item.taskId},
</if>
<if test="item.itemId != null">
item_id = #{item.itemId},
</if>
<if test="item.selectResult != null">
select_result = #{item.selectResult},
</if>
<if test="item.inputResult != null">
input_result = #{item.inputResult},
</if>
<if test="item.remarkResult != null">
remark_result = #{item.remarkResult},
</if>
<if test="item.itemFinish != null">
item_finish = #{item.itemFinish},
</if>
<if test="item.photoResult != null">
photo_result = #{item.photoResult},
</if>
<if test="item.deleted != null">
deleted = #{item.deleted},
</if>
<if test="item.createDate != null">
create_date = #{item.createDate},
</if>
<if test="item.updateDate != null">
update_date = #{item.updateDate},
</if>
<if test="item.orgCode != null">
org_code = #{item.orgCode},
</if>
<if test="item.extraIds != null">
extra_ids = #{item.extraIds},
</if>
</set>
where id = #{item.id}
</foreach>
</update>
<select id="listFillRecordData" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentFillRecordBo">
select
b.order_num,
a.*,
b.item_flag,
b.item_level,
b.item_type,
b.item_name,
b.item_can_copy,
b.item_parent_id,
b.select_name,
b.select_is_need,
b.select_is_required,
b.select_json,
b.input_name,
b.input_type,
b.input_can_edit,
b.input_is_need,
b.input_is_required,
b.remark_is_need,
b.remark_is_required,
b.photo_is_need,
b.photo_is_required,
(select c.department_id from spc_risk_judgment_task c where a.task_id = c.id) as department_id
from
spc_risk_judgment_fill_record a
left join
spc_risk_judgment_item b on a.item_id = b.id
<where>
<if test="true">
and a.deleted = 0
</if>
<if test="taskId != null">
and a.task_id = #{taskId}
</if>
<if test="type != null">
and b.item_type = #{type}
</if>
<if test="level != null">
and b.item_level = #{level}
</if>
<if test="itemParentId != null">
and b.item_parent_id = #{itemParentId}
</if>
</where>
order by b.order_num
</select>
<select id="countNotFinishRecordByTaskId" resultType="java.lang.Long">
select
count(1)
from
spc_risk_judgment_fill_record
where
deleted = 0
and
task_id = #{taskId}
and
item_finish = 0
</select>
<update id='updateInputResultAndselectResult'>
update
spc_risk_judgment_fill_record a,
spc_risk_judgment_task b,
spc_risk_judgment_item c
set a.input_result = #{inputResult}
<if test="selectResult !=null">,a.select_result = #{selectResult}</if>
WHERE
b.task_date = CURRENT_DATE ()
AND b.department_id = #{departmentId}
AND a.item_id = c.id
and b.id = a.task_id
and c.item_flag = #{itemFlag}
and b.task_status <![CDATA[<=]]> #{taskStatus}
</update>
</mapper>
\ No newline at end of file
amos-boot-system-maintenance/src/main/resources/db/mapper/SpcRiskJudgmentItemMapper.xml deleted 100644 → 0
View file @ 6b9dc633
<?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.yeejoin.amos.maintenance.business.dao.mapper.RiskJudgmentItemMapper">
<insert id="save" keyColumn="id" keyProperty="id"
parameterType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentItemBo"
useGeneratedKeys="true">
insert into spc_risk_judgment_item
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="itemFlag != null">
item_flag,
</if>
<if test="itemLevel != null">
item_level,
</if>
<if test="itemType != null">
item_type,
</if>
<if test="itemName != null">
item_name,
</if>
<if test="itemParentId != null">
item_parent_id,
</if>
<if test="itemCanCopy != null">
item_can_copy,
</if>
<if test="selectName != null">
select_name,
</if>
<if test="selectIsNeed != null">
select_is_need,
</if>
<if test="selectIsRequired != null">
select_is_required,
</if>
<if test="selectJson != null">
select_json,
</if>
<if test="inputName != null">
input_name,
</if>
<if test="inputType != null">
input_type,
</if>
<if test="inputCanEdit != null">
input_can_edit,
</if>
<if test="inputIsNeed != null">
input_is_need,
</if>
<if test="inputIsRequired != null">
input_is_required,
</if>
<if test="remarkIsNeed != null">
remark_is_need,
</if>
<if test="remarkIsRequired != null">
remark_is_required,
</if>
<if test="photoIsNeed != null">
photo_is_need,
</if>
<if test="photoIsRequired != null">
photo_is_required,
</if>
<if test="deleted != null">
deleted,
</if>
<if test="createDate != null">
create_date,
</if>
<if test="updateDate != null">
update_date,
</if>
<if test="orgCode != null">
org_code,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="itemFlag != null">
#{itemFlag},
</if>
<if test="itemLevel != null">
#{itemLevel},
</if>
<if test="itemType != null">
#{itemType},
</if>
<if test="itemName != null">
#{itemName},
</if>
<if test="itemParentId != null">
#{itemParentId},
</if>
<if test="itemCanCopy != null">
#{itemCanCopy},
</if>
<if test="selectName != null">
#{selectName},
</if>
<if test="selectIsNeed != null">
#{selectIsNeed},
</if>
<if test="selectIsRequired != null">
#{selectIsRequired},
</if>
<if test="selectJson != null">
#{selectJson},
</if>
<if test="inputName != null">
#{inputName},
</if>
<if test="inputType != null">
#{inputType},
</if>
<if test="inputCanEdit != null">
#{inputCanEdit},
</if>
<if test="inputIsNeed != null">
#{inputIsNeed},
</if>
<if test="inputIsRequired != null">
#{inputIsRequired},
</if>
<if test="remarkIsNeed != null">
#{remarkIsNeed},
</if>
<if test="remarkIsRequired != null">
#{remarkIsRequired},
</if>
<if test="photoIsNeed != null">
#{photoIsNeed},
</if>
<if test="photoIsRequired != null">
#{photoIsRequired},
</if>
<if test="deleted != null">
#{deleted},
</if>
<if test="createDate != null">
#{createDate},
</if>
<if test="updateDate != null">
#{updateDate},
</if>
<if test="orgCode != null">
#{orgCode},
</if>
</trim>
</insert>
<update id="update" parameterType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentItemBo">
update spc_risk_judgment_item
<set>
<if test="itemFlag != null">
item_flag = #{itemFlag},
</if>
<if test="itemLevel != null">
item_level = #{itemLevel},
</if>
<if test="itemType != null">
item_type = #{itemType},
</if>
<if test="itemName != null">
item_name = #{itemName},
</if>
<if test="itemParentId != null">
item_parent_id = #{itemParentId},
</if>
<if test="itemCanCopy != null">
item_can_copy = #{itemCanCopy},
</if>
<if test="selectName != null">
select_name = #{selectName},
</if>
<if test="selectIsNeed != null">
select_is_need = #{selectIsNeed},
</if>
<if test="selectIsRequired != null">
select_is_required = #{selectIsRequired},
</if>
<if test="selectJson != null">
select_json = #{selectJson},
</if>
<if test="inputName != null">
input_name = #{inputName},
</if>
<if test="inputTye != null">
input_type = #{inputTye},
</if>
<if test="inputCanEdit != null">
input_can_edit = #{inputCanEdit},
</if>
<if test="inputIsNeed != null">
input_is_need = #{inputIsNeed},
</if>
<if test="inputIsRequired != null">
input_is_required = #{inputIsRequired},
</if>
<if test="remarkIsNeed != null">
remark_is_need = #{remarkIsNeed},
</if>
<if test="remarkIsRequired != null">
remark_is_required = #{remarkIsRequired},
</if>
<if test="photoIsNeed != null">
photo_is_need = #{photoIsNeed},
</if>
<if test="photoIsRequired != null">
photo_is_required = #{photoIsRequired},
</if>
<if test="deleted != null">
deleted = #{deleted},
</if>
<if test="createDate != null">
create_date = #{createDate},
</if>
<if test="updateDate != null">
update_date = #{updateDate},
</if>
<if test="orgCode != null">
org_code = #{orgCode},
</if>
</set>
where id = #{id}
</update>
<select id="listAllItemByDepartmentCode" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentItemBo">
select
*
from
spc_risk_judgment_item
where
deleted = 0
and
department_code = #{departmentCode}
</select>
<select id="findByItemId" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentItemBo">
select * from spc_risk_judgment_item where id = #{itemId}
</select>
</mapper>
\ No newline at end of file
amos-boot-system-maintenance/src/main/resources/db/mapper/SpcRiskJudgmentTaskMapper.xml deleted 100644 → 0
View file @ 6b9dc633
<?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.yeejoin.amos.maintenance.business.dao.mapper.RiskJudgmentTaskMapper">
<insert id="save" keyColumn="id" keyProperty="id"
parameterType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentTaskBo"
useGeneratedKeys="true">
insert into spc_risk_judgment_task
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="taskName != null">
task_name,
</if>
<if test="departmentId != null">
department_id,
</if>
<if test="taskStatus != null">
task_status,
</if>
<if test="taskDate != null">
task_date,
</if>
<if test="taskCommitDate != null">
task_commit_date,
</if>
<if test="currentFlowTaskId != null">
current_flow_task_id,
</if>
<if test="taskDefinitionKey != null">
task_definition_key,
</if>
<if test="flowUserIds != null">
flow_user_ids,
</if>
<if test="flowInstanceId != null">
flow_instance_id,
</if>
<if test="orgCode != null">
org_code,
</if>
<if test="deleted != null">
deleted,
</if>
<if test="createDate != null">
create_date,
</if>
<if test="updateDate != null">
update_date,
</if>
<if test="businessKey != null and businessKey !=''">
business_key,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="taskName != null">
#{taskName},
</if>
<if test="departmentId != null">
#{departmentId},
</if>
<if test="taskStatus != null">
#{taskStatus},
</if>
<if test="taskDate != null">
#{taskDate},
</if>
<if test="taskCommitDate != null">
#{taskCommitDate},
</if>
<if test="currentFlowTaskId != null">
#{currentFlowTaskId},
</if>
<if test="taskDefinitionKey != null">
#{taskDefinitionKey},
</if>
<if test="flowUserIds != null">
#{flowUserIds},
</if>
<if test="flowInstanceId != null">
#{flowInstanceId},
</if>
<if test="orgCode != null">
#{orgCode},
</if>
<if test="deleted != null">
#{deleted},
</if>
<if test="createDate != null">
#{createDate},
</if>
<if test="updateDate != null">
#{updateDate},
</if>
<if test="businessKey != null and businessKey !=''">
#{businessKey}
</if>
</trim>
</insert>
<update id="update" parameterType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentTaskBo">
update spc_risk_judgment_task
<set>
<if test="taskName != null">
task_name = #{taskName},
</if>
<if test="departmentId != null">
department_id = #{departmentId},
</if>
<if test="taskStatus != null">
task_status = #{taskStatus},
</if>
<if test="taskDate != null">
task_date = #{taskDate},
</if>
<if test="taskCommitDate != null">
task_commit_date = #{taskCommitDate},
</if>
<if test="currentFlowTaskId != null">
current_flow_task_id = #{currentFlowTaskId},
</if>
<if test="taskDefinitionKey != null">
task_definition_key = #{taskDefinitionKey},
</if>
<if test="flowUserIds != null">
flow_user_ids = #{flowUserIds},
</if>
<if test="flowInstanceId != null">
flow_instance_id = #{flowInstanceId},
</if>
<if test="orgCode != null">
org_code = #{orgCode},
</if>
<if test="deleted != null">
deleted = #{deleted},
</if>
<if test="createDate != null">
create_date = #{createDate},
</if>
<if test="updateDate != null">
update_date = #{updateDate},
</if>
</set>
where id = #{id}
</update>
<update id="updateBatch" parameterType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentItemBo">
<foreach collection="list" item="item" index="index" separator=";">
update spc_risk_judgment_task
<set>
<if test="item.taskName != null">
task_name = #{item.taskName},
</if>
<if test="item.departmentId != null">
department_id = #{item.departmentId},
</if>
<if test="item.taskStatus != null">
task_status = #{item.taskStatus},
</if>
<if test="item.taskDate != null">
task_date = #{item.taskDate},
</if>
<if test="item.taskCommitDate != null">
task_commit_date = #{item.taskCommitDate},
</if>
<if test="item.currentFlowTaskId != null">
current_flow_task_id = #{item.currentFlowTaskId},
</if>
<if test="item.taskDefinitionKey != null">
task_definition_key = #{item.taskDefinitionKey},
</if>
<if test="item.flowUserIds != null">
flow_user_ids = #{item.flowUserIds},
</if>
<if test="item.flowInstanceId != null">
flow_instance_id = #{item.flowInstanceId},
</if>
<if test="item.orgCode != null">
org_code = #{item.orgCode},
</if>
<if test="item.deleted != null">
deleted = #{item.deleted},
</if>
<if test="item.createDate != null">
create_date = #{item.createDate},
</if>
<if test="item.updateDate != null">
update_date = #{item.updateDate},
</if>
</set>
where id = #{item.id}
</foreach>
</update>
<select id="listByDateAndStatus" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentTaskBo">
select
*
from
spc_risk_judgment_task
where
deleted = 0
and
task_date = #{date}
and
task_status = #{status}
</select>
<select id="listByMap" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentTaskBo">
select
a.*
from
spc_risk_judgment_task as a
<where>
<if test="true">
and a.deleted = 0
</if>
<if test="true">
and a.task_status != 0
</if>
<if test="userId != null and userId != '' and !hasPermission">
and find_in_set(#{userId}, a.flow_user_ids)
</if>
<if test="orgCode != null and orgCode != ''">
and a.org_code = #{orgCode}
</if>
<if test="taskStatus != null and taskStatus != ''">
and a.task_status = #{taskStatus}
</if>
<if test="beginTime != null and beginTime != ''">
and a.task_date &gt;= #{beginTime}
</if>
<if test="endTime != null and endTime != ''">
and a.task_date &lt;= #{endTime}
</if>
<if test="departmentId != null">
and a.department_id = #{departmentId}
</if>
<if test="departmentIds != null and departmentIds != ''">
and find_in_set(a.department_id, #{departmentIds})
</if>
</where>
order by create_date desc
limit #{offset},#{limit}
</select>
<select id="countByMap" resultType="java.lang.Long">
select
count(1)
from
spc_risk_judgment_task as a
<where>
<if test="true">
and a.deleted = 0
</if>
<if test="true">
and a.task_status != 0
</if>
<if test="userId != null and userId != '' and !hasPermission">
and find_in_set(#{userId}, a.flow_user_ids)
</if>
<if test="orgCode != null and orgCode != ''">
and a.org_code = #{orgCode}
</if>
<if test="taskStatus != null and taskStatus != ''">
and a.task_status = #{taskStatus}
</if>
<if test="beginTime != null and beginTime != ''">
and a.task_date &gt;= #{beginTime}
</if>
<if test="endTime != null and endTime != ''">
and a.task_date &lt;= #{endTime}
</if>
<if test="departmentId != null">
and a.department_id = #{departmentId}
</if>
<if test="departmentIds != null and departmentIds != ''">
and find_in_set(a.department_id, #{departmentIds})
</if>
</where>
</select>
<select id="getById" resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentTaskBo">
select
*
from
spc_risk_judgment_task
where
deleted = 0
and
id = #{id}
</select>
<select id="getByInstanceIdAndTaskDefinitionKey"
resultType="com.yeejoin.amos.maintenance.business.entity.mybatis.RiskJudgmentTaskBo">
select
*
from
spc_risk_judgment_task
where
deleted = 0
and
flow_instance_id = #{instanceId}
and
task_definition_key = #{taskDefinitionKey}
</select>
<select id="countByFlowUserIds" resultType="java.lang.Long">
select
count(1)
from
spc_risk_judgment_task
where
deleted = 0
and
task_status = 1
and
find_in_set(#{userId},flow_user_ids)
</select>
<update id="updatetTaskStatusByInstanceId" >
update spc_risk_judgment_task
set task_status = #{taskStatus}
where flow_instance_id = #{flowInstanceId}
</update>
</mapper>
\ No newline at end of file
amos-boot-system-maintenance/src/main/resources/db/mapper/dbTemplate_check.xml
View file @ 3b4c9369
...@@ -108,9 +108,6 @@ ...@@ -108,9 +108,6 @@
LEFT JOIN `p_point` `b` ON `a`.`point_id` = `b`.`id` LEFT JOIN `p_point` `b` ON `a`.`point_id` = `b`.`id`
LEFT JOIN `p_route` `d` ON `a`.`route_id` = `d`.`id` LEFT JOIN `p_route` `d` ON `a`.`route_id` = `d`.`id`
LEFT JOIN `p_plan` `e` ON `a`.`plan_id` = `e`.`id` LEFT JOIN `p_plan` `e` ON `a`.`plan_id` = `e`.`id`
<if test="dangerId != null and dangerId != ''">
LEFT JOIN ( SELECT check_id, GROUP_CONCAT( latent_danger_id ) dangerIds FROM p_latent_danger_patrol GROUP BY check_id ) t ON t.check_id = a.id
</if>
<trim prefix="WHERE" prefixOverrides="AND "> <trim prefix="WHERE" prefixOverrides="AND ">
<if test="beginDate!=null and endDate!=null">and a.check_time BETWEEN #{beginDate} and #{endDate}</if> <if test="beginDate!=null and endDate!=null">and a.check_time BETWEEN #{beginDate} and #{endDate}</if>
<!-- <if test="endDate!=null"> and #{endDate} <![CDATA[>=]]> a.check_time </if> --> <!-- <if test="endDate!=null"> and #{endDate} <![CDATA[>=]]> a.check_time </if> -->
......
amos-boot-system-maintenance/src/main/resources/db/mapper/dbTemplate_plan_task.xml
View file @ 3b4c9369
...@@ -178,7 +178,6 @@ ...@@ -178,7 +178,6 @@
pt.id planTaskId, pt.id planTaskId,
pt.org_code orgCode, pt.org_code orgCode,
p.name taskName, p.name taskName,
pt.status,
pt.user_id userId, pt.user_id userId,
date_format( date_format(
pt.begin_time, pt.begin_time,
...@@ -339,9 +338,11 @@ ...@@ -339,9 +338,11 @@
<select id="getPlanTaskPoints" resultType="Map"> <select id="getPlanTaskPoints" resultType="Map">
SELECT SELECT
ptd.id, ptd.id,
p.id as pointId,
p.name, p.name,
p.point_no pointNo, p.point_no pointNo,
concat_ws(' ',p.building_name,p.address) as position, concat_ws('',p.building_name,p.address) as position,
p.belong_system_id as belongSystemId,
p.belong_system_name as belongSystemName, p.belong_system_name as belongSystemName,
ptd.status, ptd.status,
ptd.is_finish as isFinish, ptd.is_finish as isFinish,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment