package com.gkhy.labRiskManage.domain.riskReport.service.impl;

import com.gkhy.labRiskManage.api.controller.riskReport.dto.repDto.*;
import com.gkhy.labRiskManage.application.riskReport.dto.bo.*;
import com.gkhy.labRiskManage.application.riskReport.dto.dto.RiskAssessAppQueryDTO;
import com.gkhy.labRiskManage.application.riskReport.dto.dto.RiskAssessAppQueryDTO_0223bak;
import com.gkhy.labRiskManage.application.riskReport.dto.dto.RiskAssessPlanListAppDTO;
import com.gkhy.labRiskManage.commons.domain.SearchResult;
import com.gkhy.labRiskManage.commons.enums.*;
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.entity.BasicRiskUnit;
import com.gkhy.labRiskManage.domain.basic.entity.BasicRiskUnitType;
import com.gkhy.labRiskManage.domain.basic.model.dto.RiskUnitUpdateDTO;
import com.gkhy.labRiskManage.domain.basic.service.BasicExperimentPersonService;
import com.gkhy.labRiskManage.domain.basic.service.BasicRiskUnitService;
import com.gkhy.labRiskManage.domain.basic.service.BasicRiskUnitTypeService;
import com.gkhy.labRiskManage.domain.experiment.model.dto.ExperimentInfoDTO;
import com.gkhy.labRiskManage.domain.experiment.service.ExperimentInfoService;
import com.gkhy.labRiskManage.domain.riskReport.entity.*;
import com.gkhy.labRiskManage.domain.riskReport.model.bo.*;
import com.gkhy.labRiskManage.domain.riskReport.model.dto.*;
import com.gkhy.labRiskManage.domain.riskReport.repository.jpa.RiskAssessPlanRepository;
import com.gkhy.labRiskManage.domain.riskReport.service.*;
import com.gkhy.labRiskManage.domain.riskReport.utils.EvaluateAndIdentificationUtils;
import com.gkhy.labRiskManage.domain.riskReport.utils.EvaluateCheckUtils;
import com.gkhy.labRiskManage.domain.riskReport.utils.GetRoleTagUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;

import javax.persistence.criteria.*;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;


/**
 * 风险评估计划
 */
@Service
public class RiskAssessPlanServiceImpl implements RiskAssessPlanService  {

    @Autowired
    private RiskAssessPlanRepository assessPlanRepository;
    @Autowired
    private RiskUnitService riskUnitService;
    @Autowired
    private ExperimentInfoService experimentInfoService;
    @Autowired
    private BasicExperimentPersonService personService;
    @Autowired
    private BasicRiskUnitTypeService riskUnitTypeService;
    @Autowired
    private BasicRiskUnitService basicRiskUnitService;

    @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;

    /**
     * 风险评估计划 - 插入
     */
    @Transactional
    @Override
    public PlanInsertDTO insertAssessPlan(Long currentUserId, RiskAssessPlanAppInsertBO insertParam) {

        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 ==0 ){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无权添加实验评估计划");
        }
        if (ObjectUtils.isEmpty(user)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户不存在或已被删除");
        }
        //参数校验
        if (ObjectUtils.isEmpty(insertParam)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请求参数为空");
        }
        if (ObjectUtils.isEmpty(insertParam.getRiskUnitId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险单元不能为空");
        }
        if (ObjectUtils.isEmpty(insertParam.getRiskType())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险单元类型不能为空");
        }
        RiskUnitQueryDTO riskUnitById = riskUnitService.getRiskUnitById(insertParam.getRiskUnitId());
        if (ObjectUtils.isEmpty(riskUnitById.getId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险单元不存在或已被删除");
        }
        List<RiskAssessPlan> assessPlanByUnitId = assessPlanRepository.getAssessPlanByUnitId(insertParam.getRiskUnitId());
        if (assessPlanByUnitId.size() >= 1){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "该单元已有评估计划");
        }
        ExperimentInfoDTO experimentById = experimentInfoService.getExperimentById(riskUnitById.getExperimentId());
        if (ObjectUtils.isEmpty(experimentById)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "实验不存在或已被删除");
        }
        if (experimentById.getStatus() == 1){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "实验未被批准，无法进行评估");
        }
        if (ObjectUtils.isEmpty(insertParam.getAssessPlanName())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评估计划名称不能为空");
        }
        RiskAssessPlan assessPlanByName = assessPlanRepository.getAssessPlanByName(insertParam.getAssessPlanName());
        if (!ObjectUtils.isEmpty(assessPlanByName)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "评估计划名称已被使用");
        }
        if (ObjectUtils.isEmpty(insertParam.getAssessStartTime())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评估开始时间不能为空");
        }
        if (ObjectUtils.isEmpty(insertParam.getAssessEndTime())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评估结束时间不能为空");
        }
        if (insertParam.getAssessEndTime().isBefore(insertParam.getAssessStartTime())){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "评估结束时间必须在评估开始时间之后");
        }
        //   计划制定人？
        if (ObjectUtils.isEmpty(insertParam.getPlanUserId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "计划制定人不能为空");
        }
        UserInfoDomainDTO planUser = userDomainService.getUserInfoByIdAndSellInfo(insertParam.getPlanUserId(),"计划指定人");
        if (ObjectUtils.isEmpty(planUser)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_DATA_NOT_EXISIST.getCode(), "计划制定人不存在或已被删除");
        }
        // 辨识专家
        if (ObjectUtils.isEmpty(insertParam.getIdentificationUserId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "辨识专家不能为空");
        }
        UserInfoDomainDTO identificationUser = userDomainService.getUserInfoByIdAndSellInfo(insertParam.getIdentificationUserId(), "辨识专家");
        if (ObjectUtils.isEmpty(identificationUser)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_DATA_NOT_EXISIST.getCode(), "辨识专家不存在或已被删除");
        }
        // 评价专家
        if (ObjectUtils.isEmpty(insertParam.getEvaluateUserId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评价专家不能为空");
        }
        UserInfoDomainDTO evaluateUser = userDomainService.getUserInfoByIdAndSellInfo(insertParam.getEvaluateUserId(), "评价专家");
        if (ObjectUtils.isEmpty(evaluateUser)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_DATA_NOT_EXISIST.getCode(), "评价专家不存在或已被删除");
        }

        BasicRiskUnitType riskUnitTypeById = riskUnitTypeService.getRiskUnitTypeById(riskUnitById.getRiskUnitTypeId());

        //参数接收到的封装
        RiskAssessPlan riskAssessPlan = BeanCopyUtils.copyBean(insertParam, RiskAssessPlan.class);

        //获取需要的参数
        LocalDateTime date = LocalDateTime.now();
        //  如果是实验风险，添加实验id
        if (insertParam.getRiskType() == StatusEnum.EXPERIMENT_RISK.getCode().byteValue()){
            riskAssessPlan.setExperimentId(riskUnitById.getExperimentId());//
        }
        riskAssessPlan.setCreateTime(date);
        riskAssessPlan.setUpdateTime(date);
        riskAssessPlan.setCreateByUserId(user.getId());
        riskAssessPlan.setUpdateByUserId(user.getId());
        riskAssessPlan.setDeleteStatus(StatusEnum.DELETE_NOT.getCode().byteValue());
        riskAssessPlan.setRiskType(riskUnitById.getRiskType());
        riskAssessPlan.setPlanSellStatus(StatusEnum.PLAN_SELL_NOT.getCode().byteValue());//计划未派发
        riskAssessPlan.setPlanExecStatus(StatusEnum.PLAN_EXEC_NOT_START.getCode().byteValue());//计划执行未开始（执行阶段）
//        riskAssessPlan.setPlanTimeStatus(StatusEnum.PLAN_STATUS_NOT_START.getCode().byteValue());//计划状态未开始
        riskAssessPlan.setIdentificationUserId(insertParam.getIdentificationUserId());//辨识专家id
        riskAssessPlan.setIdentificationUser(identificationUser.getRealName());//辨识专家
        riskAssessPlan.setEvaluateUserId(insertParam.getEvaluateUserId());//评价专家id
        riskAssessPlan.setEvaluateUser(evaluateUser.getRealName());//评价专家

        riskAssessPlan.setIdentificationMethod(MethodEnum.IDENTIFICATION_METHOD_PHA.getCode());//辨识方法
        riskAssessPlan.setEvaluateMethod(MethodEnum.EVALUATE_METHOD_LEC.getCode());//评价方法

        RiskAssessPlan saveResult = assessPlanRepository.save(riskAssessPlan);

        //修改实验状态为评估中
        ExperimentInfoDTO experimentInfoDTO = experimentInfoService.updateExperimentStage(experimentById.getId(), StatusEnum.EXPERIMENT_STATUS_START.getCode().byteValue());
        if (ObjectUtils.isEmpty(experimentInfoDTO)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_DATA_NOT_EXISIST.getCode(), "实验状态修改失败");
        }
        //修改风险单元为已有评估计划
        if (insertParam.getRiskType() == StatusEnum.EXPERIMENT_RISK.getCode().byteValue()){
            RiskUnit riskUnit = riskUnitService.updateRiskUnitStatus(insertParam.getRiskUnitId(), StatusEnum.EVALUATE_WAIT.getCode());
            if (ObjectUtils.isEmpty(riskUnit)){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_DATA_NOT_EXISIST.getCode(), "风险单元状态修改失败");
            }
        }else if (insertParam.getRiskType() == StatusEnum.INHERENT_RISK.getCode().byteValue()){
            RiskUnitUpdateDTO riskUnitUpdateDTO = basicRiskUnitService.updateRiskUnitStatus(insertParam.getRiskUnitId(), StatusEnum.EVALUATE_WAIT.getCode());
            if (ObjectUtils.isEmpty(riskUnitUpdateDTO)){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_DATA_NOT_EXISIST.getCode(), "风险单元状态修改失败");
            }
        }


        PlanInsertDTO planInsertDTO = BeanCopyUtils.copyBean(saveResult, PlanInsertDTO.class);

        return planInsertDTO;
    }

    /**
     * 风险评估计划 - 查询
     */
    @Override
    public SearchResult<AssessPlanQueryDTO> selectAssessPlanPage(Long currentUserId, RiskAssessPlanAppQueryBO queryParamBO) {


        //校验参数
        if (ObjectUtils.isEmpty(queryParamBO.getPageSize())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode() ,"分页信息不能为空");
        }
        if (ObjectUtils.isEmpty(queryParamBO.getPageIndex())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode() ,"分页信息不能为空");
        }
        if (queryParamBO.getRiskUnitName() == "null"){
            queryParamBO.setRiskUnitName(null);
        }
        if (queryParamBO.getAssessPlanName() == "null"){
            queryParamBO.setAssessPlanName(null);
        }
        // 检查是否是实验管理者
        UserInfoDomainDTO user = userDomainService.getUserById(currentUserId);
        if (ObjectUtils.isEmpty(user)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode() ,"用户不存在");
        }
        int roleTag = GetRoleTagUtils.GetRoleTagUtils(user);

        List<Long> ids = new ArrayList<>();
        if (!ObjectUtils.isEmpty(queryParamBO.getRiskUnitName())){
            List<RiskUnitQueryDTO> riskUnitList= riskUnitService.getRiskUnitByName(queryParamBO.getRiskUnitName());
            if (riskUnitList.size() < 1){
                throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险单元不存在或已被删除");
            }
            for (RiskUnitQueryDTO riskUnit : riskUnitList) {
                ids.add(riskUnit.getId());
            }
        }

        List<ExperimentInfoDTO> experimentByList = experimentInfoService.getExperimentByUser(currentUserId);

        List<Long> experimentIdList = new ArrayList<>();
        experimentIdList.add(0L);
        if (!ObjectUtils.isEmpty(experimentByList)){
            for (ExperimentInfoDTO experimentInfo : experimentByList) {
                experimentIdList.add(experimentInfo.getId());
            }
        }

        RiskAssessPlanQueryBO  queryParam = BeanCopyUtils.copyBean(queryParamBO, RiskAssessPlanQueryBO.class);
        queryParam.setRiskUnitIds(ids);
        SearchResult searchResult = new SearchResult<>();
        searchResult.setPageIndex(queryParam.getPageIndex());
        searchResult.setPageSize(queryParam.getPageSize());


        //封装查询参数
        Specification<RiskAssessPlan> specification = new Specification<RiskAssessPlan>() {
            @Override
            public Predicate toPredicate(Root<RiskAssessPlan> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
                List<Predicate> predicateList = new ArrayList<>();
                if (queryParam.getAssessPlanName() != null && !queryParam.getAssessPlanName().equals("")){
                    predicateList.add(criteriaBuilder.like(root.get("assessPlanName"),"%"+queryParam.getAssessPlanName()+"%"));
                }
                //in
                if (queryParam.getRiskUnitIds().size() >= 1){
                    predicateList.add(criteriaBuilder.in(root.get("riskUnitId")).value(ids));
                }
                if (queryParam.getExperimentId() != null){
                    predicateList.add(criteriaBuilder.equal(root.get("experimentId"),queryParam.getExperimentId()));
                }
                if (roleTag == UserTagEnum.USER_TAG_0.getCode()){
                    //此处应有谁能查询：辨识专家，评价专家,实验负责人(此处未存相关信息，以实验id为条件查询)
                    predicateList.add(criteriaBuilder.or(
                            criteriaBuilder.equal(root.get("identificationUserId"), currentUserId),
                            criteriaBuilder.equal(root.get("evaluateUserId"), currentUserId),
                            criteriaBuilder.in(root.get("experimentId")).value(experimentIdList)
                            )
                    );
                }
                predicateList.add(criteriaBuilder.equal(root.get("deleteStatus"),StatusEnum.DELETE_NOT.getCode()));
                return criteriaBuilder.and(predicateList.toArray(new Predicate[0]));
            }
        };

        PageRequest pageParam = PageRequest.of(queryParam.getPageIndex() - 1, queryParam.getPageSize(), Sort.Direction.DESC, "updateTime");
        Page<RiskAssessPlan> pageResult = assessPlanRepository.findAll(specification, pageParam);

        List<RiskAssessPlanQueryDTO> assessPlanQueryDTOS = BeanCopyUtils.copyBeanList(pageResult.getContent(), RiskAssessPlanQueryDTO.class);

        List<RiskUnitListAppQueryDTO> riskUnitListAppQueryDTOS = riskUnitService.listAssessRiskUnit();

        List<UserInfoDomainDTO> userList = userDomainService.getUserList();
        for (RiskAssessPlanQueryDTO assessPlanQueryDTO : assessPlanQueryDTOS) {
            for (UserInfoDomainDTO userInfo : userList) {
                if (userInfo.getId() == assessPlanQueryDTO.getCreateByUserId()){
                    assessPlanQueryDTO.setCreateByUserName(userInfo.getRealName());
                }
                if (userInfo.getId() == assessPlanQueryDTO.getUpdateByUserId()){
                    assessPlanQueryDTO.setUpdateByUserName(userInfo.getRealName());
                }
                if (userInfo.getId() == assessPlanQueryDTO.getPlanUserId()){
                    assessPlanQueryDTO.setPlanUserName(userInfo.getRealName());
                }
            }
            for (RiskUnitListAppQueryDTO riskUnit : riskUnitListAppQueryDTOS) {
                if (riskUnit.getId() == assessPlanQueryDTO.getRiskUnitId()){
                    assessPlanQueryDTO.setRiskUnitName(riskUnit.getRiskName());
                }
            }
        }

        searchResult.setData(assessPlanQueryDTOS);
        searchResult.setTotal(pageResult.getTotalElements());
        return searchResult;
    }

    /**
     * 风险评估计划 - 修改
     */
    @Override
    public AssessPlanUpdateDTO updateAssessPlan(Long currentUserId, RiskAssessPlanUpdateReqBO updateParam) {


        if (currentUserId < 0){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无效，请重新登陆");
        }
        UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
        if (ObjectUtils.isEmpty(userInfoById)){
            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 ==0 ){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无权修改实验评估计划");
        }
        //参数校验
        if (ObjectUtils.isEmpty(updateParam)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "要求改的参数为空");
        }
        RiskAssessPlan assessPlanById = assessPlanRepository.getAssessPlanById(updateParam.getId());
        if (assessPlanById.getPlanSellStatus() == 2){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "该计划已经派发,无法修改");
        }
        if (ObjectUtils.isEmpty(assessPlanById)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评估计划不存在或已被删除");
        }
        if (ObjectUtils.isEmpty(updateParam.getRiskUnitId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险单元参数不能为空");
        }
        if (ObjectUtils.isEmpty(updateParam.getAssessStartTime())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评估开始时间不能为空");
        }
        if (ObjectUtils.isEmpty(updateParam.getAssessEndTime())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评估结束时间不能为空");
        }
        if (updateParam.getAssessEndTime().isBefore(updateParam.getAssessStartTime())){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "评估结束时间必须在评估开始时间之后");
        }
        RiskUnitQueryDTO riskUnitById = riskUnitService.getRiskUnitById(updateParam.getRiskUnitId());
        if (ObjectUtils.isEmpty(riskUnitById.getId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险单元不存在或已被删除");
        }
        ExperimentInfoDTO experimentById = experimentInfoService.getExperimentById(riskUnitById.getExperimentId());
        if (ObjectUtils.isEmpty(experimentById)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "实验不存在或已被删除");
        }

        if (ObjectUtils.isEmpty(updateParam.getAssessPlanName())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评估计划名称不能为空");
        }
        RiskAssessPlan assessPlanByName = assessPlanRepository.getAssessPlanByName(updateParam.getAssessPlanName());
        if (!ObjectUtils.isEmpty(assessPlanByName) && !assessPlanByName.getId().equals(updateParam.getId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评估计划已存在，请换一个计划名称");
        }
        // 计划制定人
        if (ObjectUtils.isEmpty(updateParam.getPlanUserId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "计划制定人不能为空");
        }
        UserInfoDomainDTO planUser = userDomainService.getUserInfoByIdAndSellInfo(updateParam.getPlanUserId(), "计划制定人");
        if (ObjectUtils.isEmpty(planUser)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_DATA_NOT_EXISIST.getCode(), "计划制定人不存在或已被删除");
        }
        // 辨识专家
        if (ObjectUtils.isEmpty(updateParam.getIdentificationUserId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "辨识专家不能为空");
        }
        UserInfoDomainDTO identificationUser = userDomainService.getUserInfoByIdAndSellInfo(updateParam.getIdentificationUserId(), "辨识专家");
        if (ObjectUtils.isEmpty(identificationUser)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_DATA_NOT_EXISIST.getCode(), "辨识专家不存在或已被删除");
        }
        // 评价专家
        if (ObjectUtils.isEmpty(updateParam.getEvaluateUserId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评价专家不能为空");
        }
        UserInfoDomainDTO evaluateUser = userDomainService.getUserInfoByIdAndSellInfo(updateParam.getEvaluateUserId(), "评价专家");
        if (ObjectUtils.isEmpty(evaluateUser)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_DATA_NOT_EXISIST.getCode(), "评价专家不存在或已被删除");
        }

        //获取需要的参数
        LocalDateTime date = LocalDateTime.now();

        assessPlanById.setUpdateTime(date);
        assessPlanById.setUpdateByUserId(userInfoById.getId());
        assessPlanById.setRiskUnitId(updateParam.getRiskUnitId());
        assessPlanById.setAssessPlanName(updateParam.getAssessPlanName());
        assessPlanById.setPlanUserId(updateParam.getPlanUserId());
        assessPlanById.setAssessStartTime(updateParam.getAssessStartTime());
        assessPlanById.setAssessEndTime(updateParam.getAssessEndTime());
//        assessPlanById.setIdentificationMethod(updateParam.getIdentificationMethod());//辨识方法
        assessPlanById.setIdentificationUserId(updateParam.getIdentificationUserId());//辨识专家id
        assessPlanById.setIdentificationUser(identificationUser.getRealName());//辨识专家
//        assessPlanById.setEvaluateMethod(updateParam.getEvaluateMethod());//评价方法
        assessPlanById.setEvaluateUserId(updateParam.getEvaluateUserId());//评价专家id
        assessPlanById.setEvaluateUser(evaluateUser.getRealName());//评价专家


        RiskAssessPlan saveResult = assessPlanRepository.save(assessPlanById);

        AssessPlanUpdateDTO planUpdateDTO = BeanCopyUtils.copyBean(saveResult, AssessPlanUpdateDTO.class);

        return planUpdateDTO;
    }

    /**
     * 风险评估计划 - 删除
     */
    @Override
    public AssessPlanDeleteDTO deleteAssessPlan(Long currentUserId, Long id) {

        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 ==0 ){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无权删除实验评估计划");
        }
        UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
        if (ObjectUtils.isEmpty(userInfoById)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户不存在或已被删除");
        }
        if (ObjectUtils.isEmpty(id)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "删除的内容不能为空");
        }
        RiskAssessPlan assessPlanById = assessPlanRepository.getAssessPlanById(id);
        if (ObjectUtils.isEmpty(assessPlanById)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "删除的内容不存在或已被删除");
        }
        if (assessPlanById.getPlanSellStatus() == 2){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "该计划已经派发，无法删除");
        }
        //设置必要参数
        LocalDateTime date = LocalDateTime.now();

        RiskAssessPlan riskAssessPlan = BeanCopyUtils.copyBean(assessPlanById, RiskAssessPlan.class);

        riskAssessPlan.setUpdateTime(date);
        riskAssessPlan.setUpdateByUserId(userInfoById.getId());
        riskAssessPlan.setDeleteStatus(StatusEnum.DELETED.getCode().byteValue());

        RiskAssessPlan deleteResult = assessPlanRepository.save(riskAssessPlan);

        return BeanCopyUtils.copyBean(deleteResult, AssessPlanDeleteDTO.class);
    }

    /**
     * 风险评估计划 - 派发任务
     */
    @Override
    public AssessPlanUpdateDTO sellAssessPlan(Long currentUserId, Long id) {

        if (currentUserId < 0){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无效，请重新登陆");
        }
        UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
        if (ObjectUtils.isEmpty(userInfoById)){
            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 ==0 ){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无权派发任务");
        }
        LocalDateTime date = LocalDateTime.now();

        if (ObjectUtils.isEmpty(id)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "选择的内容不能为空");
        }
        RiskAssessPlan assessPlanById = assessPlanRepository.getAssessPlanById(id);
        if (ObjectUtils.isEmpty(assessPlanById)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "要派发的计划不存在或已被删除");
        }
        if (assessPlanById.getPlanSellStatus() == 2){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "该计划已经派发");
        }
        if (assessPlanById.getAssessEndTime().isBefore(date)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "任务派发必须在评估结束时间之前");
        }
//        if (!assessPlanById.getPlanUserId().equals(userInfoById.getId())){
//            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "您不是计划制定人，无法进行任务派发");
//        }
        //设置必要参数
        RiskAssessPlan riskAssessPlan = BeanCopyUtils.copyBean(assessPlanById, RiskAssessPlan.class);

        riskAssessPlan.setPlanSellTime(date);
        riskAssessPlan.setPlanSellStatus(StatusEnum.PLAN_SELL.getCode().byteValue());
        riskAssessPlan.setPlanExecStatus(StatusEnum.PLAN_EXEC_IDENTIFICATION.getCode().byteValue());//辨识阶段

        RiskAssessPlan sellResult = assessPlanRepository.save(riskAssessPlan);

        return BeanCopyUtils.copyBean(sellResult, AssessPlanUpdateDTO.class);
    }

    /**
     * 风险评估计划 - 辨识
     */
    @Override
    public AssessPlanIdentificationDTO identification(Long currentUserId, RiskAssessPlanAppIdentificationBO identificationParam) {

        if (currentUserId < 0){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无效，请重新登陆");
        }
        UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
        if (ObjectUtils.isEmpty(userInfoById)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户不存在或已被删除");
        }
        LocalDateTime date = LocalDateTime.now();

        if (ObjectUtils.isEmpty(identificationParam)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "辨识的内容不能为空");
        }
        if (ObjectUtils.isEmpty(identificationParam.getIdentificationMethod())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "选择的辨识方法不存在");
        }
//        if (ObjectUtils.isEmpty(identificationParam.getManageMeasure())){
//            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "管理措施不能为空");
//        }
//        if (ObjectUtils.isEmpty(identificationParam.getEducationMeasure())){
//            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "教育措施不能为空");
//        }
//        if (ObjectUtils.isEmpty(identificationParam.getPersonalProtectionMeasure())){
//            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "个体防护措施不能为空");
//        }
//        if (ObjectUtils.isEmpty(identificationParam.getEmergencyMeasure())){
//            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "应急措施不能为空");
//        }
//        if (ObjectUtils.isEmpty(identificationParam.getTechnologyMeasure())){
//            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "技术措施不能为空");
//        }

        RiskAssessPlan assessPlanById = assessPlanRepository.getAssessPlanById(identificationParam.getId());
        if (ObjectUtils.isEmpty(assessPlanById)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "要辨识的计划不存在或已被删除");
        }
        if (!assessPlanById.getIdentificationUserId().equals(currentUserId)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"不是辨识专家，无法操作");
        }
        if (assessPlanById.getPlanSellStatus() == 1){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "该计划尚未派发，无法辨识");
        }
        if (assessPlanById.getPlanExecStatus() != 2){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "该计划不处在辨识阶段，无法辨识");
        }
        if (date.isAfter(assessPlanById.getAssessEndTime())){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "风险辨识必须在评估结束时间之前");
        }
        if (date.isBefore(assessPlanById.getAssessStartTime())){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "未到辨识时间");
        }
        if (!assessPlanById.getIdentificationUserId().equals(userInfoById.getId())){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "您不是辨识人，无法进行辨识");
        }

        //设置必要参数
        RiskAssessPlan riskAssessPlan = BeanCopyUtils.copyBean(assessPlanById, RiskAssessPlan.class);

        riskAssessPlan.setIdentificationTime(date);
        riskAssessPlan.setTechnologyMeasure(null);
        riskAssessPlan.setManageMeasure(null);
        riskAssessPlan.setEducationMeasure(null);
        riskAssessPlan.setPersonalProtectionMeasure(null);
        riskAssessPlan.setEmergencyMeasure(null);
        riskAssessPlan.setIdentificationMethod(identificationParam.getIdentificationMethod());

        riskAssessPlan.setPlanExecStatus(StatusEnum.PLAN_EXEC_IDENTIFICATION.getCode().byteValue());//辨识阶段
//        riskAssessPlan.setPlanTimeStatus(StatusEnum.PLAN_STATUS_START.getCode().byteValue());//计划状态未开始

        RiskAssessPlan identificationResult = assessPlanRepository.save(riskAssessPlan);

        return BeanCopyUtils.copyBean(identificationResult, AssessPlanIdentificationDTO.class);
    }

    /**
     * 风险评估计划 - 辨识结果提交
     */
    @Override
    public AssessPlanUpdateDTO identificationSubmit(Long currentUserId, Long id) {

        if (currentUserId < 0){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无效，请重新登陆");
        }
        UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
        if (ObjectUtils.isEmpty(userInfoById)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户不存在或已被删除");
        }
        if (ObjectUtils.isEmpty(id)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "所选辨识不能为空");
        }
        RiskAssessPlan assessPlanById = assessPlanRepository.getAssessPlanById(id);
        if (ObjectUtils.isEmpty(assessPlanById)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "所选辨识为空或已被删除");
        }
        if (assessPlanById.getPlanExecStatus() < StatusEnum.PLAN_EXEC_IDENTIFICATION.getCode().byteValue()){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "不在辨识阶段，无法提交");
        }else if (assessPlanById.getPlanExecStatus() > StatusEnum.PLAN_EXEC_IDENTIFICATION.getCode().byteValue()){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "辨识已完成，无需重复提交");
        }
        if (!assessPlanById.getIdentificationUserId().equals(userInfoById.getId())){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "您不是辨识人，无法进行辨识结果提交");
        }
        // 没有进行任何辨识，无法提交
        if (assessPlanById.getIdentificationMethod() == 1){
            List<PhaQueryDTO> phaQueryDTOS = phaService.listPhaByPlanId(assessPlanById.getId());
            if (phaQueryDTOS.size() < 1){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "您未做任何辨识，无法提交");
            }
            //辨识方法 2-JHA；
        }else if (assessPlanById.getIdentificationMethod() == 2){
            List<JhaQueryDTO> jhaQueryDTOS = jhaService.listJhaByPlanId(assessPlanById.getId());
            if (jhaQueryDTOS.size() < 1){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "您未做任何辨识，无法提交");
            }
            //辨识方法 3-SCL；
        }else if (assessPlanById.getIdentificationMethod() == 3){
            List<SclQueryDTO> sclQueryDTOS = sclService.listSclByPlanId(assessPlanById.getId());
            if (sclQueryDTOS.size() < 1){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "您未做任何辨识，无法提交");
            }
            //辨识方法 4-HAZOP；
        }else if (assessPlanById.getIdentificationMethod() == 4){
            List<HazopQueryDTO> hazopQueryDTOS = hazopService.listHazopByPlanId(assessPlanById.getId());
            if (hazopQueryDTOS.size() < 1){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "您未做任何辨识，无法提交");
            }
            //5-类比法 analogy；
        }else if (assessPlanById.getIdentificationMethod() == 5){
            List<AnalogyQueryDTO> analogyQueryDTOS = analogyService.listAnalogyByPlanId(assessPlanById.getId());
            if (analogyQueryDTOS.size() < 1){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode(), "您未做任何辨识，无法提交");
            }
        }else {
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode(), "辨识方法参数错误");
        }

        assessPlanById.setIdentificationTime(LocalDateTime.now());
        assessPlanById.setPlanExecStatus(StatusEnum.PLAN_EXEC_EVALUATE.getCode().byteValue());//提交后，进入评价阶段

        RiskAssessPlan submitResult = assessPlanRepository.save(assessPlanById);

        return BeanCopyUtils.copyBean(submitResult, AssessPlanUpdateDTO.class);
    }

    /**
     * 风险评估计划 - 评价
     */
    @Override
    public AssessPlanEvaluateDTO evaluate(Long currentUserId, RiskAssessPlanAppEvaluateBO evaluateParam) {

        if (currentUserId < 0){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无效，请重新登陆");
        }
        UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
        if (ObjectUtils.isEmpty(userInfoById)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户不存在或已被删除");
        }
        LocalDateTime date = LocalDateTime.now();

        if (ObjectUtils.isEmpty(evaluateParam)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评价的内容不能为空");
        }
        if (ObjectUtils.isEmpty(evaluateParam.getRiskValue())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险数值不能为空");
        }
        if (ObjectUtils.isEmpty(evaluateParam.getRiskLevelValue())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险等级值不能为空");
        }
        if (ObjectUtils.isEmpty(evaluateParam.getRiskLevel())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险级别不能为空");
        }
        if (ObjectUtils.isEmpty(evaluateParam.getRiskColor())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险色不能为空");
        }
        if (ObjectUtils.isEmpty(evaluateParam.getManageLevel())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "管理层级不能为空");
        }

        RiskAssessPlan assessPlanById = assessPlanRepository.getAssessPlanById(evaluateParam.getId());
        if (ObjectUtils.isEmpty(assessPlanById)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "要评价的计划不存在或已被删除");
        }
        if (assessPlanById.getPlanSellStatus() == 1){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "该计划尚未派发，无法辨识");
        }
        if (assessPlanById.getPlanExecStatus() != 3){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "该计划不处待评价阶段，无法评价");
        }
        if (assessPlanById.getAssessEndTime().isBefore(date)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "风险评价必须在评估结束时间之前");
        }
        if (!assessPlanById.getEvaluateUserId().equals(userInfoById.getId())){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "您不是评价人，无法进行评价");
        }
        //设置必要参数
        RiskAssessPlan riskAssessPlan = BeanCopyUtils.copyBean(assessPlanById, RiskAssessPlan.class);

        riskAssessPlan.setEvaluateTime(date);
        riskAssessPlan.setRiskValue(null);
        riskAssessPlan.setRiskLevelValue(null);
        riskAssessPlan.setRiskLevel(null);
        riskAssessPlan.setRiskColor(null);
        riskAssessPlan.setManageLevel(null);

        riskAssessPlan.setPlanExecStatus(StatusEnum.PLAN_EXEC_EVALUATE.getCode().byteValue());//评价阶段

        RiskAssessPlan evaluateResult = assessPlanRepository.save(riskAssessPlan);

        return BeanCopyUtils.copyBean(evaluateResult, AssessPlanEvaluateDTO.class);
    }

    /**
     * 风险评估计划 - 评价修改
     */
    @Override
    public AssessPlanEvaluateDTO evaluateUpdate(Long currentUserId, RiskAssessPlanAppEvaluateBO evaluateParam) {

        if (currentUserId < 0){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无效，请重新登陆");
        }
        UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
        if (ObjectUtils.isEmpty(userInfoById)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户不存在或已被删除");
        }
        LocalDateTime date = LocalDateTime.now();

        if (ObjectUtils.isEmpty(evaluateParam)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评价的内容不能为空");
        }
        if (ObjectUtils.isEmpty(evaluateParam.getRiskValue())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险数值不能为空");
        }
        if (ObjectUtils.isEmpty(evaluateParam.getRiskLevelValue())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险等级值不能为空");
        }
        if (ObjectUtils.isEmpty(evaluateParam.getRiskLevel())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险级别不能为空");
        }
        if (ObjectUtils.isEmpty(evaluateParam.getRiskColor())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "风险色不能为空");
        }
        if (ObjectUtils.isEmpty(evaluateParam.getManageLevel())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "管理层级不能为空");
        }

        RiskAssessPlan assessPlanById = assessPlanRepository.getAssessPlanById(evaluateParam.getId());
        if (ObjectUtils.isEmpty(assessPlanById)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "要评价的计划不存在或已被删除");
        }
        if (assessPlanById.getPlanSellStatus() == 1){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "该计划尚未派发，无法辨识");
        }
        if (assessPlanById.getPlanExecStatus() != 3){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "该计划不处待评价阶段，无法评价");
        }
        if (assessPlanById.getAssessEndTime().isBefore(date)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "风险评价必须在评估结束时间之前");
        }
        if (!assessPlanById.getEvaluateUserId().equals(userInfoById.getId())){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "您不是评价人，无法进行评价");
        }
        //设置必要参数
        RiskAssessPlan riskAssessPlan = BeanCopyUtils.copyBean(assessPlanById, RiskAssessPlan.class);

        riskAssessPlan.setEvaluateTime(date);
        riskAssessPlan.setRiskValue(null);
        riskAssessPlan.setRiskLevelValue(null);
        riskAssessPlan.setRiskLevel(null);
        riskAssessPlan.setRiskColor(null);
        riskAssessPlan.setManageLevel(null);

        RiskAssessPlan evaluateResult = assessPlanRepository.save(riskAssessPlan);

        return BeanCopyUtils.copyBean(evaluateResult, AssessPlanEvaluateDTO.class);
    }

    /**
     * 风险评估计划 - 评价结果提交
     */
    @Transactional
    @Override
    public AssessPlanUpdateDTO evaluateSubmit(Long currentUserId, Long id) {

        if (currentUserId < 0){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无效，请重新登陆");
        }
        UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
        if (ObjectUtils.isEmpty(userInfoById)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户不存在或已被删除");
        }
        if (ObjectUtils.isEmpty(id)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "所选评价不能为空");
        }
        RiskAssessPlan assessPlanById = assessPlanRepository.getAssessPlanById(id);
        if (ObjectUtils.isEmpty(assessPlanById)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "所选评价为空或已被删除");
        }
        if (assessPlanById.getPlanExecStatus() < StatusEnum.PLAN_EXEC_EVALUATE.getCode().byteValue()){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "不在评价阶段，无法提交");
        }else if (assessPlanById.getPlanExecStatus() > StatusEnum.PLAN_EXEC_EVALUATE.getCode().byteValue()){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评价已完成，无需重复提交");
        }
        if (!assessPlanById.getEvaluateUserId().equals(userInfoById.getId())){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "您不是评价人，无法进行评价结果提交");
        }
//        ExecStatusSubmitBO execStatusSubmitBO = new ExecStatusSubmitBO();
//        execStatusSubmitBO.setId(id);
//        execStatusSubmitBO.setPlanExecStatus(StatusEnum.PLAN_EXEC_OVER.getCode().byteValue());//评价提交后，评估结束
//
//        RiskAssessPlan submitResult = assessPlanRepository.execStatusSubmit(execStatusSubmitBO);

        assessPlanById.setPlanExecStatus(StatusEnum.PLAN_EXEC_OVER.getCode().byteValue());
        assessPlanById.setEvaluateTime(LocalDateTime.now());
        //修改风险单元评价状态
        RiskUnit riskUnit = riskUnitService.updateRiskUnitStatus(assessPlanById.getRiskUnitId(),StatusEnum.EVALUATE.getCode());
        if (ObjectUtils.isEmpty(riskUnit)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "修改风险单元状态失败");
        }

        //  1-检查该计划的所有辨识项，是否全部完成评价，否则无法提交
        int result = EvaluateCheckUtils.evaluateCheckUtils(assessPlanById);
        if (result == 1){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "有辨识项未评价，无法提交");
        }

        // 2 - 该实验所有的评估计划，是否都是已编写 评估完成
        List<RiskAssessPlan> assessPlanByExperimentId = assessPlanRepository.getAssessPlanByExperimentId(assessPlanById.getExperimentId());
        int tag = 0;
        for (RiskAssessPlan riskAssessPlan : assessPlanByExperimentId) {
            // todo - 之前检查使用评价计划的status，存在编写完但未提交的计划。 先加上评估计划执行状态判断。   --- 需要测试是否能避免问题
            if (assessPlanById.getPlanExecStatus() != StatusEnum.PLAN_EXEC_OVER.getCode().byteValue()){
                tag = 1;
            }
            if (assessPlanById.getEvaluateMethod() == 1){
                List<LecQueryDTO> lecQueryDTOS = lecService.listLecByPlanId(riskAssessPlan.getId());
                for (LecQueryDTO lec : lecQueryDTOS) {
                    if (lec.getStatus() != 1){
                        tag = 1;
                    }
                }
                //辨识方法2 - LS
            }else if (assessPlanById.getEvaluateMethod() == 2){
                List<LsQueryDTO> lsQueryDTOS = lsService.listLsByPlanId(riskAssessPlan.getId());
                for (LsQueryDTO ls : lsQueryDTOS) {
                    if (ls.getStatus() != 1){
                        tag = 1;
                    }
                }
                //辨识方法3 - MES
            }else if (assessPlanById.getEvaluateMethod() == 3){
                List<MesQueryDTO> mesQueryDTOS = mesService.listMesByPlanId(riskAssessPlan.getId());
                for (MesQueryDTO mes : mesQueryDTOS) {
                    if (mes.getStatus() != 1){
                        tag = 1;
                    }
                }
                //辨识方法4 - RS
            }else if (assessPlanById.getEvaluateMethod() == 4){
                List<RsQueryDTO> rsQueryDTOS = rsService.listRsByPlanId(riskAssessPlan.getId());
                for (RsQueryDTO rs : rsQueryDTOS) {
                    if (rs.getStatus() != 1){
                        tag = 1;
                    }
                }
            }
        }
        //所有评估计划完成，设置实验为评估完成状态。
        if (tag == 0){
            //修改实验 为 评估完成
            ExperimentInfoDTO experimentInfoDTO = experimentInfoService.updateExperimentStage(assessPlanById.getExperimentId(), StatusEnum.EXPERIMENT_STATUS_FINISH.getCode().byteValue());
            if (ObjectUtils.isEmpty(experimentInfoDTO)){
                throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode() ,"实验状态修改失败");
            }
        }

        RiskAssessPlan submitResult = assessPlanRepository.save(assessPlanById);

        return BeanCopyUtils.copyBean(submitResult, AssessPlanUpdateDTO.class);
    }

    /**
     * 风险辨识与评价 - 查询
     */
    @Transactional
    @Override
    public SearchResult<RiskAssessAppQueryDTO> selectAssessPage(Long currentUserId, RiskAssessAppQueryBO queryBO) {

        //校验参数
        if (ObjectUtils.isEmpty(queryBO.getPageSize())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode() ,"分页信息不能为空");
        }
        if (ObjectUtils.isEmpty(queryBO.getPageIndex())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode() ,"分页信息不能为空");
        }
        // 检查是否是实验管理者
        UserInfoDomainDTO userInfo = userDomainService.getUserById(currentUserId);
        if (ObjectUtils.isEmpty(userInfo)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode() ,"用户不存在");
        }
        if (queryBO.getAssessPlanName() == "null"){
            queryBO.setAssessPlanName(null);
        }
        if (queryBO.getExperimentName() == "null"){
            queryBO.setExperimentName(null);
        }

        AssessQueryBO queryParam = BeanCopyUtils.copyBean(queryBO, AssessQueryBO.class);
        if (!ObjectUtils.isEmpty(queryBO.getExperimentName())){
            ExperimentInfoDTO experimentByName = experimentInfoService.getExperimentByName(queryBO.getExperimentName());
            if (ObjectUtils.isEmpty(experimentByName)){
                throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode() ,"分页信息不能为空");
            }
            queryParam.setExperimentId(experimentByName.getId());
        }
        // 拿到所有的固有风险单元 ，遍历
        List<Long> planIds = new ArrayList<>();
        List<RiskUnit> riskUnits = riskUnitService.listInherentRiskUnit();
        if (ObjectUtils.isEmpty(riskUnits)){
            for (RiskUnit riskUnit : riskUnits) {
                // 拿到所有固有风险的评估计划
                List<RiskAssessPlan> assessPlanByInherentUnit = assessPlanRepository.getAssessPlanByInherentUnit(riskUnit.getBasicRiskUnitId());
                if (assessPlanByInherentUnit.size() > 0){
                    // 遍历固有风险评估计划，如果当前用户属于对应实验的负责人，新增，修改人
                    for (RiskAssessPlan inherentRiskAssessPlan : assessPlanByInherentUnit) {
                        if (riskUnit.getExperimentId().equals(currentUserId) || riskUnit.getCreateByUserId().equals(currentUserId)  || riskUnit.getUpdateByUserId().equals(currentUserId)){
                            planIds.add(inherentRiskAssessPlan.getId());
                        }
                    }
                }
            }
        }

        List<ExperimentInfoDTO> experimentByList = experimentInfoService.getExperimentByUser(currentUserId);
        List<Long> experimentIdList = new ArrayList<>();
        experimentIdList.add(0L);
        if (!ObjectUtils.isEmpty(experimentByList)){
            for (ExperimentInfoDTO experimentInfo : experimentByList) {
                experimentIdList.add(experimentInfo.getId());
            }
        }

        SearchResult searchResult = new SearchResult<>();
        searchResult.setPageIndex(queryBO.getPageIndex());
        searchResult.setPageSize(queryBO.getPageSize());

        int roleTag = GetRoleTagUtils.GetRoleTagUtils(userInfo);
        //封装查询参数
        Specification<RiskAssessPlan> specification = new Specification<RiskAssessPlan>() {
            @Override
            public Predicate toPredicate(Root<RiskAssessPlan> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder) {
                List<Predicate> predicateList = new ArrayList<>();
                if (queryParam.getAssessPlanName() != null && !queryParam.getAssessPlanName().equals("")){
                    predicateList.add(criteriaBuilder.like(root.get("assessPlanName"),"%"+queryParam.getAssessPlanName()+"%"));
                }
                if (queryParam.getExperimentId() != null && !queryParam.getExperimentId().equals("")){
                    predicateList.add(criteriaBuilder.equal(root.get("experimentId"), queryParam.getExperimentId()));
                }
                if (queryParam.getAssessPlanId() != null && !queryParam.getAssessPlanId().equals("")){
                    predicateList.add(criteriaBuilder.equal(root.get("id"), queryParam.getAssessPlanId()));
                }
                if (!ObjectUtils.isEmpty(queryParam.getPlanExecStatus())){
                    if (queryParam.getPlanExecStatus() == 5){
                        predicateList.add(criteriaBuilder.ge(root.get("planExecStatus"), 3));
                    }else {
                        predicateList.add(criteriaBuilder.equal(root.get("planExecStatus"), queryParam.getPlanExecStatus()));
                    }
                }
                if (queryParam.getTag() == 2){
                    predicateList.add(criteriaBuilder.isNotNull(root.get("identificationTime")));
                }
                if (queryParam.getTag() == 3){
                    predicateList.add(criteriaBuilder.isNotNull(root.get("evaluateTime")));
                }
                if (planIds.size() > 0){
                    predicateList.add(criteriaBuilder.in(root.get("id")).value(planIds));
                }

                if (roleTag == UserTagEnum.USER_TAG_0.getCode()){
                    //此处应有谁能查询：辨识专家，评价专家,实验负责人(此处未存相关信息，以实验id为条件查询)
                    predicateList.add(criteriaBuilder.or(
                                    criteriaBuilder.equal(root.get("identificationUserId"), currentUserId),
                                    criteriaBuilder.equal(root.get("evaluateUserId"), currentUserId),
                                    criteriaBuilder.in(root.get("experimentId")).value(experimentIdList)
                            )
                    );
                }
                predicateList.add(criteriaBuilder.equal(root.get("deleteStatus"),StatusEnum.DELETE_NOT.getCode()));
                return criteriaBuilder.and(predicateList.toArray(new Predicate[0]));
            }
        };

        PageRequest pageParam = PageRequest.of(queryParam.getPageIndex() - 1, queryParam.getPageSize(), Sort.Direction.DESC, "updateTime");
        Page<RiskAssessPlan> pageResult = assessPlanRepository.findAll(specification, pageParam);

        //循环遍历结果集，封装查询结果
        List<AssessQueryDTO> assessQueryDTOList = new ArrayList<>();
        List<UserInfoDomainDTO> userList = userDomainService.getUserList();
        List<RiskUnitListAppQueryDTO> riskUnitListAppQueryDTOS = riskUnitService.listAssessRiskUnit();

//        // 查处固有风险单元列表，依此为条件，查询评估计划 此处需要测试
//        List<RiskUnit> riskUnits = riskUnitService.listInherentRiskUnit();
//        if (ObjectUtils.isEmpty(riskUnits)){
//            for (RiskUnit riskUnit : riskUnits) {
//                List<RiskAssessPlan> assessPlanByInherentUnit = assessPlanRepository.getAssessPlanByInherentUnit(riskUnit.getBasicRiskUnitId());
//                if (pageResult.getContent().size() > 0){
//                    for (RiskAssessPlan riskAssessPlan : pageResult.getContent()) {
//                        if (riskAssessPlan.getExperimentId().equals(riskUnit.getExperimentId())){
//                            if (assessPlanByInherentUnit.size() > 0){
//                                for (RiskAssessPlan inherentAssessPlan : assessPlanByInherentUnit) {
//                                    pageResult.getContent().add(inherentAssessPlan);
//                                }
//                            }
//                        }
//                    }
//                }
//            }
//        }

        if (pageResult.getContent().size() > 0){
            for (RiskAssessPlan riskAssessPlan : pageResult.getContent()) {
                AssessQueryDTO assessQueryDTO = BeanCopyUtils.copyBean(riskAssessPlan, AssessQueryDTO.class);
                for (RiskUnitListAppQueryDTO riskUnit : riskUnitListAppQueryDTOS) {
                    if (riskUnit.getId() == assessQueryDTO.getRiskUnitId()){
                        assessQueryDTO.setRiskUnitName(riskUnit.getRiskName());
                    }
                }
                List<FactorQueryDTO> factorQueryDTOList = new ArrayList<>();
                List<PhaQueryDTO> phaList = new ArrayList<>();
                List<JhaQueryDTO> jhaList = new ArrayList<>();
                List<SclQueryDTO> sclList = new ArrayList<>();
                List<HazopQueryDTO> hazopList = new ArrayList<>();
                List<AnalogyQueryDTO> analogyList = new ArrayList<>();

                //辨识方法 1-PHA；
                if (assessQueryDTO.getIdentificationMethod() == 1){
                    phaList = phaService.listPhaByPlanId(riskAssessPlan.getId());
                    //辨识方法 2-JHA；
                }else if (assessQueryDTO.getIdentificationMethod() == 2){
                    jhaList = jhaService.listJhaByPlanId(riskAssessPlan.getId());
                    //辨识方法 3-SCL；
                }else if (assessQueryDTO.getIdentificationMethod() == 3){
                    sclList = sclService.listSclByPlanId(riskAssessPlan.getId());
                    //辨识方法 4-HAZOP；
                }else if (assessQueryDTO.getIdentificationMethod() == 4){
                    hazopList = hazopService.listHazopByPlanId(riskAssessPlan.getId());
                    //5-类比法 analogy；
                }else if (assessQueryDTO.getIdentificationMethod() == 5){
                    analogyList = analogyService.listAnalogyByPlanId(riskAssessPlan.getId());
                }else {
                    throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode(), "辨识方法参数错误");
                }

                //评价方法1 - LEC
                if (assessQueryDTO.getEvaluateMethod() == 1){
                    List<LecQueryDTO> lecList = lecService.listLecByPlanId(riskAssessPlan.getId());
                    if (assessQueryDTO.getIdentificationMethod() == 1){
                        for (PhaQueryDTO pha : phaList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(pha, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setPhaId(pha.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(pha.getUpdateTime());
                            for (LecQueryDTO lec : lecList) {
                                if (lec.getIdentificationId() == pha.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.lecMatchPha(pha, lec);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setPhaId(pha.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }else if (assessQueryDTO.getIdentificationMethod() == 2){
                        for (JhaQueryDTO jha : jhaList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(jha, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setJhaId(jha.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(jha.getUpdateTime());
                            for (LecQueryDTO lec : lecList) {
                                if (lec.getIdentificationId() == jha.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.lecMatchJha(jha, lec);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setJhaId(jha.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }else if (assessQueryDTO.getIdentificationMethod() == 3){
                        for (SclQueryDTO scl : sclList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(scl, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setSclId(scl.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(scl.getUpdateTime());
                            for (LecQueryDTO lec : lecList) {
                                if (lec.getIdentificationId() == scl.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.lecMatchScl(scl, lec);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setSclId(scl.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }else if (assessQueryDTO.getIdentificationMethod() == 4){
                        for (HazopQueryDTO hazop : hazopList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(hazop, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setHazopId(hazop.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(hazop.getUpdateTime());
                            for (LecQueryDTO lec : lecList) {
                                if (lec.getIdentificationId() == hazop.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.lecMatchHazop(hazop, lec);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setHazopId(hazop.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                                for (UserInfoDomainDTO user : userList) {
                                    if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                        assessQueryDTO.setCreateByUserName(user.getRealName());
                                    }
                                    if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                        assessQueryDTO.setUpdateByUserName(user.getRealName());
                                    }
                                }
                                factorQueryDTOList.add(factorQueryDTO);
                            }
                        }
                    }else if (assessQueryDTO.getIdentificationMethod() == 5){
                        for (AnalogyQueryDTO analogy : analogyList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(analogy, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setAnalogyId(analogy.getAssessPlanId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(analogy.getUpdateTime());
                            for (LecQueryDTO lec : lecList) {
                                if (lec.getIdentificationId() == analogy.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.lecMatchAnalogy(analogy, lec);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setAnalogyId(analogy.getAssessPlanId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }

                    //评价方法2 - LS
                }else if (assessQueryDTO.getEvaluateMethod() == 2){
                    List<LsQueryDTO> lsList = lsService.listLsByPlanId(riskAssessPlan.getId());
                    if (assessQueryDTO.getIdentificationMethod() == 1){
                        for (PhaQueryDTO pha : phaList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(pha, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setPhaId(pha.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(pha.getUpdateTime());
                            for (LsQueryDTO ls : lsList) {
                                if (ls.getIdentificationId() == pha.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.lsMatchPha(pha, ls);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setPhaId(pha.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }else if (assessQueryDTO.getIdentificationMethod() == 2){
                        for (JhaQueryDTO jha : jhaList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(jha, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setJhaId(jha.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(jha.getUpdateTime());
                            for (LsQueryDTO ls : lsList) {
                                if (ls.getIdentificationId() == jha.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.lsMatchJha(jha, ls);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setJhaId(jha.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }else if (assessQueryDTO.getIdentificationMethod() == 3){
                        for (SclQueryDTO scl : sclList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(scl, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setSclId(scl.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(scl.getUpdateTime());
                            for (LsQueryDTO ls : lsList) {
                                if (ls.getIdentificationId() == scl.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.lsMatchScl(scl, ls);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setSclId(scl.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }else if (assessQueryDTO.getIdentificationMethod() == 4){
                        for (HazopQueryDTO hazop : hazopList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(hazop, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setHazopId(hazop.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(hazop.getUpdateTime());
                            for (LsQueryDTO ls : lsList) {
                                if (ls.getIdentificationId() == hazop.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.lsMatchHazop(hazop, ls);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setHazopId(hazop.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }else if (assessQueryDTO.getIdentificationMethod() == 5){
                        for (AnalogyQueryDTO analogy : analogyList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(analogy, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setAnalogyId(analogy.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(analogy.getUpdateTime());
                            for (LsQueryDTO ls : lsList) {
                                if (ls.getIdentificationId() == analogy.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.lsMatchAnalogy(analogy, ls);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setAnalogyId(analogy.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }
                    //评价方法3 - MES
                }else if (assessQueryDTO.getEvaluateMethod() == 3){
                    List<MesQueryDTO> mesList = mesService.listMesByPlanId(riskAssessPlan.getId());
                    if (assessQueryDTO.getIdentificationMethod() == 1){
                        for (PhaQueryDTO pha : phaList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(pha, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setPhaId(pha.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(pha.getUpdateTime());
                            for (MesQueryDTO mes : mesList) {
                                if (mes.getIdentificationId() == pha.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.mesMatchPha(pha, mes);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setPhaId(pha.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }else if (assessQueryDTO.getIdentificationMethod() == 2){
                        for (JhaQueryDTO jha : jhaList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(jha, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setJhaId(jha.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(jha.getUpdateTime());
                            for (MesQueryDTO mes : mesList) {
                                if (mes.getIdentificationId() == jha.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.mesMatchJha(jha, mes);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setJhaId(jha.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }else if (assessQueryDTO.getIdentificationMethod() == 3){
                        for (SclQueryDTO scl : sclList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(scl, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setSclId(scl.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(scl.getUpdateTime());
                            for (MesQueryDTO mes : mesList) {
                                if (mes.getIdentificationId() == scl.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.mesMatchScl(scl, mes);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setSclId(scl.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }else if (assessQueryDTO.getIdentificationMethod() == 4){
                        for (HazopQueryDTO hazop : hazopList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(hazop, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setHazopId(hazop.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(hazop.getUpdateTime());
                            for (MesQueryDTO mes : mesList) {
                                if (mes.getIdentificationId() == hazop.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.mesMatchHazop(hazop, mes);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setHazopId(hazop.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }else if (assessQueryDTO.getIdentificationMethod() == 5){
                        for (AnalogyQueryDTO analogy : analogyList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(analogy, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setAnalogyId(analogy.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(analogy.getUpdateTime());
                            for (MesQueryDTO mes : mesList) {
                                if (mes.getIdentificationId() == analogy.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.mesMatchAnalogy(analogy, mes);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setAnalogyId(analogy.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }
                    //评价方法4 - RS
                }else if (assessQueryDTO.getEvaluateMethod() == 4){
                    List<RsQueryDTO> rsList = rsService.listRsByPlanId(riskAssessPlan.getId());
                    if (assessQueryDTO.getIdentificationMethod() == 1){
                        for (PhaQueryDTO pha : phaList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(pha, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setPhaId(pha.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(pha.getUpdateTime());
                            for (RsQueryDTO rs : rsList) {
                                if (rs.getIdentificationId() == pha.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.rsMatchPha(pha, rs);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setPhaId(pha.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }else if (assessQueryDTO.getIdentificationMethod() == 2){
                        for (JhaQueryDTO jha : jhaList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(jha, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setJhaId(jha.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(jha.getUpdateTime());
                            for (RsQueryDTO rs : rsList) {
                                if (rs.getIdentificationId() == jha.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.rsMatchJha(jha, rs);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setJhaId(jha.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }else if (assessQueryDTO.getIdentificationMethod() == 3){
                        for (SclQueryDTO scl : sclList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(scl, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setSclId(scl.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(scl.getUpdateTime());
                            for (RsQueryDTO rs : rsList) {
                                if (rs.getIdentificationId() == scl.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.rsMatchScl(scl, rs);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setSclId(scl.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }else if (assessQueryDTO.getIdentificationMethod() == 4){
                        for (HazopQueryDTO hazop : hazopList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(hazop, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setHazopId(hazop.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(hazop.getUpdateTime());
                            for (RsQueryDTO rs : rsList) {
                                if (rs.getIdentificationId() == hazop.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.rsMatchHazop(hazop, rs);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setHazopId(hazop.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }else if (assessQueryDTO.getIdentificationMethod() == 5){
                        for (AnalogyQueryDTO analogy : analogyList) {
                            FactorQueryDTO factorQueryDTO = BeanCopyUtils.copyBean(analogy, FactorQueryDTO.class);
                            factorQueryDTO.setId(riskAssessPlan.getId());
                            factorQueryDTO.setAnalogyId(analogy.getId());
                            factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                            factorQueryDTO.setItemIdentificationTime(analogy.getUpdateTime());
                            for (RsQueryDTO rs : rsList) {
                                if (rs.getIdentificationId() == analogy.getId()){
                                    EvaluateAndIdentificationUtils evaluateAndIdentificationUtils = new EvaluateAndIdentificationUtils();
                                    factorQueryDTO = evaluateAndIdentificationUtils.rsMatchAnalogy(analogy, rs);
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                    factorQueryDTO.setId(riskAssessPlan.getId());
                                    factorQueryDTO.setAnalogyId(analogy.getId());
                                    factorQueryDTO.setEvaluateMethod(riskAssessPlan.getEvaluateMethod());
                                }
                            }
                            for (UserInfoDomainDTO user : userList) {
                                if (user.getId() == assessQueryDTO.getCreateByUserId()){
                                    assessQueryDTO.setCreateByUserName(user.getRealName());
                                }
                                if (user.getId() == assessQueryDTO.getUpdateByUserId()){
                                    assessQueryDTO.setUpdateByUserName(user.getRealName());
                                }
                            }
                            factorQueryDTOList.add(factorQueryDTO);
                        }
                    }
                }else {
                    throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode(), "评价方法参数错误");
                }
                assessQueryDTO.setFactorQueryDTOList(factorQueryDTOList);
                assessQueryDTOList.add(assessQueryDTO);
            }
        }

        searchResult.setData(assessQueryDTOList);
        searchResult.setTotal(pageResult.getTotalElements());
        searchResult.setCount(assessQueryDTOList.size());
        return searchResult;
    }

    /**
     * 风险评估计划 - 辨识删除
     */
    @Transactional
    @Override
    public AssessPlanUpdateDTO deleteIdentification(Long currentUserId, RiskAssessPlanIdentificationDeleteReqBO deleteReqBO) {

        if (currentUserId < 0){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无效，请重新登陆");
        }
        UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
        if (ObjectUtils.isEmpty(userInfoById)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户不存在或已被删除");
        }
        if (ObjectUtils.isEmpty(deleteReqBO.getId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "要删除的辨识项目不能为空");
        }
        RiskAssessPlan assessPlanById = assessPlanRepository.getAssessPlanById(deleteReqBO.getId());
        if (ObjectUtils.isEmpty(assessPlanById)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "辨识计划不存在，或已被删除");
        }
        if (!assessPlanById.getIdentificationUserId().equals(currentUserId)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"不是辨识专家，无法操作");
        }
        if (ObjectUtils.isEmpty(assessPlanById.getIdentificationMethod())){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "要删除的辨识项目为空,或已被删除");
        }
        if (assessPlanById.getPlanExecStatus() != StatusEnum.PLAN_EXEC_IDENTIFICATION.getCode().byteValue()){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "辨识已提交，无法删除");
        }
//        if (!assessPlanById.getPlanUserId().equals(userInfoById.getId())){
//            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode(), "您不是计划制定者，无法删除");
//        }
        //处理辨识表
        //辨识方法 1-PHA；
        int tag = 0;
        if (assessPlanById.getIdentificationMethod() == 1){
            IdentificationMethodDeleteDTO deleteIdentificationResult = phaService.deletePhaByPlanId(currentUserId, deleteReqBO.getPhaId());
            if (deleteIdentificationResult.getResult() < 1){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "删除辨识项目失败");
            }
            tag = 1;
            //辨识方法 2-JHA；
        }else if (assessPlanById.getIdentificationMethod() == 2){
            IdentificationMethodDeleteDTO deleteIdentificationResult = jhaService.deleteJhaByPlanId(currentUserId, deleteReqBO.getJhaId());
            if (deleteIdentificationResult.getResult() < 1){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "删除辨识项目失败");
            }
            tag = 1;
            //辨识方法 3-SCL；
        }else if (assessPlanById.getIdentificationMethod() == 3){
            IdentificationMethodDeleteDTO deleteIdentificationResult =sclService.deleteSclByPlanId(currentUserId, deleteReqBO.getSclId());
            if (deleteIdentificationResult.getResult() < 1){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "删除辨识项目失败");
            }
            tag = 1;
            //辨识方法 4-HAZOP；
        }else if (assessPlanById.getIdentificationMethod() == 4){
            IdentificationMethodDeleteDTO deleteIdentificationResult = hazopService.deleteHazopByPlanId(currentUserId, deleteReqBO.getHazopId());
            if (deleteIdentificationResult.getResult() < 1){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "删除辨识项目失败");
            }
            tag = 1;
            //5-类比法 analogy；
        }else if (assessPlanById.getIdentificationMethod() == 5){
            IdentificationMethodDeleteDTO deleteIdentificationResult= analogyService.deleteAnalogyByPlanId(currentUserId, deleteReqBO.getAnalogyId());
            if (deleteIdentificationResult.getResult() < 1){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "删除辨识项目失败");
            }
            tag = 1;
        }else {
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode(), "辨识方法参数错误");
        }
        //处理计划表 , 清除辨识时间
//        RiskAssessPlan deleteResult = assessPlanRepository.deleteIdentification(deleteReqBO.getId(), LocalDateTime.now());
        //todo 需要进行判断，如果没有辨识，清空时间，如果有，重置时间
        assessPlanById.setIdentificationTime(null);
        RiskAssessPlan deleteResult = assessPlanRepository.save(assessPlanById);
        if (ObjectUtils.isEmpty(deleteResult)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "辨识方法删除失败");
        }

        return BeanCopyUtils.copyBean(deleteResult, AssessPlanUpdateDTO.class);
    }

    /**
     * 风险评估计划 - 评价删除
     */
    @Transactional
    @Override
    public AssessPlanUpdateDTO deleteEvaluate(Long currentUserId, RiskAssessPlanEvaluateDeleteReqBO deleteReqBO) {

        if (currentUserId < 0){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户无效，请重新登陆");
        }
        UserInfoDomainDTO userInfoById = userDomainService.getUserInfoById(currentUserId);
        if (ObjectUtils.isEmpty(userInfoById)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_NOT_ALLOWED.getCode() ,"当前用户不存在或已被删除");
        }
        if (ObjectUtils.isEmpty(deleteReqBO.getId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "要删除的评价项目不能为空");
        }
        RiskAssessPlan assessPlanById = assessPlanRepository.getAssessPlanById(deleteReqBO.getId());
        if (ObjectUtils.isEmpty(assessPlanById)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "评价计划不存在，或已被删除");
        }
        if (ObjectUtils.isEmpty(assessPlanById.getEvaluateMethod())){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "要删除的评价项目为空,或已被删除");
        }
        if (assessPlanById.getPlanExecStatus() != StatusEnum.PLAN_EXEC_EVALUATE.getCode().byteValue()){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "评价已提交，无法删除");
        }
        if (!assessPlanById.getPlanUserId().equals(userInfoById.getId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode(), "您不是计划制定者，无法删除");
        }
        //辨识方法1 - LEC
        if (assessPlanById.getEvaluateMethod() == 1){
            EvaluateMethodDeleteDTO deleteEvaluateResult = lecService.deleteLecByPlanId(currentUserId, deleteReqBO);
            if (deleteEvaluateResult.getResult() < 1){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "删除评价项目失败");
            }
            //辨识方法2 - LS
        }else if (assessPlanById.getEvaluateMethod() == 2){
            EvaluateMethodDeleteDTO deleteEvaluateResult = lsService.deleteLsByPlanId(currentUserId, deleteReqBO);
            if (deleteEvaluateResult.getResult() < 1){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "删除评价项目失败");
            }
            //辨识方法3 - MES
        }else if (assessPlanById.getEvaluateMethod() == 3){
            EvaluateMethodDeleteDTO deleteEvaluateResult = mesService.deleteMesByPlanId(currentUserId, deleteReqBO);
            if (deleteEvaluateResult.getResult() < 1){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "删除评价项目失败");
            }
            //辨识方法4 - RS
        }else if (assessPlanById.getEvaluateMethod() == 4){
            EvaluateMethodDeleteDTO deleteEvaluateResult = rsService.deleteRsByPlanId(currentUserId, deleteReqBO);
            if (deleteEvaluateResult.getResult() < 1){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "删除评价项目失败");
            }
        }else {
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR.getCode(), "评价方法参数错误");
        }

        //处理评估计划表
//        RiskAssessPlan deleteResult = assessPlanRepository.deleteEvaluate(id, LocalDateTime.now());
        assessPlanById.setIdentificationTime(null);
        RiskAssessPlan deleteResult = assessPlanRepository.save(assessPlanById);
        if (ObjectUtils.isEmpty(deleteResult)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "评价方法删除失败");
        }

        return BeanCopyUtils.copyBean(deleteResult, AssessPlanUpdateDTO.class);
    }

    /**
     * 风险评估计划 - 查询 by id
     */
    @Override
    public AssessPlanQueryDTO getAssessPlanById(Long id) {

        if (ObjectUtils.isEmpty(id)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评估计划不能为空");
        }

        RiskAssessPlan assessPlanById = assessPlanRepository.getAssessPlanById(id);
        if (ObjectUtils.isEmpty(assessPlanById)){
            throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "评估计划不存在");
        }
        return BeanCopyUtils.copyBean(assessPlanById, AssessPlanQueryDTO.class);
    }

    /**
     * 风险评估计划 - 查询 by 实验id
     */
    @Override
    public List<AssessPlanQueryDTO> getAssessPlanByExperimentId(Long experimentId) {

        if (ObjectUtils.isEmpty(experimentId)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评估计划不能为空");
        }
        List<RiskAssessPlan> assessPlanList = assessPlanRepository.getAssessPlanByExperimentId(experimentId);
        return BeanCopyUtils.copyBeanList(assessPlanList, AssessPlanQueryDTO.class);
    }
    /**
     * 评估计划 - 查询已派发
     */
    @Override
    public List<RiskAssessPlanListAppDTO> listAssessPlan(Byte status) {
        List<RiskAssessPlan> riskAssessPlans = assessPlanRepository.listAssessPlan(status);
        if (riskAssessPlans.size() < 1){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "没有可以辨识的评估计划");
        }
        return BeanCopyUtils.copyBeanList(riskAssessPlans, RiskAssessPlanListAppDTO.class);
    }
    /**
     * 评估计划 - 修改任务派发状态
     */
    @Override
    public int assessPlanSellStatus(Long id, byte status) {

        List<RiskAssessPlan> assessPlanByExperimentId = assessPlanRepository.getAssessPlanByExperimentId(id);

        int tag = 1;
        for (RiskAssessPlan riskAssessPlan : assessPlanByExperimentId) {
            riskAssessPlan.setPlanSellStatus(status);
            RiskAssessPlan save = assessPlanRepository.save(riskAssessPlan);
            if (ObjectUtils.isEmpty(save)){
                tag = 0;
            }
        }

        return tag;
    }
    /**
     * 风险评估计划 - 辨识专家拒绝
     */
    @Override
    public AssessPlanUpdateDTO identificationRefuse(Long currentUserId, Long id) {

        if (ObjectUtils.isEmpty(id)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请选择正确的评估计划");
        }
        UserInfoDomainDTO user = userDomainService.getUserById(currentUserId);

        RiskAssessPlan assessPlanById = assessPlanRepository.getAssessPlanById(id);
        if (!currentUserId.equals(assessPlanById.getIdentificationUserId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "不能拒绝其他专家的辨识任务");
        }
        if (assessPlanById.getPlanExecStatus().equals(StatusEnum.PLAN_EXEC_EVALUATE.getCode())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "辨识结果已提交，无法拒绝任务");
        }
        assessPlanById.setIdentificationUser(null);
        assessPlanById.setIdentificationUserId(null);

        RiskAssessPlan save = assessPlanRepository.save(assessPlanById);
        return BeanCopyUtils.copyBean(save, AssessPlanUpdateDTO.class);
    }

    /**
     * 风险评估计划 - 评价专家拒绝
     */
    @Transactional
    @Override
    public AssessPlanUpdateDTO evaluateRefuse(Long currentUserId, Long id) {
        if (ObjectUtils.isEmpty(id)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请选择正确的评估计划");
        }
        UserInfoDomainDTO user = userDomainService.getUserById(currentUserId);

        RiskAssessPlan assessPlanById = assessPlanRepository.getAssessPlanById(id);
        if (!currentUserId.equals(assessPlanById.getEvaluateUserId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "不能拒绝其他专家的评价任务");
        }
        if (assessPlanById.getPlanExecStatus().equals(StatusEnum.PLAN_EXEC_OVER.getCode())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评估已完成，无法拒绝任务");
        }
        assessPlanById.setEvaluateUser(null);
        assessPlanById.setEvaluateUserId(null);
        if (assessPlanById.getEvaluateTime() != null){
            if (assessPlanById.getEvaluateMethod().equals(MethodEnum.EVALUATE_METHOD_LEC.getCode())){
                int result = lecService.deleteLecByAssessPlanId(id);
                if (result == 1){
                    throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "删除评价信息失败");
                }
            }else if (assessPlanById.getEvaluateMethod().equals(MethodEnum.EVALUATE_METHOD_LS.getCode())){
                int result = lsService.deleteLsByAssessPlanId(id);
                if (result == 1){
                    throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "删除评价信息失败");
                }
            }else if (assessPlanById.getEvaluateMethod().equals(MethodEnum.EVALUATE_METHOD_MES.getCode())){
                int result = mesService.deleteMesByAssessPlanId(id);
                if (result == 1){
                    throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "删除评价信息失败");
                }
            }else if (assessPlanById.getEvaluateMethod().equals(MethodEnum.EVALUATE_METHOD_RS.getCode())){
                int result = rsService.deleteRsByAssessPlanId(id);
                if (result == 1){
                    throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "删除评价信息失败");
                }
            }
        }

        RiskAssessPlan save = assessPlanRepository.save(assessPlanById);

        return BeanCopyUtils.copyBean(save, AssessPlanUpdateDTO.class);
    }

    /**
     * 风险评估计划 - 辨识方法修改
     */
    @Override
    public AssessPlanUpdateDTO identificationUpdateMethod(Long currentUserId, MethodUpdateReqDTO updateReqDTO) {

        if (ObjectUtils.isEmpty(updateReqDTO.getId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请选择正确的评估计划");
        }
        if (ObjectUtils.isEmpty(updateReqDTO.getIdentificationMethodId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请选择正确的辨识方法");
        }
        RiskAssessPlan assessPlanById = assessPlanRepository.getAssessPlanById(updateReqDTO.getId());
        if (ObjectUtils.isEmpty(assessPlanById)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "辨识任务不存在");
        }
        if (!assessPlanById.getIdentificationUserId().equals(currentUserId)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "只能修改自己的辨识任务");
        }
        assessPlanById.setIdentificationMethod(updateReqDTO.getIdentificationMethodId());
        assessPlanById.setUpdateTime(LocalDateTime.now());
        assessPlanById.setUpdateByUserId(currentUserId);

        RiskAssessPlan save = assessPlanRepository.save(assessPlanById);
        return BeanCopyUtils.copyBean(save, AssessPlanUpdateDTO.class);
    }

    /**
     * 风险评估计划 - 评价方法修改
     */
    @Transactional
    @Override
    public AssessPlanUpdateDTO evaluateUpdateMethod(Long currentUserId, MethodUpdateReqDTO updateReqDTO) {

        if (ObjectUtils.isEmpty(updateReqDTO.getId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请选择正确的评估计划");
        }
        if (ObjectUtils.isEmpty(updateReqDTO.getEvaluateMethodId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请选择正确的评价方法");
        }
        RiskAssessPlan assessPlanById = assessPlanRepository.getAssessPlanById(updateReqDTO.getId());
        if (ObjectUtils.isEmpty(assessPlanById)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "评价任务不存在");
        }
        if (!assessPlanById.getEvaluateUserId().equals(currentUserId)){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "只能修改自己的评价任务");
        }
        assessPlanById.setEvaluateMethod(updateReqDTO.getEvaluateMethodId());
        assessPlanById.setUpdateTime(LocalDateTime.now());
        assessPlanById.setUpdateByUserId(currentUserId);
        assessPlanById.setEvaluateTime(null);

        if (updateReqDTO.getEvaluateMethodId() == 1){
            int result = lecService.deleteLecByPlan(updateReqDTO.getId());
            if (result == StatusEnum.FAIL.getCode()){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "修改评价方法失败");
            }
        }else if (updateReqDTO.getEvaluateMethodId() == 2){
            int result = lsService.deleteLsByPlan(updateReqDTO.getId());
            if (result == StatusEnum.FAIL.getCode()){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "修改评价方法失败");
            }
        }else if (updateReqDTO.getEvaluateMethodId() == 3){
            int result = mesService.deleteMesByPlan(updateReqDTO.getId());
            if (result == StatusEnum.FAIL.getCode()){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "修改评价方法失败");
            }
        }else if (updateReqDTO.getEvaluateMethodId() == 4){
            int result = rsService.deleteRsByPlan(updateReqDTO.getId());
            if (result == StatusEnum.FAIL.getCode()){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR.getCode(), "修改评价方法失败");
            }
        }

        RiskAssessPlan save = assessPlanRepository.save(assessPlanById);
        return BeanCopyUtils.copyBean(save, AssessPlanUpdateDTO.class);
    }

    /**
     * 风险评估计划 - 重新指定专家
     */
    @Override
    public AssessPlanUpdateDTO appoint(Long currentUserId, AppointUserReBO appointUserReBO) {

        if (ObjectUtils.isEmpty(appointUserReBO.getId())){
            throw new BusinessException(this.getClass(), ResultCode.PARAM_ERROR_NULL.getCode(), "请选择正确的评估计划");
        }
        UserInfoDomainDTO user = userDomainService.getUserById(currentUserId);
        RiskAssessPlan assessPlanById = assessPlanRepository.getAssessPlanById(appointUserReBO.getId());

        if (!ObjectUtils.isEmpty(appointUserReBO.getIdentificationUserId())){
            UserInfoDomainDTO identificationUser = userDomainService.getUserById(appointUserReBO.getIdentificationUserId());
            if (ObjectUtils.isEmpty(identificationUser)){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_DATA_NOT_EXISIST.getCode(), "所选的辨识专家不存在");
            }
            assessPlanById.setIdentificationUserId(identificationUser.getId());
            assessPlanById.setIdentificationUser(identificationUser.getRealName());
        }
        if (!ObjectUtils.isEmpty(appointUserReBO.getEvaluateUserId())){
            UserInfoDomainDTO evaluateUser = userDomainService.getUserById(appointUserReBO.getEvaluateUserId());
            if (ObjectUtils.isEmpty(evaluateUser)){
                throw new BusinessException(this.getClass(), ResultCode.BUSINESS_ERROR_DATA_NOT_EXISIST.getCode(), "所选的评价专家不存在");
            }
            assessPlanById.setEvaluateUserId(evaluateUser.getId());
            assessPlanById.setEvaluateUser(evaluateUser.getRealName());
        }

        LocalDateTime date = LocalDateTime.now();
        assessPlanById.setUpdateByUserId(user.getId());
        assessPlanById.setUpdateTime(date);

        RiskAssessPlan save = assessPlanRepository.save(assessPlanById);
        return BeanCopyUtils.copyBean(save, AssessPlanUpdateDTO.class);
    }


}