safePlatform-out.git

package com.gkhy.safePlatform.emergency.service.impl;
 
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.gkhy.safePlatform.commons.enums.ResultCodes;
import com.gkhy.safePlatform.commons.query.PageQuery;
import com.gkhy.safePlatform.commons.utils.BeanCopyUtils;
import com.gkhy.safePlatform.commons.utils.StringUtils;
import com.gkhy.safePlatform.commons.vo.ResultVO;
import com.gkhy.safePlatform.commons.vo.SearchResultVO;
import com.gkhy.safePlatform.emergency.entity.*;
import com.gkhy.safePlatform.emergency.enums.*;
import com.gkhy.safePlatform.emergency.excepiton.EmergencyException;
import com.gkhy.safePlatform.emergency.model.dto.req.EmergencyDrillEvaluationFileReqDTO;
import com.gkhy.safePlatform.emergency.model.dto.req.EmergencyDrillEvaluationReqDTO;
import com.gkhy.safePlatform.emergency.model.dto.req.EmergencyDrillEvaluationUserReqDTO;
import com.gkhy.safePlatform.emergency.model.dto.resp.*;
import com.gkhy.safePlatform.emergency.query.EmergencyDrillEvaluationQuery;
import com.gkhy.safePlatform.emergency.query.db.EmergencyDrillEvaluationDBQuery;
import com.gkhy.safePlatform.emergency.service.EmergencyDrillEvaluationService;
import com.gkhy.safePlatform.emergency.service.baseService.*;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
 
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
 
@Service("emergencyDrillEvaluationService")
public class EmergencyDrillEvaluationServiceImpl implements EmergencyDrillEvaluationService {
 
    @Autowired
    private EmergencyDrillEvaluationInfoService emergencyDrillEvaluationInfoService;
 
    @Autowired
    private EmergencyDrillEvaluationFileInfoService emergencyDrillEvaluationFileInfoService;
 
    @Autowired
    private EmergencyDrillEvaluationUserInfoService emergencyDrillEvaluationUserInfoService;
 
    @Autowired
    private EmergencyDrillExecuteInfoService emergencyDrillExecuteInfoService;
 
    @Autowired
    private EmergencyDrillExecuteUserInfoService emergencyDrillExecuteUserInfoService;
 
    @Autowired
    private EmergencyDrillPlanFileInfoService emergencyDrillPlanFileInfoService;
 
    @Autowired
    private EmergencyDrillPlanUserInfoService emergencyDrillPlanUserInfoService;
 
    @Override
    public SearchResultVO<List<EmergencyDrillEvaluationPageRespDTO>> selectEmergencyDrillEvaluationList(PageQuery<EmergencyDrillEvaluationQuery> query) {
        Long pageIndex = query.getPageIndex();
        Long pageSize = query.getPageSize();
        Page<EmergencyDrillEvaluationInfoPageDO> page = new Page<>(pageIndex, pageSize);
 
        EmergencyDrillEvaluationDBQuery emergencyDrillEvaluationDBQuery = new EmergencyDrillEvaluationDBQuery();
        if (query.getSearchParams() != null) {
            BeanUtils.copyProperties(query.getSearchParams(), emergencyDrillEvaluationDBQuery);
        }
        List<EmergencyDrillEvaluationInfoPageDO> emergencyDrillEvaluationListDoInfoList = emergencyDrillEvaluationInfoService.selectEmergencyDrillEvaluationList(page, emergencyDrillEvaluationDBQuery);
        List<EmergencyDrillEvaluationPageRespDTO> respList = BeanCopyUtils.copyBeanList(emergencyDrillEvaluationListDoInfoList, EmergencyDrillEvaluationPageRespDTO.class);
 
        return new SearchResultVO<>(
                true,
                pageIndex,
                pageSize,page.getPages(),
                page.getTotal(),
                respList,
                ResultCodes.OK
        );
    }
 
    @Override
    public ResultVO addEmergencyDrillEvaluation(Long uid, EmergencyDrillEvaluationReqDTO emergencyDrillEvaluationReqDTO) {
        // 验证枚举
        checkEnum(emergencyDrillEvaluationReqDTO);
 
        // 判断请求中是否存在演练计划id
        if (emergencyDrillEvaluationReqDTO.getDrillExecuteId() == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_EXECUTE_NULL);
        } else {
            EmergencyDrillExecuteInfoDetailDO emergencyDrillExecuteInfoDetailDO = emergencyDrillExecuteInfoService.selectEmergencyDrillExecuteById(emergencyDrillEvaluationReqDTO.getDrillExecuteId());
            // 判断是否存在该演练实施
            if (emergencyDrillExecuteInfoDetailDO == null) {
                throw new EmergencyException(EmergencyResultCodes.DRILL_EXECUTE_NOT_EXIST);
            } else {
                Date nowDate = new Date();
                // 新增应急演练实施评价
                EmergencyDrillEvaluationInfo emergencyDrillEvaluationInfo = new EmergencyDrillEvaluationInfo();
                BeanUtils.copyProperties(emergencyDrillEvaluationReqDTO, emergencyDrillEvaluationInfo);
                emergencyDrillEvaluationInfo.setDelFlag(false);
                emergencyDrillEvaluationInfo.setCreateUid(uid);
                emergencyDrillEvaluationInfo.setGmtCreate(nowDate);
                emergencyDrillEvaluationInfoService.addEmergencyDrillEvaluation(emergencyDrillEvaluationInfo);
                // 新增急演练实施评价附件表
                if (!CollectionUtils.isEmpty(emergencyDrillEvaluationReqDTO.getFileList())) {
                    addEmergencyDrillEvaluationFile(uid, emergencyDrillEvaluationInfo.getId(), nowDate, emergencyDrillEvaluationReqDTO.getFileList());
                }
                // 新增急演练实施评价应急人员表
                if (!CollectionUtils.isEmpty(emergencyDrillEvaluationReqDTO.getUserList())) {
                    addEmergencyDrillEvaluationUser(uid, emergencyDrillEvaluationInfo.getId(), nowDate, emergencyDrillEvaluationReqDTO.getUserList());
                }
 
                return new ResultVO<>(ResultCodes.OK);
            }
        }
    }
 
    private void addEmergencyDrillEvaluationFile(Long uid, Long DrillEvaluationId, Date nowDate, List<EmergencyDrillEvaluationFileReqDTO> emergencyDrillEvaluationFileReqDTOList) {
        List<EmergencyDrillEvaluationFileInfo> emergencyDrillEvaluationFileInfoList = BeanCopyUtils.copyBeanList(emergencyDrillEvaluationFileReqDTOList, EmergencyDrillEvaluationFileInfo.class);
        emergencyDrillEvaluationFileInfoList.forEach(EmergencyDrillEvaluationFileInfo -> {
            EmergencyDrillEvaluationFileInfo.setDelFlag(false);
            EmergencyDrillEvaluationFileInfo.setCreateUid(uid);
            EmergencyDrillEvaluationFileInfo.setGmtCreate(nowDate);
            EmergencyDrillEvaluationFileInfo.setDrillEvaluationId(DrillEvaluationId);
        });
        for (EmergencyDrillEvaluationFileInfo emergencyDrillEvaluationFileInfo : emergencyDrillEvaluationFileInfoList) {
            emergencyDrillEvaluationFileInfoService.addEmergencyDrillEvaluationFile(emergencyDrillEvaluationFileInfo);
        }
    }
 
    private void addEmergencyDrillEvaluationUser(Long uid, Long DrillEvaluationId, Date nowDate, List<EmergencyDrillEvaluationUserReqDTO> emergencyDrillEvaluationUserReqDTOList) {
        List<EmergencyDrillEvaluationUserInfo> emergencyDrillEvaluationUserInfoList = BeanCopyUtils.copyBeanList(emergencyDrillEvaluationUserReqDTOList, EmergencyDrillEvaluationUserInfo.class);
        emergencyDrillEvaluationUserInfoList.forEach(EmergencyDrillEvaluationUserInfo -> {
            EmergencyDrillEvaluationUserInfo.setDelFlag(false);
            EmergencyDrillEvaluationUserInfo.setCreateUid(uid);
            EmergencyDrillEvaluationUserInfo.setGmtCreate(nowDate);
            EmergencyDrillEvaluationUserInfo.setDrillEvaluationId(DrillEvaluationId);
        });
        for (EmergencyDrillEvaluationUserInfo emergencyDrillEvaluationUserInfo : emergencyDrillEvaluationUserInfoList) {
            emergencyDrillEvaluationUserInfoService.addEmergencyDrillEvaluationUser(emergencyDrillEvaluationUserInfo);
        }
    }
 
    @Override
    public ResultVO<EmergencyDrillEvaluationDetailRespDTO> getEmergencyDrillEvaluationById(Long id) {
        EmergencyDrillEvaluationDetailRespDTO emergencyDrillEvaluationDetailRespDTO = new EmergencyDrillEvaluationDetailRespDTO();
        // 查询是否存在
        EmergencyDrillEvaluationInfoDetailDO emergencyDrillEvaluationInfoDetailDO = emergencyDrillEvaluationInfoService.selectEmergencyDrillEvaluationByExecuteId(id);
        if (emergencyDrillEvaluationInfoDetailDO == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_EVALUATION_NOT_EXIST);
        } else {
            BeanUtils.copyProperties(emergencyDrillEvaluationInfoDetailDO, emergencyDrillEvaluationDetailRespDTO);
 
            // 演练计划的文件
            List<EmergencyDrillPlanFileInfoDO> planFileInfoDOList = emergencyDrillPlanFileInfoService.selectEmergencyDrillPlanFileByDrillPlanId(emergencyDrillEvaluationDetailRespDTO.getDrillPlanId());
            if (!CollectionUtils.isEmpty(planFileInfoDOList)) {
                List<EmergencyDrillPlanFileRespDTO> emergencyUserFileRespDTOList = BeanCopyUtils.copyBeanList(planFileInfoDOList, EmergencyDrillPlanFileRespDTO.class);
                emergencyDrillEvaluationDetailRespDTO.setPlanFileList(emergencyUserFileRespDTOList);
            }
            // 演练计划的人员
            List<EmergencyDrillPlanUserInfoDO> planUserInfoDOList = emergencyDrillPlanUserInfoService.selectEmergencyDrillPlanUserByDrillPlanId(emergencyDrillEvaluationDetailRespDTO.getDrillPlanId());
            if (!CollectionUtils.isEmpty(planUserInfoDOList)) {
                List<EmergencyDrillPlanUserRespDTO> emergencyDrillPlanUserRespDTOList = BeanCopyUtils.copyBeanList(planUserInfoDOList, EmergencyDrillPlanUserRespDTO.class);
 
                List<EmergencyDrillPlanUserRespDTO> planUserList = emergencyDrillPlanUserRespDTOList.stream().filter(user -> user.getType()==1 ).collect(Collectors.toList());
                List<EmergencyDrillPlanUserRespDTO> planChargeUserList = emergencyDrillPlanUserRespDTOList.stream().filter(user -> user.getType()==2 ).collect(Collectors.toList());
                emergencyDrillEvaluationDetailRespDTO.setPlanUserList(planUserList);
                emergencyDrillEvaluationDetailRespDTO.setPlanChargeUserList(planChargeUserList);
            }
            // 演练实施的人员
            List<EmergencyDrillExecuteUserInfoDO> executeUserList = emergencyDrillExecuteUserInfoService.selectEmergencyDrillExecuteUserByDrillExecuteId(emergencyDrillEvaluationDetailRespDTO.getDrillExecuteId());
            if (!CollectionUtils.isEmpty(executeUserList)) {
                List<EmergencyDrillExecuteUserRespDTO> emergencyUserFileRespDTOList = BeanCopyUtils.copyBeanList(executeUserList, EmergencyDrillExecuteUserRespDTO.class);
                emergencyDrillEvaluationDetailRespDTO.setExecuteUserList(emergencyUserFileRespDTOList);
            }
            // 演练评价的文件
            List<EmergencyDrillEvaluationFileInfoDO> emergencyDrillEvaluationFileInfoDOList = emergencyDrillEvaluationFileInfoService.selectEmergencyDrillEvaluationFileByDrillEvaluationId(emergencyDrillEvaluationDetailRespDTO.getId());
            if (!CollectionUtils.isEmpty(emergencyDrillEvaluationFileInfoDOList)) {
                List<EmergencyDrillEvaluationFileRespDTO> emergencyUserFileRespDTOList = BeanCopyUtils.copyBeanList(emergencyDrillEvaluationFileInfoDOList, EmergencyDrillEvaluationFileRespDTO.class);
                emergencyDrillEvaluationDetailRespDTO.setEvaluationFileList(emergencyUserFileRespDTOList);
            }
            // 演练评价的人员
            List<EmergencyDrillEvaluationUserInfoDO> emergencyDrillEvaluationUserInfoDOList = emergencyDrillEvaluationUserInfoService.selectEmergencyDrillEvaluationUserByDrillEvaluationId(emergencyDrillEvaluationDetailRespDTO.getId());
            if (!CollectionUtils.isEmpty(emergencyDrillEvaluationUserInfoDOList)) {
                List<EmergencyDrillEvaluationUserRespDTO> emergencyUserUserRespDTOList = BeanCopyUtils.copyBeanList(emergencyDrillEvaluationUserInfoDOList, EmergencyDrillEvaluationUserRespDTO.class);
                emergencyDrillEvaluationDetailRespDTO.setEvaluationUserList(emergencyUserUserRespDTOList);
            }
 
 
            return new ResultVO<>(ResultCodes.OK, emergencyDrillEvaluationDetailRespDTO);
        }
    }
 
    @Override
    public ResultVO updateEmergencyDrillEvaluation(Long uid, EmergencyDrillEvaluationReqDTO emergencyDrillEvaluationReqDTO) {
        // 验证枚举
        checkEnum(emergencyDrillEvaluationReqDTO);
        Date nowDate = new Date();
        // 查询是否存在
        EmergencyDrillEvaluationInfoDetailDO emergencyDrillEvaluationInfoDetailDO = emergencyDrillEvaluationInfoService.selectEmergencyDrillEvaluationByExecuteId(emergencyDrillEvaluationReqDTO.getDrillExecuteId());
        if (emergencyDrillEvaluationInfoDetailDO == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_EVALUATION_NOT_EXIST);
        } else {
            EmergencyDrillEvaluationInfo emergencyDrillEvaluationInfo = new EmergencyDrillEvaluationInfo();
            BeanUtils.copyProperties(emergencyDrillEvaluationReqDTO, emergencyDrillEvaluationInfo);
            emergencyDrillEvaluationInfo.setId(emergencyDrillEvaluationInfoDetailDO.getId());
            emergencyDrillEvaluationInfo.setUpdateUid(uid);
            emergencyDrillEvaluationInfo.setGmtModitify(nowDate);
            emergencyDrillEvaluationInfoService.updateEmergencyDrillEvaluation(emergencyDrillEvaluationInfo);
 
            // 更新急演练实施评价附件表
            if (!CollectionUtils.isEmpty(emergencyDrillEvaluationReqDTO.getFileList())) {
                updateEmergencyDrillEvaluationFile(uid, emergencyDrillEvaluationInfo.getId(), nowDate, emergencyDrillEvaluationReqDTO.getFileList());
            }
            // 更新急演练实施评价应急队伍表
            if (!CollectionUtils.isEmpty(emergencyDrillEvaluationReqDTO.getUserList())) {
                updateEmergencyDrillEvaluationUser(uid, emergencyDrillEvaluationInfo.getId(), nowDate, emergencyDrillEvaluationReqDTO.getUserList());
            }
            // 修改实施表的评价状态
            emergencyDrillExecuteInfoService.updateStatusById(emergencyDrillEvaluationInfoDetailDO.getDrillExecuteId());
            return new ResultVO<>(ResultCodes.OK);
        }
    }
 
    private void updateEmergencyDrillEvaluationFile(Long uid, Long DrillEvaluationId, Date
            nowDate, List<EmergencyDrillEvaluationFileReqDTO> fileReqDTOList) {
        List<EmergencyDrillEvaluationFileInfoDO> emergencyDrillEvaluationFileInfoDOList = emergencyDrillEvaluationFileInfoService.selectEmergencyDrillEvaluationFileByDrillEvaluationId(DrillEvaluationId);
        List<Long> oldIdsList = emergencyDrillEvaluationFileInfoDOList.stream().map(EmergencyDrillEvaluationFileInfoDO::getId).collect(Collectors.toList());
        List<Long> newIdsList = new ArrayList<>();
 
        //新增的区域集合
        List<EmergencyDrillEvaluationFileInfo> addList = new ArrayList<>();
        //删除的区域集合(id)
        List<Long> deleteList = new ArrayList<>();
        for (EmergencyDrillEvaluationFileReqDTO emergencyDrillEvaluationFileReqDTO : fileReqDTOList) {
            //如果不存在id则表示页面新增的附件
            if (emergencyDrillEvaluationFileReqDTO.getId() == null) {
                EmergencyDrillEvaluationFileInfo emergencyDrillEvaluationFileInfo = new EmergencyDrillEvaluationFileInfo();
                BeanUtils.copyProperties(emergencyDrillEvaluationFileReqDTO, emergencyDrillEvaluationFileInfo);
                emergencyDrillEvaluationFileInfo.setDelFlag(false);
                emergencyDrillEvaluationFileInfo.setGmtCreate(nowDate);
                emergencyDrillEvaluationFileInfo.setCreateUid(uid);
                emergencyDrillEvaluationFileInfo.setDrillEvaluationId(DrillEvaluationId);
                addList.add(emergencyDrillEvaluationFileInfo);
            }
            //如果存在id则判断页面是否删除
            else {
                newIdsList.add(emergencyDrillEvaluationFileReqDTO.getId());
            }
        }
        for (Long oldId : oldIdsList) {
            if (!newIdsList.contains(oldId)) {
                deleteList.add(oldId);
            }
        }
        if (!CollectionUtils.isEmpty(addList)) {
            for (EmergencyDrillEvaluationFileInfo emergencyDrillEvaluationFileInfo : addList) {
                emergencyDrillEvaluationFileInfoService.addEmergencyDrillEvaluationFile(emergencyDrillEvaluationFileInfo);
            }
        }
        if (!CollectionUtils.isEmpty(deleteList)) {
            emergencyDrillEvaluationFileInfoService.deleteEmergencyDrillEvaluationFileByIds(deleteList);
        }
    }
 
    private void updateEmergencyDrillEvaluationUser(Long uid, Long DrillEvaluationId, Date
            nowDate, List<EmergencyDrillEvaluationUserReqDTO> UserReqDTOList) {
        List<EmergencyDrillEvaluationUserInfoDO> emergencyDrillEvaluationUserInfoDOList = emergencyDrillEvaluationUserInfoService.selectEmergencyDrillEvaluationUserByDrillEvaluationId(DrillEvaluationId);
        List<Long> oldIdsList = emergencyDrillEvaluationUserInfoDOList.stream().map(EmergencyDrillEvaluationUserInfoDO::getId).collect(Collectors.toList());
        List<Long> newIdsList = new ArrayList<>();
 
        //新增的区域集合
        List<EmergencyDrillEvaluationUserInfo> addList = new ArrayList<>();
        //删除的区域集合(id)
        List<Long> deleteList = new ArrayList<>();
        for (EmergencyDrillEvaluationUserReqDTO emergencyDrillEvaluationUserReqDTO : UserReqDTOList) {
            //如果不存在id则表示页面新增的附件
            if (emergencyDrillEvaluationUserReqDTO.getId() == null) {
                EmergencyDrillEvaluationUserInfo emergencyDrillEvaluationUserInfo = new EmergencyDrillEvaluationUserInfo();
                BeanUtils.copyProperties(emergencyDrillEvaluationUserReqDTO, emergencyDrillEvaluationUserInfo);
                emergencyDrillEvaluationUserInfo.setDelFlag(false);
                emergencyDrillEvaluationUserInfo.setGmtCreate(nowDate);
                emergencyDrillEvaluationUserInfo.setCreateUid(uid);
                emergencyDrillEvaluationUserInfo.setDrillEvaluationId(DrillEvaluationId);
                addList.add(emergencyDrillEvaluationUserInfo);
            }
            //如果存在id则判断页面是否删除
            else {
                newIdsList.add(emergencyDrillEvaluationUserReqDTO.getId());
            }
        }
        for (Long oldId : oldIdsList) {
            if (!newIdsList.contains(oldId)) {
                deleteList.add(oldId);
            }
        }
        if (!CollectionUtils.isEmpty(addList)) {
            for (EmergencyDrillEvaluationUserInfo emergencyDrillEvaluationUserInfo : addList) {
                emergencyDrillEvaluationUserInfoService.addEmergencyDrillEvaluationUser(emergencyDrillEvaluationUserInfo);
            }
        }
        if (!CollectionUtils.isEmpty(deleteList)) {
            emergencyDrillEvaluationUserInfoService.deleteEmergencyDrillEvaluationUserByIds(deleteList);
        }
    }
 
    @Override
    public ResultVO batchDeleteEmergencyDrillEvaluation(Long[] ids) {
 
        if (ids == null ||  ids.length==0){
            throw new EmergencyException(EmergencyResultCodes.DRILL_EVALUATION_NULL);
        }else{
            for (Long id : ids){
                deleteEmergencyDrillEvaluation(id);
            }
            return new ResultVO(ResultCodes.OK);
        }
    }
 
    private void deleteEmergencyDrillEvaluation(Long id) {
        //查询是否存在
        EmergencyDrillEvaluationInfoDetailDO emergencyDrillEvaluationInfoDetailDO = emergencyDrillEvaluationInfoService.selectEmergencyDrillEvaluationByExecuteId(id);
        if (emergencyDrillEvaluationInfoDetailDO == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_EVALUATION_NOT_EXIST);
        } else {
            Long DrillEvaluationId = emergencyDrillEvaluationInfoDetailDO.getId();
            emergencyDrillEvaluationInfoService.deleteEmergencyDrillEvaluation(DrillEvaluationId);
            //删除附件
            emergencyDrillEvaluationFileInfoService.deleteEmergencyDrillEvaluationFileByDrillEvaluationId(DrillEvaluationId);
            //删除应急队伍
            emergencyDrillEvaluationUserInfoService.deleteEmergencyDrillEvaluationUserByDrillEvaluationId(DrillEvaluationId);
        }
    }
 
 
    /**
     *
     * 枚举类验证
     * @param emergencyDrillEvaluationReqDTO
     */
    public void checkEnum(EmergencyDrillEvaluationReqDTO emergencyDrillEvaluationReqDTO) {
        if (DrillEvaluationSuitableEnum.getByCode(emergencyDrillEvaluationReqDTO.getSuitable()) == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_EVALUATION_ENUM_SUITABLE_NOT_EXIST);
        }
        if (DrillEvaluationSufficientEnum.getByCode(emergencyDrillEvaluationReqDTO.getSufficient()) == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_EVALUATION_ENUM_SUFFICIENT_NOT_EXIST);
        }
        if (DrillEvaluationArrivalEnum.getByCode(emergencyDrillEvaluationReqDTO.getArrival()) == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_EVALUATION_ENUM_ARRIVAL_NOT_EXIST);
        }
        if (DrillEvaluationSuppliesEnum.getByCode(emergencyDrillEvaluationReqDTO.getSupplies()) == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_EVALUATION_ENUM_SUPPLIES_NOT_EXIST);
        }
        if (DrillEvaluationProtectionEnum.getByCode(emergencyDrillEvaluationReqDTO.getProtection()) == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_EVALUATION_ENUM_PROTECTION_NOT_EXIST);
        }
        if (DrillEvaluationWholeEnum.getByCode(emergencyDrillEvaluationReqDTO.getWhole()) == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_EVALUATION_ENUM_WHOLE_NOT_EXIST);
        }
        if (DrillEvaluationDivisionEnum.getByCode(emergencyDrillEvaluationReqDTO.getDivision()) == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_EVALUATION_ENUM_DIVISION_NOT_EXIST);
        }
        if (DrillEvaluationEffectEnum.getByCode(emergencyDrillEvaluationReqDTO.getEffect()) == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_EVALUATION_ENUM_EFFECT_NOT_EXIST);
        }
        if (DrillEvaluationReportEnum.getByCode(emergencyDrillEvaluationReqDTO.getReport()) == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_EVALUATION_ENUM_REPORT_NOT_EXIST);
        }
        if (DrillEvaluationSafetyEnum.getByCode(emergencyDrillEvaluationReqDTO.getSafety()) == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_EVALUATION_ENUM_SAFETY_NOT_EXIST);
        }
        if (DrillEvaluationRescueEnum.getByCode(emergencyDrillEvaluationReqDTO.getRescue()) == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_EVALUATION_ENUM_RESCUE_NOT_EXIST);
        }
        if (DrillEvaluationEvacuateEnum.getByCode(emergencyDrillEvaluationReqDTO.getEvacuate()) == null) {
            throw new EmergencyException(EmergencyResultCodes.DRILL_EVALUATION_ENUM_EVACUATE_NOT_EXIST);
        }
    }
}