package com.gkhy.labRiskManage.application.riskReport.service.impl;
|
|
import com.gkhy.labRiskManage.api.controller.riskReport.dto.repDto.*;
|
import com.gkhy.labRiskManage.api.controller.riskReport.dto.respDto.RiskAssessPlanListRespDTO;
|
import com.gkhy.labRiskManage.api.controller.riskReport.dto.respDto.RiskUnitListQueryRespDTO;
|
import com.gkhy.labRiskManage.application.riskReport.dto.bo.*;
|
import com.gkhy.labRiskManage.application.riskReport.dto.dto.*;
|
import com.gkhy.labRiskManage.application.riskReport.service.RiskAccessAppService;
|
import com.gkhy.labRiskManage.commons.domain.SearchResult;
|
import com.gkhy.labRiskManage.commons.enums.ResultCode;
|
import com.gkhy.labRiskManage.commons.enums.StatusEnum;
|
import com.gkhy.labRiskManage.commons.enums.UserRoleEnum;
|
import com.gkhy.labRiskManage.commons.exception.BusinessException;
|
import com.gkhy.labRiskManage.commons.utils.BeanCopyUtils;
|
import com.gkhy.labRiskManage.domain.account.model.dto.SysUserRoleBindDomainDTO;
|
import com.gkhy.labRiskManage.domain.account.model.dto.UserInfoDomainDTO;
|
import com.gkhy.labRiskManage.domain.account.service.UserDomainService;
|
import com.gkhy.labRiskManage.domain.basic.model.dto.PersonQueryDTO;
|
import com.gkhy.labRiskManage.domain.basic.model.dto.RiskUnitBasicQueryDTO;
|
import com.gkhy.labRiskManage.domain.experiment.model.dto.ExperimentInfoDTO;
|
import com.gkhy.labRiskManage.domain.riskReport.entity.*;
|
import com.gkhy.labRiskManage.domain.riskReport.model.bo.AssessLSInsertBO;
|
import com.gkhy.labRiskManage.domain.riskReport.model.bo.AssessLecInsertBO;
|
import com.gkhy.labRiskManage.domain.riskReport.model.bo.AssessMesInsertBO;
|
import com.gkhy.labRiskManage.domain.riskReport.model.bo.AssessRsInsertBO;
|
import com.gkhy.labRiskManage.domain.riskReport.model.dto.*;
|
import com.gkhy.labRiskManage.domain.basic.service.BasicExperimentPersonService;
|
import com.gkhy.labRiskManage.domain.basic.service.BasicRiskUnitService;
|
import com.gkhy.labRiskManage.domain.experiment.service.ExperimentInfoService;
|
import com.gkhy.labRiskManage.domain.riskReport.service.*;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.ObjectUtils;
|
|
import java.math.BigDecimal;
|
import java.util.List;
|
|
@Service
|
public class RiskAccessAppServiceImpl implements RiskAccessAppService {
|
|
@Autowired
|
private RiskAssessPlanService assessPlanService;
|
@Autowired
|
private RiskUnitService riskUnitService;
|
@Autowired
|
private ExperimentInfoService experimentInfoService;
|
@Autowired
|
private BasicRiskUnitService basicRiskUnitService;
|
@Autowired
|
private BasicExperimentPersonService basicExperimentPersonService;
|
|
|
@Autowired
|
private RiskAssessPlanIdentificationAnalogyService analogyService;
|
@Autowired
|
private RiskAssessPlanIdentificationHazopService hazopService;
|
@Autowired
|
private RiskAssessPlanIdentificationJhaService jhaService;
|
@Autowired
|
private RiskAssessPlanIdentificationPhaService phaService;
|
@Autowired
|
private RiskAssessPlanIdentificationSclService sclService;
|
|
@Autowired
|
private RiskAssessPlanEvaluateLecService lecService;
|
@Autowired
|
private RiskAssessPlanEvaluateLsService lsService;
|
@Autowired
|
private RiskAssessPlanEvaluateMesService mesService;
|
@Autowired
|
private RiskAssessPlanEvaluateRsService rsService;
|
|
@Autowired
|
private UserDomainService userDomainService;
|
|
/**
|
* 风险评估计划 - 插入
|
*/
|
@Override
|
public int insertAssessPlan(Long currentUserId, RiskAssessPlanInsertReqBO assessPlanInsertReqDTO) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
// RiskUnitQueryDTO riskUnitById = riskUnitService.getRiskUnitById(assessPlanInsertReqDTO.getRiskUnitId());
|
// UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
|
// if (!userInfoById.getId().equals(riskUnitById.getLiabilityUserId())){
|
// throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "只有实验负责人，才能修改实验风险单元");
|
// }
|
|
RiskAssessPlanAppInsertBO insertParam = BeanCopyUtils.copyBean(assessPlanInsertReqDTO, RiskAssessPlanAppInsertBO.class);
|
PlanInsertDTO planInsertDTO = assessPlanService.insertAssessPlan(currentUserId, insertParam);
|
|
if (ObjectUtils.isEmpty(planInsertDTO)){
|
return StatusEnum.FAIL.getCode();
|
}
|
return StatusEnum.SUCCESS.getCode();
|
}
|
|
/**
|
* 风险评估计划 - 查询
|
*/
|
@Override
|
public SearchResult<RiskAssessPlanAppQueryDTO> selectAssessPlanPage(Long currentUserId, RiskAssessPlanQueryReqBO queryReqBO) {
|
|
|
SearchResult searchResult = new SearchResult<>();
|
|
RiskAssessPlanAppQueryBO queryParam = BeanCopyUtils.copyBean(queryReqBO, RiskAssessPlanAppQueryBO.class);
|
SearchResult<AssessPlanQueryDTO> queryResult = assessPlanService.selectAssessPlanPage(currentUserId, queryParam);
|
|
searchResult.setPageIndex(queryResult.getPageIndex());
|
searchResult.setPageSize(queryResult.getPageSize());
|
searchResult.setTotal(queryResult.getTotal());
|
searchResult.setData(BeanCopyUtils.copyRiskAssessPlanAppQueryList(queryResult.getData(), RiskAssessPlanAppQueryDTO.class));
|
|
return searchResult;
|
}
|
|
/**
|
* 风险评估计划 - 修改
|
*/
|
@Override
|
public int updateAssessPlan(Long currentUserId, RiskAssessPlanUpdateReqBO updateReqBO) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
|
RiskAssessPlanUpdateReqBO updateParam = BeanCopyUtils.copyBean(updateReqBO, RiskAssessPlanUpdateReqBO.class);
|
|
AssessPlanUpdateDTO assessPlanUpdateDTO = assessPlanService.updateAssessPlan(currentUserId, updateParam);
|
|
if (ObjectUtils.isEmpty(assessPlanUpdateDTO)){
|
return StatusEnum.FAIL.getCode();
|
}
|
return StatusEnum.SUCCESS.getCode();
|
}
|
|
/**
|
* 风险评估计划 - 删除
|
*/
|
@Override
|
public int deleteAssessPlan(Long currentUserId, Long id) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
|
AssessPlanDeleteDTO deleteResult = assessPlanService.deleteAssessPlan(currentUserId, id);
|
|
if (ObjectUtils.isEmpty(deleteResult)){
|
return StatusEnum.FAIL.getCode();
|
}
|
return StatusEnum.SUCCESS.getCode();
|
}
|
|
/**
|
* 风险评估计划 - 派发任务
|
*/
|
@Override
|
public int sellAssessPlan(Long currentUserId, Long id) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
|
AssessPlanUpdateDTO sellResult = assessPlanService.sellAssessPlan(currentUserId, id);
|
|
if (ObjectUtils.isEmpty(sellResult)){
|
return StatusEnum.FAIL.getCode();
|
}
|
return StatusEnum.SUCCESS.getCode();
|
}
|
|
/**
|
* 风险评估计划 - 辨识
|
*/
|
@Override
|
@Transactional
|
public FactorQueryDTO identification(Long currentUserId, RiskAssessPlanIdentificationInsertReqBO identificationReqBO) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
|
if (userInfoById == null){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
String realName = userInfoById.getRealName();
|
|
RiskAssessPlanAppIdentificationBO identificationParam = BeanCopyUtils.copyBean(identificationReqBO, RiskAssessPlanAppIdentificationBO.class);
|
int tag = 1;
|
FactorQueryDTO factorQueryDTO = new FactorQueryDTO();
|
PhaInsertDTO phaInsertDTO = new PhaInsertDTO();
|
JhaInsertDTO jhaInsertDTO = new JhaInsertDTO();
|
SclInsertDTO sclInsertDTO = new SclInsertDTO();
|
HazopInsertDTO hazopInsertDTO = new HazopInsertDTO();
|
AnalogyInsertDTO analogyInsertDTO = new AnalogyInsertDTO();
|
//分发参数到不同的服务进行处理
|
//辨识方法 1-PHA；
|
if (identificationParam.getIdentificationMethod() == 1){
|
RiskAssessPlanIdentificationPha pha = BeanCopyUtils.copyBean(identificationParam, RiskAssessPlanIdentificationPha.class);
|
pha.setAssessPlanId(identificationParam.getId());
|
pha.setCreateByUser(realName);
|
pha.setCreateByUserId(currentUserId.intValue());
|
phaInsertDTO = phaService.insertPha(currentUserId, pha);
|
if (ObjectUtils.isEmpty(phaInsertDTO)){
|
tag = 0;
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(phaInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setPhaId(phaInsertDTO.getId());
|
//辨识方法 2-JHA；
|
}else if (identificationParam.getIdentificationMethod() == 2){
|
RiskAssessPlanIdentificationJha jha = BeanCopyUtils.copyBean(identificationParam, RiskAssessPlanIdentificationJha.class);
|
jha.setAssessPlanId(identificationParam.getId());
|
jha.setCreateByUser(realName);
|
jha.setCreateByUserId(currentUserId.intValue());
|
jhaInsertDTO = jhaService.insertJha(currentUserId, jha);
|
if (ObjectUtils.isEmpty(jhaInsertDTO)){
|
tag = 0;
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(jhaInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setJhaId(jhaInsertDTO.getId());
|
//辨识方法 3-SCL；
|
}else if (identificationParam.getIdentificationMethod() == 3){
|
RiskAssessPlanIdentificationScl scl = BeanCopyUtils.copyBean(identificationParam, RiskAssessPlanIdentificationScl.class);
|
scl.setAssessPlanId(identificationParam.getId());
|
scl.setCreateByUser(realName);
|
scl.setCreateByUserId(currentUserId.intValue());
|
sclInsertDTO = sclService.insertScl(currentUserId, scl);
|
if (ObjectUtils.isEmpty(sclInsertDTO)){
|
tag = 0;
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(sclInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setSclId(sclInsertDTO.getId());
|
//辨识方法 4-HAZOP；
|
}else if (identificationParam.getIdentificationMethod() == 4){
|
RiskAssessPlanIdentificationHazop hazop = BeanCopyUtils.copyBean(identificationParam, RiskAssessPlanIdentificationHazop.class);
|
hazop.setAssessPlanId(identificationParam.getId());
|
hazop.setCreateByUser(realName);
|
hazop.setCreateByUserId(currentUserId.intValue());
|
|
hazopInsertDTO = hazopService.insertHazop(currentUserId, hazop);
|
if (ObjectUtils.isEmpty(hazopInsertDTO)){
|
tag = 0;
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(hazopInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setHazopId(hazopInsertDTO.getId());
|
//5-类比法 nalogy；
|
}else if (identificationParam.getIdentificationMethod() == 5){
|
RiskAssessPlanIdentificationAnalogy analogy = BeanCopyUtils.copyBean(identificationParam, RiskAssessPlanIdentificationAnalogy.class);
|
analogy.setAssessPlanId(identificationParam.getId());
|
analogy.setCreateByUser(realName);
|
analogy.setCreateByUserId(currentUserId.intValue());
|
analogyInsertDTO = analogyService.insertAnalogy(currentUserId, analogy);
|
if (ObjectUtils.isEmpty(analogyInsertDTO)){
|
tag = 0;
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(analogyInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setAnalogyId(analogyInsertDTO.getId());
|
}else {
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode(), "请选择正确的辨识方法");
|
}
|
|
//处理评估计划表
|
AssessPlanIdentificationDTO identificationResult = assessPlanService.identification(currentUserId, identificationParam);
|
|
if (ObjectUtils.isEmpty(identificationResult) && tag == 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "新增辨识失败");
|
}
|
return factorQueryDTO;
|
}
|
|
/**
|
* 风险评估计划 - 辨识修改
|
*/
|
@Transactional
|
@Override
|
public FactorQueryDTO updateIdentification(Long currentUserId, RiskAssessPlanIdentificationUpdateReqBO updateReqBO) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
|
if (userInfoById == null){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
String realName = userInfoById.getRealName();
|
RiskAssessPlanIdentificationAppUpdateBO updateParam = BeanCopyUtils.copyBean(updateReqBO, RiskAssessPlanIdentificationAppUpdateBO.class);
|
int tag = 1;
|
FactorQueryDTO factorQueryDTO = new FactorQueryDTO();
|
//分发参数到不同的服务进行处理
|
//辨识方法 1-PHA；
|
if (updateParam.getIdentificationMethod() == 1){
|
RiskAssessPlanIdentificationPha pha = BeanCopyUtils.copyBean(updateParam, RiskAssessPlanIdentificationPha.class);
|
pha.setAssessPlanId(updateParam.getId());
|
pha.setId(updateParam.getPhaId());
|
pha.setUpdateByUser(realName);
|
pha.setUpdateByUserId(currentUserId.intValue());
|
PhaInsertDTO phaInsertDTO = phaService.updatePha(currentUserId, pha);
|
if (ObjectUtils.isEmpty(phaInsertDTO)){
|
tag = 0;
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(phaInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setPhaId(phaInsertDTO.getId());
|
//辨识方法 2-JHA；
|
}else if (updateParam.getIdentificationMethod() == 2){
|
RiskAssessPlanIdentificationJha jha = BeanCopyUtils.copyBean(updateParam, RiskAssessPlanIdentificationJha.class);
|
jha.setAssessPlanId(updateParam.getId());
|
jha.setId(updateParam.getJhaId());
|
jha.setUpdateByUser(realName);
|
jha.setUpdateByUserId(currentUserId.intValue());
|
JhaInsertDTO jhaInsertDTO = jhaService.updateJha(currentUserId, jha);
|
if (ObjectUtils.isEmpty(jhaInsertDTO)){
|
tag = 0;
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(jhaInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setJhaId(jhaInsertDTO.getId());
|
//辨识方法 3-SCL；
|
}else if (updateParam.getIdentificationMethod() == 3){
|
RiskAssessPlanIdentificationScl scl = BeanCopyUtils.copyBean(updateParam, RiskAssessPlanIdentificationScl.class);
|
scl.setAssessPlanId(updateParam.getId());
|
scl.setId(updateParam.getSclId());
|
scl.setUpdateByUser(realName);
|
scl.setUpdateByUserId(currentUserId.intValue());
|
SclInsertDTO sclInsertDTO = sclService.updateScl(currentUserId, scl);
|
if (ObjectUtils.isEmpty(sclInsertDTO)){
|
tag = 0;
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(sclInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setSclId(sclInsertDTO.getId());
|
//辨识方法 4-HAZOP；
|
}else if (updateParam.getIdentificationMethod() == 4){
|
RiskAssessPlanIdentificationHazop hazop = BeanCopyUtils.copyBean(updateParam, RiskAssessPlanIdentificationHazop.class);
|
hazop.setAssessPlanId(updateParam.getId());
|
hazop.setId(updateParam.getHazopId());
|
hazop.setUpdateByUser(realName);
|
hazop.setUpdateByUserId(currentUserId.intValue());
|
HazopInsertDTO hazopInsertDTO = hazopService.updateHazop(currentUserId, hazop);
|
if (ObjectUtils.isEmpty(hazopInsertDTO)){
|
tag = 0;
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(hazopInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setHazopId(hazopInsertDTO.getId());
|
//5-类比法 nalogy；
|
}else if (updateParam.getIdentificationMethod() == 5){
|
RiskAssessPlanIdentificationAnalogy analogy = BeanCopyUtils.copyBean(updateParam, RiskAssessPlanIdentificationAnalogy.class);
|
analogy.setAssessPlanId(updateParam.getId());
|
analogy.setId(updateParam.getAnalogyId());
|
analogy.setUpdateByUser(realName);
|
analogy.setUpdateByUserId(currentUserId.intValue());
|
AnalogyInsertDTO analogyInsertDTO = analogyService.updateAnalogy(currentUserId, analogy);
|
if (ObjectUtils.isEmpty(analogyInsertDTO)){
|
tag = 0;
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(analogyInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setAnalogyId(analogyInsertDTO.getId());
|
}else {
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode(), "请选择正确的辨识方法");
|
}
|
|
RiskAssessPlanAppIdentificationBO riskAssessPlanAppIdentificationBO = BeanCopyUtils.copyBean(updateReqBO, RiskAssessPlanAppIdentificationBO.class);
|
//处理评估计划表
|
AssessPlanIdentificationDTO identificationResult = assessPlanService.identification(currentUserId, riskAssessPlanAppIdentificationBO);
|
|
if (ObjectUtils.isEmpty(identificationResult) && tag == 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "修改辨识失败");
|
}
|
return factorQueryDTO;
|
}
|
|
/**
|
* 风险评估计划 - 辨识删除
|
*/
|
@Override
|
public int deleteIdentification(Long currentUserId, RiskAssessPlanIdentificationDeleteReqBO deleteReqBO) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
|
AssessPlanUpdateDTO deleteResult = assessPlanService.deleteIdentification(currentUserId, deleteReqBO);
|
|
if (ObjectUtils.isEmpty(deleteResult)){
|
return StatusEnum.FAIL.getCode();
|
}
|
return StatusEnum.SUCCESS.getCode();
|
}
|
|
/**
|
* 风险评估计划 - 辨识结果提交
|
*/
|
@Override
|
public int identificationSubmit(Long currentUserId, Long id) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
|
AssessPlanUpdateDTO identificationSubmitResult= assessPlanService.identificationSubmit(currentUserId, id);
|
|
if (ObjectUtils.isEmpty(identificationSubmitResult)){
|
return StatusEnum.FAIL.getCode();
|
}
|
return StatusEnum.SUCCESS.getCode();
|
}
|
|
/**
|
* 风险评估计划 - 评价
|
*/
|
@Transactional
|
@Override
|
public FactorQueryDTO evaluate(Long currentUserId, RiskAssessPlanEvaluateInsertReqBO evaluateReqBO) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
|
RiskAssessPlanAppEvaluateBO evaluateParam = BeanCopyUtils.copyBean(evaluateReqBO, RiskAssessPlanAppEvaluateBO.class);
|
AssessPlanQueryDTO assessPlanById = assessPlanService.getAssessPlanById(evaluateParam.getId());
|
int tag = 1;
|
FactorQueryDTO factorQueryDTO = new FactorQueryDTO();
|
//分发参数到不同的服务进行处理
|
// todo ,1、将参数与结果值传入，2计算比对前端传来的结果值是否正确，3相同存入，不同抛异常
|
//辨识方法1 - LEC
|
if (assessPlanById.getEvaluateMethod() == 1){
|
AssessLecInsertBO lecInsertBO = BeanCopyUtils.copyBean(evaluateReqBO, AssessLecInsertBO.class);
|
lecInsertBO.setAssessPlanId(evaluateParam.getId());
|
lecInsertBO.setIdentificationId(evaluateReqBO.getIdentificationId());
|
lecInsertBO.setIdentificationMethod(assessPlanById.getIdentificationMethod());
|
LecInsertDTO lecInsertDTO = lecService.insertLec(currentUserId, lecInsertBO);
|
if (ObjectUtils.isEmpty(lecInsertDTO)){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "写入评价结果失败");
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(lecInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setLecId(lecInsertDTO.getId());
|
factorQueryDTO.setEvaluateMethod(assessPlanById.getEvaluateMethod());
|
//辨识方法2 - LS
|
}else if (assessPlanById.getEvaluateMethod() == 2){
|
AssessLSInsertBO lsInsertBO = BeanCopyUtils.copyBean(evaluateReqBO, AssessLSInsertBO.class);
|
lsInsertBO.setAssessPlanId(evaluateParam.getId());
|
lsInsertBO.setIdentificationId(evaluateReqBO.getIdentificationId());
|
lsInsertBO.setIdentificationMethod(assessPlanById.getIdentificationMethod());
|
LsInsertDTO lsInsertDTO = lsService.insertLs(currentUserId, lsInsertBO);
|
if (ObjectUtils.isEmpty(lsInsertDTO)){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "写入评价结果失败");
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(lsInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setLsId(lsInsertDTO.getId());
|
factorQueryDTO.setEvaluateMethod(assessPlanById.getEvaluateMethod());
|
//辨识方法3 - MES
|
}else if (assessPlanById.getEvaluateMethod() == 3){
|
AssessMesInsertBO mesInsertBO = BeanCopyUtils.copyBean(evaluateReqBO, AssessMesInsertBO.class);
|
mesInsertBO.setAssessPlanId(evaluateParam.getId());
|
mesInsertBO.setIdentificationId(evaluateReqBO.getIdentificationId());
|
mesInsertBO.setIdentificationMethod(assessPlanById.getIdentificationMethod());
|
MesInsertDTO mesInsertDTO = mesService.InsertMes(currentUserId, mesInsertBO);
|
if (ObjectUtils.isEmpty(mesInsertDTO)){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "写入评价结果失败");
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(mesInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setMesId(mesInsertDTO.getId());
|
factorQueryDTO.setEvaluateMethod(assessPlanById.getEvaluateMethod());
|
//辨识方法4 - RS
|
}else if (assessPlanById.getEvaluateMethod() == 4){
|
AssessRsInsertBO rsInsertBO = BeanCopyUtils.copyBean(evaluateReqBO, AssessRsInsertBO.class);
|
rsInsertBO.setAssessPlanId(evaluateParam.getId());
|
rsInsertBO.setIdentificationId(evaluateReqBO.getIdentificationId());
|
rsInsertBO.setIdentificationMethod(assessPlanById.getIdentificationMethod());
|
RsInsertDTO rsInsertDTO = rsService.InsertRs(currentUserId, rsInsertBO);
|
if (ObjectUtils.isEmpty(rsInsertDTO)){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "写入评价结果失败");
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(rsInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setRsId(rsInsertDTO.getId());
|
factorQueryDTO.setEvaluateMethod(assessPlanById.getEvaluateMethod());
|
}else {
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode(), "请选择正确的评价方法");
|
}
|
|
//处理评估计划表
|
AssessPlanEvaluateDTO evaluateResult = assessPlanService.evaluate(currentUserId, evaluateParam);
|
if (ObjectUtils.isEmpty(evaluateResult)){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode(), "写入失败");
|
}
|
return factorQueryDTO;
|
}
|
|
/**
|
* 风险评估计划 - 评价修改
|
*/
|
@Transactional
|
@Override
|
public FactorQueryDTO updateEvaluate(Long currentUserId, RiskAssessPlanEvaluateUpdateReqBO updateReqBO) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
|
RiskAssessPlanEvaluateUpdateReqBO updateParam = BeanCopyUtils.copyBean(updateReqBO, RiskAssessPlanEvaluateUpdateReqBO.class);
|
AssessPlanQueryDTO assessPlanById = assessPlanService.getAssessPlanById(updateReqBO.getId());
|
int tag = 1;
|
FactorQueryDTO factorQueryDTO = new FactorQueryDTO();
|
//分发参数到不同的服务进行处理
|
// 1、将参数与结果值传入，2计算比对前端传来的结果值是否正确，3相同存入，不同抛异常
|
//辨识方法1 - LEC
|
if (assessPlanById.getEvaluateMethod() == 1){
|
AssessLecInsertBO lecInsertBO = BeanCopyUtils.copyBean(updateParam, AssessLecInsertBO.class);
|
lecInsertBO.setAssessPlanId(updateParam.getId());
|
lecInsertBO.setId(updateParam.getLecId());
|
lecInsertBO.setIdentificationMethod(assessPlanById.getIdentificationMethod());
|
LecInsertDTO lecInsertDTO = lecService.updateLec(currentUserId, lecInsertBO);
|
if (ObjectUtils.isEmpty(lecInsertDTO)){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "修改评价结果失败");
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(lecInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setLecId(lecInsertDTO.getId());
|
factorQueryDTO.setEvaluateMethod(assessPlanById.getEvaluateMethod());
|
//辨识方法2 - LS
|
}else if (assessPlanById.getEvaluateMethod() == 2){
|
AssessLSInsertBO lsInsertBO = BeanCopyUtils.copyBean(updateParam, AssessLSInsertBO.class);
|
lsInsertBO.setAssessPlanId(updateParam.getId());
|
lsInsertBO.setId(updateParam.getLsId());
|
lsInsertBO.setIdentificationMethod(assessPlanById.getIdentificationMethod());
|
LecInsertDTO lsInsertDTO = lsService.updateLs(currentUserId, lsInsertBO);
|
if (ObjectUtils.isEmpty(lsInsertDTO)){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "修改评价结果失败");
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(lsInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setLsId(lsInsertDTO.getId());
|
factorQueryDTO.setEvaluateMethod(assessPlanById.getEvaluateMethod());
|
//辨识方法3 - MES
|
}else if (assessPlanById.getEvaluateMethod() == 3){
|
AssessMesInsertBO mesInsertBO = BeanCopyUtils.copyBean(updateParam, AssessMesInsertBO.class);
|
mesInsertBO.setAssessPlanId(updateParam.getId());
|
mesInsertBO.setId(updateParam.getMesId());
|
mesInsertBO.setIdentificationMethod(assessPlanById.getIdentificationMethod());
|
MesInsertDTO mesInsertDTO = mesService.updateMes(currentUserId, mesInsertBO);
|
if (ObjectUtils.isEmpty(mesInsertDTO)){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "写入评价结果失败");
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(mesInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setMesId(mesInsertDTO.getId());
|
factorQueryDTO.setEvaluateMethod(assessPlanById.getEvaluateMethod());
|
//辨识方法4 - RS
|
}else if (assessPlanById.getEvaluateMethod() == 4){
|
AssessRsInsertBO rsInsertBO = BeanCopyUtils.copyBean(updateParam, AssessRsInsertBO.class);
|
rsInsertBO.setAssessPlanId(updateParam.getId());
|
rsInsertBO.setId(updateParam.getRsId());
|
rsInsertBO.setIdentificationMethod(assessPlanById.getIdentificationMethod());
|
RsInsertDTO rsInsertDTO = rsService.updateRs(currentUserId, rsInsertBO);
|
if (ObjectUtils.isEmpty(rsInsertDTO)){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "写入评价结果失败");
|
}
|
factorQueryDTO = BeanCopyUtils.copyBean(rsInsertDTO, FactorQueryDTO.class);
|
factorQueryDTO.setRsId(rsInsertDTO.getId());
|
factorQueryDTO.setEvaluateMethod(assessPlanById.getEvaluateMethod());
|
}
|
|
RiskAssessPlanAppEvaluateBO evaluateParam = BeanCopyUtils.copyBean(updateReqBO, RiskAssessPlanAppEvaluateBO.class);
|
//处理评估计划表
|
AssessPlanEvaluateDTO evaluateResult = assessPlanService.evaluateUpdate(currentUserId, evaluateParam);
|
|
return factorQueryDTO;
|
}
|
|
/**
|
* 风险评估计划 - 评价删除
|
*/
|
@Override
|
public int deleteEvaluate(Long currentUserId, RiskAssessPlanEvaluateDeleteReqBO deleteReqBO) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
|
AssessPlanUpdateDTO deleteResult= assessPlanService.deleteEvaluate(currentUserId, deleteReqBO);
|
|
if (ObjectUtils.isEmpty(deleteResult)){
|
return StatusEnum.FAIL.getCode();
|
}
|
return StatusEnum.SUCCESS.getCode();
|
}
|
|
/**
|
* 风险评估计划 - 评价结果提交
|
*/
|
@Transactional
|
@Override
|
public int evaluateSubmit(Long currentUserId, Long id) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
|
//提交评价结果
|
AssessPlanUpdateDTO evaluateSubmitResult= assessPlanService.evaluateSubmit(currentUserId, id);
|
|
if (ObjectUtils.isEmpty(evaluateSubmitResult)){
|
return StatusEnum.FAIL.getCode();
|
}
|
return StatusEnum.SUCCESS.getCode();
|
}
|
|
/**
|
* 风险辨识与评价 - 查询
|
*/
|
@Override
|
public SearchResult selectAssessPage(Long currentUserId, RiskAssessQueryReqBO queryReqBO) {
|
|
SearchResult searchResult = new SearchResult<>();
|
|
RiskAssessAppQueryBO queryBO = BeanCopyUtils.copyBean(queryReqBO, RiskAssessAppQueryBO.class);
|
|
SearchResult<RiskAssessAppQueryDTO> queryResult = assessPlanService.selectAssessPage(currentUserId, queryBO);
|
|
searchResult.setPageIndex(queryResult.getPageIndex());
|
searchResult.setPageSize(queryResult.getPageSize());
|
searchResult.setCount(queryResult.getCount());
|
searchResult.setTotal(queryResult.getTotal());
|
searchResult.setData(queryResult.getData());
|
|
return searchResult;
|
}
|
|
/**
|
* 实验风险单元 - 插入
|
*/
|
@Transactional
|
@Override
|
public int insertRiskUnit(Long currentUserId, RiskUnitInsertReqBO riskUnitInsertReqBO) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
int roleTag = 0;
|
UserInfoDomainDTO user = userDomainService.getUserById(currentUserId);
|
// for (SysUserRoleBindDomainDTO role : user.getRoles()) {
|
// if (role.getRoleId() == UserRoleEnum.USER_ROLE_4.getCode().byteValue()){
|
// roleTag = 1;
|
// }
|
// }
|
//20241107修改注释权限
|
// if (roleTag != 1){
|
// throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户不是管理人员，无权限添加");
|
// }
|
if (ObjectUtils.isEmpty(riskUnitInsertReqBO.getExperimentId())){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "所选实验不能为空");
|
}
|
ExperimentInfoDTO experimentById = experimentInfoService.getExperimentById(riskUnitInsertReqBO.getExperimentId());
|
|
if (ObjectUtils.isEmpty(experimentById)){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "所选实验不存在或实验已被删除");
|
}
|
if (ObjectUtils.isEmpty(riskUnitInsertReqBO.getLiabilityUserId())){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "责任人不能为空");
|
}
|
|
PersonQueryDTO basicExperimentPersonById = basicExperimentPersonService.getBasicExperimentPersonById(riskUnitInsertReqBO.getLiabilityUserId());
|
|
if (ObjectUtils.isEmpty(basicExperimentPersonById)){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "责任人不存在，或已被删除");
|
}
|
RiskUnitAppInsertBO insertParam = BeanCopyUtils.copyBean(riskUnitInsertReqBO, RiskUnitAppInsertBO.class);
|
|
RiskUnitInsertDTO riskUnitInsertDTO = riskUnitService.insertRiskUnit(currentUserId, insertParam);
|
|
if (ObjectUtils.isEmpty(riskUnitInsertDTO)){
|
return StatusEnum.FAIL.getCode();
|
}
|
return StatusEnum.SUCCESS.getCode();
|
}
|
|
/**
|
* 固有风险单元 - 插入
|
*/
|
@Override
|
public int insertInherentRiskUnit(Long currentUserId, InherentRiskUnitInsertReqBO insertReqBO) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
int roleTag = 0;
|
UserInfoDomainDTO user = userDomainService.getUserById(currentUserId);
|
for (SysUserRoleBindDomainDTO role : user.getRoles()) {
|
if (role.getRoleId() == UserRoleEnum.USER_ROLE_4.getCode().byteValue()){
|
roleTag = 1;
|
}
|
}
|
if (roleTag != 1){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户不是管理人员，无权限添加");
|
}
|
if (ObjectUtils.isEmpty(insertReqBO.getExperimentId())){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "所选实验不能为空，或实验已被删除");
|
}
|
ExperimentInfoDTO experimentById = experimentInfoService.getExperimentById(insertReqBO.getExperimentId());
|
|
if (ObjectUtils.isEmpty(experimentById)){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "所选实验不存在或实验已被删除");
|
}
|
RiskUnitBasicQueryDTO basicRiskUnitById = basicRiskUnitService.getBasicRiskUnitById(insertReqBO.getBasicRiskUnitId());
|
|
//封装插入需要的数据
|
InherentRiskUnitAppInsertBO insertParam = BeanCopyUtils.copyBean(basicRiskUnitById, InherentRiskUnitAppInsertBO.class);
|
insertParam.setExperimentId(insertReqBO.getExperimentId());
|
insertParam.setBasicRiskUnitId(basicRiskUnitById.getId());
|
|
RiskUnitInsertDTO riskUnitInsertDTO = riskUnitService.insertInherentRiskUnit(currentUserId, insertParam);
|
|
if (ObjectUtils.isEmpty(riskUnitInsertDTO)){
|
return StatusEnum.FAIL.getCode();
|
}
|
return StatusEnum.SUCCESS.getCode();
|
}
|
|
/**
|
* 风险单元 - 分页查询
|
*/
|
@Override
|
public SearchResult<RiskUnitAppQueryDTO> selectRiskUnitPage(Long currentUserId, RiskUnitQueryReqBO queryReqBO) {
|
|
SearchResult searchResult = new SearchResult<>();
|
|
RiskUnitAppQueryBO queryParam = BeanCopyUtils.copyBean(queryReqBO, RiskUnitAppQueryBO.class);
|
|
SearchResult<RiskUnitQueryDTO> queryResult = riskUnitService.selectRiskUnitPage(currentUserId, queryParam);
|
|
searchResult.setPageIndex(queryResult.getPageIndex());
|
searchResult.setPageSize(queryResult.getPageSize());
|
searchResult.setTotal(queryResult.getTotal());
|
searchResult.setData(BeanCopyUtils.copyExperimentRiskUnitAppQueryList(queryResult.getData(), RiskUnitBasicQueryDTO.class));
|
|
return searchResult;
|
}
|
|
/**
|
* 风险单元 - 修改
|
*/
|
@Override
|
public int updateRiskUnit(Long currentUserId, RiskUnitUpdateReqBO updateReqBO) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
int roleTag = 0;
|
UserInfoDomainDTO user = userDomainService.getUserById(currentUserId);
|
// for (SysUserRoleBindDomainDTO role : user.getRoles()) {
|
// if (role.getRoleId() == UserRoleEnum.USER_ROLE_4.getCode().byteValue()){
|
// roleTag = 1;
|
// }
|
// }
|
//20241107修改注释权限
|
// if (roleTag != 1){
|
// throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户不是管理人员，无权限修改");
|
// }
|
if (ObjectUtils.isEmpty(updateReqBO.getExperimentId())){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "所选实验不能为空，或实验已被删除");
|
}
|
ExperimentInfoDTO experimentById = experimentInfoService.getExperimentById(updateReqBO.getExperimentId());
|
|
if (ObjectUtils.isEmpty(experimentById)){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "所选实验不存在或实验已被删除");
|
}
|
if (ObjectUtils.isEmpty(updateReqBO.getLiabilityUserId())){
|
throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "责任人不能为空");
|
}
|
|
PersonQueryDTO basicExperimentPersonById = basicExperimentPersonService.getBasicExperimentPersonById(updateReqBO.getLiabilityUserId());
|
if (ObjectUtils.isEmpty(basicExperimentPersonById)){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "责任人不存在，或已被删除");
|
}
|
RiskUnitAppUpdateBO updateParam = BeanCopyUtils.copyBean(updateReqBO, RiskUnitAppUpdateBO.class);
|
|
RiskUnitInsertDTO riskUnitUpdateDTO = riskUnitService.updateRiskUnit(currentUserId, updateParam);
|
|
if (ObjectUtils.isEmpty(riskUnitUpdateDTO)){
|
return StatusEnum.FAIL.getCode();
|
}
|
return StatusEnum.SUCCESS.getCode();
|
}
|
|
/**
|
* 风险单元 - 删除
|
*/
|
@Override
|
public int deleteRiskUnit(Long currentUserId, Long id) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
RiskUnitQueryDTO riskUnitById = riskUnitService.getRiskUnitById(id);
|
if (ObjectUtils.isEmpty(riskUnitById)){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前要删除的实验不存在，或已被删除");
|
}
|
int roleTag = 0;
|
UserInfoDomainDTO user = userDomainService.getUserById(currentUserId);
|
//20241107注释
|
// for (SysUserRoleBindDomainDTO role : user.getRoles()) {
|
// if (role.getRoleId() == UserRoleEnum.USER_ROLE_4.getCode().byteValue()){
|
// roleTag = 1;
|
// }
|
// }
|
// if (roleTag != 1){
|
// throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户不是管理人员，无权限添加");
|
// }
|
RiskUnitDeleteDTO deleteResult = riskUnitService.deleteRiskUnit(currentUserId, id);
|
|
if (ObjectUtils.isEmpty(deleteResult)){
|
return StatusEnum.FAIL.getCode();
|
}
|
return StatusEnum.SUCCESS.getCode();
|
}
|
|
/**
|
* 基础风险单元管理 - 列表查询
|
*/
|
@Override
|
public SearchResult<RiskUnitListQueryRespDTO> listRiskUnit(Long currentUserId) {
|
|
SearchResult result = new SearchResult();
|
|
List<RiskUnitListAppQueryDTO> riskUnitListAppQueryDTOS = riskUnitService.listRiskUnit(currentUserId);
|
|
result.setData(BeanCopyUtils.copyBeanList(riskUnitListAppQueryDTOS, RiskUnitListQueryRespDTO.class));
|
result.setCount(riskUnitListAppQueryDTOS.size());
|
|
return result;
|
}
|
|
/**
|
* 风险单元 - 列表查询
|
*/
|
@Override
|
public SearchResult<RiskUnitListQueryRespDTO> listRiskUnitByExperiment(Long currentUserId, RiskUnitListReqBO reqBO) {
|
|
SearchResult result = new SearchResult();
|
|
List<RiskUnitListAppQueryDTO> riskUnitListAppQueryDTOS = riskUnitService.listRiskUnitByExperiment(currentUserId, reqBO);
|
|
result.setData(BeanCopyUtils.copyBeanList(riskUnitListAppQueryDTOS, RiskUnitListQueryRespDTO.class));
|
result.setCount(riskUnitListAppQueryDTOS.size());
|
|
return result;
|
}
|
|
/**
|
* 评估计划 - 列表查询
|
*/
|
@Override
|
public SearchResult<RiskAssessPlanListRespDTO> listAssessPlan() {
|
SearchResult result = new SearchResult();
|
Byte status = StatusEnum.PLAN_SELL.getCode().byteValue();
|
List<RiskAssessPlanListAppDTO> riskAssessPlanListAppDTO = assessPlanService.listAssessPlan(status);
|
|
result.setData(BeanCopyUtils.copyBeanList(riskAssessPlanListAppDTO, RiskAssessPlanListRespDTO.class));
|
result.setCount(riskAssessPlanListAppDTO.size());
|
|
return result;
|
}
|
|
/**
|
* 评估计划 - 风险值计算
|
*/
|
@Override
|
public BigDecimal riskValue(RiskValueReqBO valueReqBO) {
|
|
if (valueReqBO.getValue3() == null){
|
BigDecimal value = valueReqBO.getValue1().multiply(valueReqBO.getValue2());
|
return value;
|
}
|
|
BigDecimal value = valueReqBO.getValue1().multiply(valueReqBO.getValue2()).multiply(valueReqBO.getValue3());
|
|
return value;
|
}
|
|
/**
|
* 风险评估计划 - 辨识专家拒绝
|
*/
|
@Override
|
public AssessPlanUpdateDTO identificationRefuse(Long currentUserId, Long id) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
AssessPlanUpdateDTO assessPlanUpdateDTO = assessPlanService.identificationRefuse(currentUserId, id);
|
return assessPlanUpdateDTO;
|
}
|
|
/**
|
* 风险评估计划 - 评价专家拒绝
|
*/
|
@Override
|
public AssessPlanUpdateDTO evaluateRefuse(Long currentUserId, Long id) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
|
AssessPlanUpdateDTO assessPlanUpdateDTO = assessPlanService.evaluateRefuse(currentUserId, id);
|
return assessPlanUpdateDTO;
|
}
|
|
/**
|
* 风险评估计划 - 修改辨识方法
|
*/
|
@Override
|
public AssessPlanUpdateDTO identificationUpdateMethod(Long currentUserId, MethodUpdateReqDTO updateReqDTO) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
|
AssessPlanUpdateDTO assessPlanUpdateDTO = assessPlanService.identificationUpdateMethod(currentUserId, updateReqDTO);
|
|
return assessPlanUpdateDTO;
|
}
|
|
/**
|
* 风险评估计划 - 评价方法修改
|
*/
|
@Override
|
public AssessPlanUpdateDTO evaluateUpdateMethod(Long currentUserId, MethodUpdateReqDTO updateReqDTO) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
|
AssessPlanUpdateDTO assessPlanUpdateDTO = assessPlanService.evaluateUpdateMethod(currentUserId, updateReqDTO);
|
|
return assessPlanUpdateDTO;
|
}
|
/**
|
* 风险评估计划 - 重新指定专家
|
*/
|
@Override
|
public AssessPlanUpdateDTO appoint(Long currentUserId, AppointUserReBO appointUserReBO) {
|
|
if (currentUserId < 0){
|
throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "当前用户无效，请重新登录");
|
}
|
|
AssessPlanUpdateDTO assessPlanUpdateDTO = assessPlanService.appoint(currentUserId, appointUserReBO);
|
return assessPlanUpdateDTO;
|
}
|
|
}
|
