package com.gkhy.safePlatform.doublePrevention.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.gkhy.safePlatform.account.rpc.apimodel.AccountAuthService;
import com.gkhy.safePlatform.account.rpc.apimodel.AccountDepartmentService;
import com.gkhy.safePlatform.account.rpc.apimodel.model.resp.DepInfoRPCRespDTO;
import com.gkhy.safePlatform.account.rpc.apimodel.model.resp.UserRPCRespDTO;
import com.gkhy.safePlatform.commons.enums.E;
import com.gkhy.safePlatform.commons.enums.ResultCodes;
import com.gkhy.safePlatform.commons.exception.AusinessException;
import com.gkhy.safePlatform.commons.exception.BusinessException;
import com.gkhy.safePlatform.commons.utils.BeanCopyUtils;
import com.gkhy.safePlatform.commons.utils.idService.SnowFlow;
import com.gkhy.safePlatform.commons.vo.ResultVO;
import com.gkhy.safePlatform.doublePrevention.entity.*;
import com.gkhy.safePlatform.doublePrevention.entity.dto.req.*;
import com.gkhy.safePlatform.doublePrevention.entity.dto.resp.PreventDangerManageListQueryRespDTO;
import com.gkhy.safePlatform.doublePrevention.entity.dto.resp.PreventDangerManageQueryRespDTO;
import com.gkhy.safePlatform.doublePrevention.entity.dto.resp.PreventDangerRectifyQueryRespDTO;
import com.gkhy.safePlatform.doublePrevention.enums.StatusEnum;
import com.gkhy.safePlatform.doublePrevention.enums.SyncEnum;
import com.gkhy.safePlatform.doublePrevention.enums.WorkStatusEnum;
import com.gkhy.safePlatform.doublePrevention.repository.param.*;
import com.gkhy.safePlatform.doublePrevention.service.RectifyService;
import com.gkhy.safePlatform.doublePrevention.service.baseService.*;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.dubbo.config.annotation.DubboReference;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@Service
public class RectifyServiceImpl implements RectifyService {

    @DubboReference(check = false)
    private AccountAuthService accountAuthService;
    @DubboReference(check = false)
    private AccountDepartmentService accountDepartmentService;

    @Autowired
    private RedissonClient redissonClient;

    @Autowired
    private PreventDangerManageService preventDangerManageService;
    @Autowired
    private PreventDangerRectifyService preventDangerRectifyService;
    @Autowired
    private PreventDangerCheckTaskService preventDangerCheckTaskService;
    @Autowired
    private PreventProduceDeviceService preventProduceDeviceService;
    @Autowired
    private PreventDangerCheckTaskUnitService preventDangerCheckTaskUnitService;
    @Autowired
    private PreventReportConfigService preventReportConfigService;
    @Autowired
    private PreventRiskAnaUnitService preventRiskAnaUnitService;
    @Autowired
    private PreventDangerManageTimeoutService preventDangerManageTimeoutService;

    //隐患治理清单
    /**
     * 隐患治理清单-分页查询
     */
    @Override
    public ResultVO<PreventDangerManage> getDangerManagePage(Long userId, PreventDangerManageQueryReqDTO manageQueryReqDTO) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("查询成功");

        List<PreventDangerManageQueryRespDTO> list = new ArrayList<>();
        Integer pageIndex = manageQueryReqDTO.getPageIndex();
        Integer pageSize = manageQueryReqDTO.getPageSize();

        //获取用户信息
        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
        if (rpcResult == null) {
            throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
        }
        if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
            throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
        }
        if (rpcResult.getData() == null) {
            throw new BusinessException(ResultCodes.RPC_DATA_NULL);
        }
        if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
            throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
        }
        UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();
        if (ObjectUtils.isEmpty(userById)) {
            throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
        }
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
        //获取到所有符合条件的隐患治理清单信息
        IPage<PreventDangerManage> page =
                preventDangerManageService.getDangerManagePage(new Page<>(pageIndex, pageSize), manageQueryReqDTO);
        if (ObjectUtils.isEmpty(page.getRecords())){
            resultVO.setMsg("查询成功,无数据");
            return resultVO;
        }
        //遍历结果集，封装数据
        for (PreventDangerManage record : page.getRecords()) {
            PreventDangerManageQueryRespDTO respDTO = BeanCopyUtils.copyBean(record, PreventDangerManageQueryRespDTO.class);
            respDTO.setPageIndex((int) page.getCurrent());
            respDTO.setPageSize((int) page.getSize());
            PreventProduceDevice deviceById = preventProduceDeviceService.getDeviceById(record.getProduceDeviceId());
            if (ObjectUtils.isNotEmpty(deviceById)){
                respDTO.setProduceDeviceName(deviceById.getProduceDeviceName());
            }

            PreventRiskAnaUnit riskUnitById = preventRiskAnaUnitService.getRiskUnitById(record.getRiskUnitId());
            if (ObjectUtils.isNotEmpty(riskUnitById)){
                respDTO.setRiskUnitName(riskUnitById.getRiskUnitName());
            }
            PreventDangerRectify rectifyByManageId = preventDangerRectifyService.getRectifyByManageId(record.getId());
            if (ObjectUtils.isNotEmpty(rectifyByManageId)){
                //获取责任人信息
                ResultVO<UserRPCRespDTO> liablePersonResult = accountAuthService.getUserById(rectifyByManageId.getLiablePersonId());
                UserRPCRespDTO liablePerson = (UserRPCRespDTO)liablePersonResult.getData();
                if (rectifyByManageId.getCost() != null){
                    respDTO.setCost(rectifyByManageId.getCost());
                }
                if (rectifyByManageId.getRectifyDesc() != null){
                    respDTO.setRectifyDesc(rectifyByManageId.getRectifyDesc());
                }
                if (rectifyByManageId.getRectifyInfo() != null){
                    respDTO.setRectifyInfo(rectifyByManageId.getRectifyInfo());
                }
                if (rectifyByManageId.getCheckAcceptPersonId() != null){
                    respDTO.setCheckAcceptPersonId(rectifyByManageId.getCheckAcceptPersonId());
                    respDTO.setCheckAcceptTime(rectifyByManageId.getCheckAcceptTime());
                    respDTO.setCheckAcceptPerson(rectifyByManageId.getCheckAcceptPerson());
                    respDTO.setCheckAcceptDesc(rectifyByManageId.getCheckAcceptDesc());
                    respDTO.setLiablePersonId(rectifyByManageId.getLiablePersonId());
                }
                respDTO.setRectifyTime(rectifyByManageId.getRectifyTime());
                respDTO.setRectifyType(rectifyByManageId.getRectifyType());
                respDTO.setRectifyDepId(rectifyByManageId.getRectifyDepId());
                respDTO.setLiablePersonId(rectifyByManageId.getLiablePersonId());
                respDTO.setLastEditUserName(rectifyByManageId.getLiablePerson());
                respDTO.setRectifyDepId(rectifyByManageId.getRectifyDepId());
                respDTO.setTimeOutDesc(respDTO.getTimeOutDesc());
                respDTO.setRectifyDepName(liablePerson.getDepartment().getDepName());
                respDTO.setRectifyId(rectifyByManageId.getId());
            }
            PreventDangerManageTimeout timeoutResult = preventDangerManageTimeoutService.getByManageId(record.getId());
            if (ObjectUtils.isNotEmpty(timeoutResult)){
                respDTO.setTimeoutStatus(timeoutResult.getTimeoutStatus());
            }
            respDTO.setReportState(reportConfigById.getReportState());
            respDTO.setReportType(reportConfigById.getReportType());
            respDTO.setDepName(userById.getDepartment().getDepName());
            list.add(respDTO);
        }
        resultVO.setData(list);
        resultVO.setCount((int) page.getTotal());

        return resultVO;
    }
    /**
     * 隐患治理清单-列表
     */
    @Override
    public ResultVO<PreventDangerManage> listDangerManage(Long valueOf) {
        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("查询成功");

        List<PreventDangerManage> dangerManages = preventDangerManageService.listDangerManage();
        List<PreventDangerManageListQueryRespDTO> respDTOS =
                BeanCopyUtils.copyBeanList(dangerManages, PreventDangerManageListQueryRespDTO.class);

        resultVO.setData(respDTOS);
        return resultVO;
    }
    /**
     * 隐患管理-手工上报-配置
     */
    @Override
    public ResultVO<PreventRiskAnaUnit> updateDangerManagerReport(Long userId, PreventHandReportConfigReqDTO preventHandReportConfigReqDTO) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("修改上报数据成功");

        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
        if (rpcResult == null) {
            throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
        }
        if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
            throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
        }
        if (rpcResult.getData() == null) {
            throw new BusinessException(ResultCodes.RPC_DATA_NULL);
        }
        if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
            throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
        }
        if (preventHandReportConfigReqDTO.getId() == null){
            throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "传参非法");
        }
        if (preventHandReportConfigReqDTO.getReportSwitch() == null){
            throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "传参非法");
        }
        //查询当前隐患的配置
        PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(preventHandReportConfigReqDTO.getId());
        //配置相同，做处理
        if (dangerManageById.getReportSwitch() == preventHandReportConfigReqDTO.getReportSwitch()){
            throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "与当前配置相同");
        }
        int result ;
        //读取主配置信息
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
        //只有当开启上报，且类型为手动上报时，可以修改
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_AUTO_EXEC_CONFIG.getCode()){
            result = preventDangerManageService.updateDangerManagerReport(preventHandReportConfigReqDTO);

        }else {
            throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "当前上报配置，不支持对单条数据操作");
        }
        resultVO.setCount(result);
        return resultVO;
    }

    /**
     * 隐患治理清单-新增
     */
    @Transactional
    @Override
    public ResultVO<PreventDangerManage> saveDangerManage(Long userId, PreventDangerManageSaveReqDTO manageSaveReqDTO) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("新增成功");

        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
        if (rpcResult == null) {
            throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
        }
        if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
            throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
        }
        if (rpcResult.getData() == null) {
            throw new BusinessException(ResultCodes.RPC_DATA_NULL);
        }
        if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
            throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
        }
        UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();

        if (ObjectUtils.isEmpty(userById)) {
            throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
        }
        //校验参数
        if (manageSaveReqDTO.getDangerLevel() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "隐患等级不能为空");
        }
        if (manageSaveReqDTO.getDangerType() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "隐患类型不能为空");
        }
        if (manageSaveReqDTO.getDepId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "隐患所属部门不能为空");
        }
        if (manageSaveReqDTO.getDangerCode() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "隐患名称不能为空");
        }
        //校验部门是否存在
        ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(userId, manageSaveReqDTO.getDepId());
        if(ObjectUtils.isEmpty(depInfoByDepId)){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确责任部门");
        }
        if (manageSaveReqDTO.getRiskUnitId() != null){
            PreventRiskAnaUnit riskUnitById = preventRiskAnaUnitService.getRiskUnitById(manageSaveReqDTO.getRiskUnitId());
            if(ObjectUtils.isEmpty(riskUnitById)){
                throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确的风险分析单元");
            }
        }

        if (manageSaveReqDTO.getProduceDeviceId() != null){
            PreventProduceDevice deviceById =
                    preventProduceDeviceService.getDeviceById(manageSaveReqDTO.getProduceDeviceId());
            if (ObjectUtils.isEmpty(deviceById)){
                throw new AusinessException(E.DATA_PARAM_NULL, "请填写正确的生产装置");
            }
            PreventRiskAnaUnit riskUnitById = preventRiskAnaUnitService.getRiskUnitById(manageSaveReqDTO.getRiskUnitId());
            if (ObjectUtils.isNotEmpty(riskUnitById)){
                if (!riskUnitById.getProduceDeviceId().equals(manageSaveReqDTO.getProduceDeviceId())){
                    throw new AusinessException(E.DATA_PARAM_NULL, "请填写生产装置对应的分析单元");
                }
            }else if (ObjectUtils.isEmpty(riskUnitById)){
                throw new AusinessException(E.DATA_PARAM_NULL, "请填写生产装置对应的分析单元");
            }
        }
        if (manageSaveReqDTO.getRectifyType() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改类型不能为空");
        }
        if (manageSaveReqDTO.getDangerResult() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "隐患可能造成的后果不能为空");
        }
        if (manageSaveReqDTO.getLiablePersonId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改责任人不能为空");
        }
        //责任人信息
        ResultVO<UserRPCRespDTO> execUserResult = accountAuthService.getUserById(manageSaveReqDTO.getLiablePersonId());
        UserRPCRespDTO liableUser = (UserRPCRespDTO)execUserResult.getData();
        if (ObjectUtils.isEmpty(liableUser)){
            throw new AusinessException(E.DATA_PARAM_NULL, "该责任人不存在或已被删除，请选择正确的责任人");
        }
        if (manageSaveReqDTO.getRectifyTime() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改期限不能为空");
        }
        if (manageSaveReqDTO.getRectifyDepId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改部门不能为空");
        }
        if (!manageSaveReqDTO.getRectifyDepId().equals(liableUser.getDepartment().getDepId())){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改人不属于该部门");
        }

        //获取需要填充的信息
        SnowFlow snowFlow = new SnowFlow();//雪花算法生成器
        String uuid = UUID.randomUUID().toString();
        Date date = new Date();
        long dangerManagerId = snowFlow.nextId();
        //读取上报主配置
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
        /**设置隐患管理表参数*/
        PreventDangerManage dangerManage = BeanCopyUtils.copyBean(manageSaveReqDTO, PreventDangerManage.class);
        dangerManage.setId(dangerManagerId);
        dangerManage.setUuid(uuid);
        dangerManage.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());
        dangerManage.setGmtCreate(date);
        dangerManage.setGmtModitify(date);
        dangerManage.setCreateByUserName(userById.getRealName());
        dangerManage.setLastEditUserName(userById.getRealName());
        dangerManage.setEnterpriseId((long) 1);
        dangerManage.setEnterpriseUuid("123124134");
        dangerManage.setDangerStatus(StatusEnum.DANGER_MANAGER_RECTIFY.getCode());
        dangerManage.setDangerReview(StatusEnum.DANGER_RECTIFY_WAIT.getCode());
        dangerManage.setDangerCode(manageSaveReqDTO.getDangerCode());
        dangerManage.setDangerCloseReason(null);
        //这暂时不用字段
        dangerManage.setTaskId(null);
        dangerManage.setRegistantId(null);
        dangerManage.setRegisterTime(null);
        dangerManage.setRegistantName(null);

        /**设置隐患整改验收表的参数*/
        //获取需要填充的信息
        String RectifyUuid = UUID.randomUUID().toString();
        long rectifyId = snowFlow.nextId();
        //封装参数
        PreventDangerRectify dangerRectify = BeanCopyUtils.copyBean(manageSaveReqDTO, PreventDangerRectify.class);
        dangerRectify.setId(rectifyId);
        dangerRectify.setUuid(RectifyUuid);
        dangerRectify.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());
        dangerRectify.setGmtCreate(date);
        dangerRectify.setCreateByUserName(userById.getRealName());
        dangerRectify.setGmtModitify(date);
        dangerRectify.setLastEditUserName(userById.getRealName());
        dangerRectify.setEnterpriseId((long) 1);
        dangerRectify.setEnterpriseUuid("1564wq");
        dangerRectify.setDangerManagerUuid(uuid);
        dangerRectify.setDangerManagerId(dangerManagerId);
        dangerRectify.setLiablePerson(liableUser.getRealName());
        dangerRectify.setDangerCode(null);
        dangerRectify.setApplyTime(null);
        dangerRectify.setTimeOutDesc(null);
        dangerRectify.setRectifyInfo(null);
        dangerRectify.setCheckAcceptPerson(userById.getRealName());
        dangerRectify.setRectifyDepId(manageSaveReqDTO.getRectifyDepId());
        dangerRectify.setDangerReview(StatusEnum.DANGER_RECTIFY_WAIT.getCode());
        dangerRectify.setCheckAcceptPersonId(userId);
        dangerRectify.setCheckAcceptPerson(userById.getRealName());
        // 不确定是否需要的字段
        dangerRectify.setCheckAcceptTime(null);
        dangerRectify.setCheckAcceptDesc(null);
        //设置上报时间为空，以隐患管理表为主，同时设置上报
        dangerManage.setReportTime(null);
        dangerRectify.setReportTime(null);
        //设置本条数据上报更新时间
        dangerManage.setUpdateReportDataTime(new Date());
        dangerRectify.setUpdateReportDataTime(new Date());
        //读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
            //设置上报状态为-等待上报
            dangerManage.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
            dangerRectify.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
            //设置本条数据上报开关为-开启
            dangerManage.setReportSwitch(SyncEnum.REPORT_ON.getCode());
            //其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作
        }else {
            //设置上报状态为-不上报
            dangerManage.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
            dangerRectify.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
            //设置本条数据上报开关为-关闭
            dangerManage.setReportSwitch(SyncEnum.REPORT_OFF.getCode());
        }

        /**设置是否延期状态参数*/
        PreventDangerManageTimeout manageTimeout = new PreventDangerManageTimeout();
        manageTimeout.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());
        manageTimeout.setTimeoutStatus(StatusEnum.DANGER_ON_TIME_RECTIFY.getCode());
        manageTimeout.setDangerRectifyId(rectifyId);
        manageTimeout.setDangerManagerId(dangerManagerId);

        //生成隐患编码
        LocalDateTime t = dangerManage.getGmtCreate().toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
        LocalDate localDate = t.toLocalDate();
        LocalDateTime startTime = LocalDateTime.of(localDate, LocalTime.of(0,0,0));
        LocalDateTime endTime = LocalDateTime.of(localDate, LocalTime.of(23,59,59));
        Date start = Date.from(startTime.atZone(ZoneId.systemDefault()).toInstant());
        Date end = Date.from(endTime.atZone(ZoneId.systemDefault()).toInstant());
        //1、加分布式锁
        String lockName = "LOCK_DANGER_CODE_GENERATE";
        RLock lock = redissonClient.getLock(lockName);
        lock.lock(3, TimeUnit.SECONDS);
        int count = -1;
        try {
            count = preventDangerManageService.countByCreateTime(start,end);
        } catch (Exception e) {
            lock.unlock();
            throw new AusinessException(E.ADD_FAIL, "保存隐患整改信息失败");
        }
        //2、生成编码
        String serialCode = generateDangerSerialCode(dangerManage.getGmtCreate(),count);
        if(serialCode == null || serialCode.isEmpty()){
            throw new AusinessException(E.ADD_FAIL, "保存隐患整改信息失败");
        }
        dangerManage.setSerialCode(serialCode);

        int step = 1;
        //保存隐患管理信息
        if (step == 1){
            int resultManage = preventDangerManageService.saveDangerManage(dangerManage);
            if (resultManage < 1){
                throw new AusinessException(E.ADD_FAIL, "保存隐患管理信息失败");
            }else {
                step = 2;
            }
        }
        //保存隐患整改信息
        if (step == 2){
            int resultRectify = preventDangerRectifyService.saveDangerRectify(dangerRectify);
            if (resultRectify < 1){
                throw new AusinessException(E.ADD_FAIL, "保存隐患整改信息失败");
            }else {
                step = 3;
            }
        }
        //保存延期状态
        if (step == 3){
            int resultTimeout = preventDangerManageTimeoutService.insert(manageTimeout);
            if (resultTimeout < 1){
                throw new AusinessException(E.ADD_FAIL, "保存隐患整改信息失败");
            }
        }
        //3、释放生成编码锁
        lock.unlock();
        return resultVO;
    }

    /**
     * 隐患管理清单-修改
     */
    @Transactional
    @Override
    public ResultVO<PreventDangerManage> updateDangerManage(Long userId, PreventDangerManageUpdateReqDTO manageUpdateReqDTO) {
        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("修改成功");

        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
        if (rpcResult == null) {
            throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
        }
        if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
            throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
        }
        if (rpcResult.getData() == null) {
            throw new BusinessException(ResultCodes.RPC_DATA_NULL);
        }
        if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
            throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
        }
        UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();

        if (ObjectUtils.isEmpty(userById)) {
            throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
        }
        //校验参数
        if (manageUpdateReqDTO.getId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "传参非法");
        }
        if (manageUpdateReqDTO.getDangerLevel() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "隐患等级不能为空");
        }
        if (manageUpdateReqDTO.getDangerType() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "隐患类型不能为空");
        }
        if (manageUpdateReqDTO.getDangerSource() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "隐患来源不能为空");
        }
        if (manageUpdateReqDTO.getDepId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "隐患所属部门不能为空");
        }
        //校验部门是否存在
        ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(userId, manageUpdateReqDTO.getDepId());
        if(ObjectUtils.isEmpty(depInfoByDepId)){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确责任部门");
        }
        if (manageUpdateReqDTO.getRiskUnitId() != null){
            PreventRiskAnaUnit riskUnitById = preventRiskAnaUnitService.getRiskUnitById(manageUpdateReqDTO.getRiskUnitId());
            if(ObjectUtils.isEmpty(riskUnitById)){
                throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确的风险分析单元");
            }
        }
        if (manageUpdateReqDTO.getProduceDeviceId() != null){
            PreventProduceDevice deviceById =
                    preventProduceDeviceService.getDeviceById(manageUpdateReqDTO.getProduceDeviceId());
            if (ObjectUtils.isEmpty(deviceById)){
                throw new AusinessException(E.DATA_PARAM_NULL, "请填写正确的生产装置");
            }
            PreventRiskAnaUnit riskUnitById = preventRiskAnaUnitService.getRiskUnitById(manageUpdateReqDTO.getRiskUnitId());
            if (!riskUnitById.getProduceDeviceId().equals(manageUpdateReqDTO.getProduceDeviceId())){
                throw new AusinessException(E.DATA_PARAM_NULL, "请填写生产装置对应的分析单元");
            }
        }
        if (manageUpdateReqDTO.getRectifyType() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改类型不能为空");
        }
        if (manageUpdateReqDTO.getLiablePersonId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改责任人不能为空");
        }
        if (manageUpdateReqDTO.getRectifyDepId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改部门不能为空");
        }
        //责任人信息
        ResultVO<UserRPCRespDTO> execUserResult = accountAuthService.getUserById(manageUpdateReqDTO.getLiablePersonId());
        UserRPCRespDTO liableUser = (UserRPCRespDTO)execUserResult.getData();

        Date date = new Date();
        //读取上报主配置
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
        //封装隐患管理参数
        PreventDangerRectify rectifyByManageId = preventDangerRectifyService.getRectifyByManageId(manageUpdateReqDTO.getId());
        PreventDangerManageUpdateParams updateParams = BeanCopyUtils.copyBean(manageUpdateReqDTO, PreventDangerManageUpdateParams.class);
        updateParams.setLastEditUserName(userById.getRealName());
        updateParams.setGmtModitify(date);
        //封装隐患整改参数
        //PreventDangerRectifyUpdateParams rectifyUpdateParams = new PreventDangerRectifyUpdateParams();
        PreventDangerRectifyUpdateParams rectifyUpdateParams = BeanCopyUtils.copyBean(manageUpdateReqDTO, PreventDangerRectifyUpdateParams.class);
        rectifyUpdateParams.setLastEditUserName(userById.getRealName());
        rectifyUpdateParams.setGmtModitify(date);
        rectifyUpdateParams.setLiablePerson(liableUser.getRealName());
        rectifyUpdateParams.setId(rectifyByManageId.getId());

        //设置本条数据上报更新时间
        rectifyUpdateParams.setUpdateReportDataTime(date);
        updateParams.setUpdateReportDataTime(date);
        //读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
            //设置上报状态为-等待上报
            updateParams.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
            rectifyUpdateParams.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
            //设置本条数据上报开关为-开启
            updateParams.setReportSwitch(SyncEnum.REPORT_ON.getCode());
            //其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作
        }else {
            //设置上报状态为-不上报
            updateParams.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
            rectifyUpdateParams.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
            //设置本条数据上报开关为-关闭
            updateParams.setReportSwitch(SyncEnum.REPORT_OFF.getCode());
        }
        int rectifyResult = preventDangerRectifyService.updateDangerRectify(rectifyUpdateParams);
        if (rectifyResult < 1){
            throw new AusinessException(E.UPDATE_FAIL, "修改隐患整改信息失败");
        }

        int result = preventDangerManageService.updateDangerManage(updateParams);
        if (rectifyResult < 1){
            throw new AusinessException(E.UPDATE_FAIL, "修改管理整改信息失败");
        }
        resultVO.setCount(result);
        return resultVO;
    }

    /**
     * 隐患治理清单-删除
     */
    @Override
    public ResultVO<PreventDangerManage> deleteDangerManage(Long userId, PreventDangerManageDeleteReqDTO manageDeleteReqDTO) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("删除成功");
        PreventDeleteParams deleteParams = new PreventDeleteParams();

        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
        if (rpcResult == null) {
            throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
        }
        if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
            throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
        }
        if (rpcResult.getData() == null) {
            throw new BusinessException(ResultCodes.RPC_DATA_NULL);
        }
        if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
            throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
        }
        UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();

        if (ObjectUtils.isEmpty(userById)) {
            throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
        }
        //校验参数
        if (manageDeleteReqDTO.getId() == null ){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "请选择正确的删除内容");
        }
        PreventDangerRectify rectifyByManageId = preventDangerRectifyService.getRectifyByManageId(manageDeleteReqDTO.getId());
        if (ObjectUtils.isNotEmpty(rectifyByManageId)){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "需要先删除对应的隐患整改");
        }
        //获取需要填充的信息
        Date date = new Date();
        //封装删除需要的参数
        deleteParams.setId(manageDeleteReqDTO.getId());
        deleteParams.setGmtModitify(date);
        deleteParams.setLastEditUserName(userById.getRealName());
        deleteParams.setUpdateReportDataTime(date);

        int result = preventDangerManageService.deleteDangerManage(deleteParams);

        resultVO.setCount(result);

        return resultVO;
    }

    //隐患整改清单
    /**
     * 隐患整改清单-分页查询
     */
    @Override
    public ResultVO<PreventDangerRectify> getDangerRectifyPage(Long userId, PreventDangerRectifyQueryReqDTO rectifyQueryReqDTO) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("查询成功");

        List<PreventDangerRectifyQueryRespDTO> list = new ArrayList<>();
        Integer pageIndex = rectifyQueryReqDTO.getPageIndex();
        Integer pageSize = rectifyQueryReqDTO.getPageSize();

        //获取用户信息
        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
        if (rpcResult == null) {
            throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
        }
        if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
            throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
        }
        if (rpcResult.getData() == null) {
            throw new BusinessException(ResultCodes.RPC_DATA_NULL);
        }
        if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
            throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
        }
        UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();

        if (ObjectUtils.isEmpty(userById)) {
            throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
        }

        //读取上报主配置
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_ANA_UNIT.getCode());
        //获取到所有符合条件的隐患治理清单信息
        Page pageInfo = new Page<>(pageIndex, pageSize);
        pageInfo.setOptimizeCountSql(false);
        IPage<PreventDangerRectify> page =
                preventDangerRectifyService.getDangerRectifyPage(pageInfo, rectifyQueryReqDTO);
        if (ObjectUtils.isEmpty(page.getRecords())){
            resultVO.setMsg("查询成功,无数据");
            return resultVO;
        }
        //遍历结果集，封装数据
        for (PreventDangerRectify record : page.getRecords()) {
            PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(record.getDangerManagerId());
            if (rectifyQueryReqDTO.getDangerStatus() != null){
                if(dangerManageById.getDangerStatus().equals(rectifyQueryReqDTO.getDangerStatus())){
                    PreventDangerManageTimeout timeoutResult = preventDangerManageTimeoutService.getByRectifyId(record.getId());
                    PreventDangerRectifyQueryRespDTO respDTO = BeanCopyUtils.copyBean(record, PreventDangerRectifyQueryRespDTO.class);
                    //添加部门名称
                    ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(userId, respDTO.getRectifyDepId());
                    DepInfoRPCRespDTO data = (DepInfoRPCRespDTO)depInfoByDepId.getData();
                    if (ObjectUtils.isNotEmpty(timeoutResult)){
                        respDTO.setTimeoutStatus(timeoutResult.getTimeoutStatus());
                    }
                    respDTO.setSerialCode(dangerManageById.getSerialCode());
                    respDTO.setRectifyDepName(data.getDepName());
                    respDTO.setDangerStatus(dangerManageById.getDangerStatus());
                    respDTO.setDangerManagerId(dangerManageById.getId());
                    respDTO.setReportState(reportConfigById.getReportState());
                    respDTO.setReportType(reportConfigById.getReportType());
                    respDTO.setDangerCode(dangerManageById.getDangerCode());
                    list.add(respDTO);
                    respDTO.setPageIndex(list.indexOf(respDTO));
                    respDTO.setPageSize(pageSize);
                }
            }else {
                PreventDangerManageTimeout timeoutResult = preventDangerManageTimeoutService.getByRectifyId(record.getId());
                PreventDangerRectifyQueryRespDTO respDTO = BeanCopyUtils.copyBean(record, PreventDangerRectifyQueryRespDTO.class);
                //添加部门名称
                ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(userId, respDTO.getRectifyDepId());
                DepInfoRPCRespDTO data = (DepInfoRPCRespDTO)depInfoByDepId.getData();
                if (ObjectUtils.isNotEmpty(timeoutResult)){
                    respDTO.setTimeoutStatus(timeoutResult.getTimeoutStatus());
                }
                if (ObjectUtils.isNotEmpty(dangerManageById.getSerialCode())){
                    respDTO.setSerialCode(dangerManageById.getSerialCode());
                }
                respDTO.setSerialCode(dangerManageById.getSerialCode());
                respDTO.setRectifyDepName(data.getDepName());
                respDTO.setDangerStatus(dangerManageById.getDangerStatus());
                respDTO.setPageIndex(pageSize);
                respDTO.setPageSize((int) page.getCurrent());
                respDTO.setDangerManagerId(dangerManageById.getId());
                respDTO.setReportState(reportConfigById.getReportState());
                respDTO.setReportType(reportConfigById.getReportType());
                list.add(respDTO);
                resultVO.setCount((int) page.getTotal());
            }
        }

        resultVO.setData(list);
        resultVO.setCount((int) page.getTotal());
        return resultVO;
    }


    /**
     * 隐患整改清单-查询:待验收与已验收
     */
    @Override
    public ResultVO<PreventDangerRectify> getRectifyOverPage(Long userId, PreventRectifyOverQueryReqDTO rectifyOverQueryReqDTO) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("查询成功");

        List<PreventDangerRectifyQueryRespDTO> list = new ArrayList<>();
        Integer pageIndex = rectifyOverQueryReqDTO.getPageIndex();
        Integer pageSize = rectifyOverQueryReqDTO.getPageSize();

        //获取用户信息
        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
        if (rpcResult == null) {
            throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
        }
        if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
            throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
        }
        if (rpcResult.getData() == null) {
            throw new BusinessException(ResultCodes.RPC_DATA_NULL);
        }
        if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
            throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
        }
        UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();

        if (ObjectUtils.isEmpty(userById)) {
            throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
        }
        if (ObjectUtils.isEmpty(rectifyOverQueryReqDTO.getDangerStatus())){
            rectifyOverQueryReqDTO.setStatus(StatusEnum.DELETE_STATUS_USE.getCode());
        }else {
            rectifyOverQueryReqDTO.setStatus(null);
        }

        //读取上报主配置
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_ANA_UNIT.getCode());
        Page pageInfo = new Page<>(pageIndex, pageSize);
        pageInfo.setOptimizeCountSql(false);
        IPage<PreventDangerRectify> page = preventDangerRectifyService.getDangerRectifyPageToOverRectify(pageInfo, rectifyOverQueryReqDTO);
        if (ObjectUtils.isEmpty(page)){
            resultVO.setMsg("查询成功,无数据");
            return resultVO;
        }
        for (PreventDangerRectify record : page.getRecords()) {
            PreventDangerRectifyQueryRespDTO respDTO = BeanCopyUtils.copyBean(record, PreventDangerRectifyQueryRespDTO.class);
            PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(record.getDangerManagerId());
            PreventDangerManageTimeout timeoutResult = preventDangerManageTimeoutService.getByRectifyId(record.getId());
            //添加部门名称
            ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(userId, respDTO.getRectifyDepId());
            if (ObjectUtils.isNotEmpty(timeoutResult)){
                respDTO.setTimeoutStatus(timeoutResult.getTimeoutStatus());
            }
            DepInfoRPCRespDTO data = (DepInfoRPCRespDTO)depInfoByDepId.getData();
            respDTO.setRectifyDepName(data.getDepName());
            respDTO.setSerialCode(dangerManageById.getSerialCode());
            respDTO.setDangerStatus(dangerManageById.getDangerStatus());
            respDTO.setDangerManagerId(record.getDangerManagerId());
            respDTO.setReportState(reportConfigById.getReportState());
            respDTO.setReportType(reportConfigById.getReportType());
            respDTO.setPageIndex((int) page.getCurrent());
            respDTO.setPageSize((int) page.getSize());
            list.add(respDTO);
        }

        resultVO.setData(list);
        resultVO.setCount((int) page.getTotal());
        return resultVO;
    }

    /**
     * 隐患整改清单-新增 ---不要了--20220727
     */
    @Override
    public ResultVO<PreventDangerRectify> saveDangerRectify(Long userId, PreventDangerRectifySaveReqDTO rectifySaveReqDTO) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("新增成功");

        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
        if (rpcResult == null) {
            throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
        }
        if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
            throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
        }
        if (rpcResult.getData() == null) {
            throw new BusinessException(ResultCodes.RPC_DATA_NULL);
        }
        if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
            throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
        }
        UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();

        if (ObjectUtils.isEmpty(userById)) {
            throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
        }
        if (rectifySaveReqDTO.getDangerManagerId() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "隐患管理单不能为空");
        }
        PreventDangerManage dangerManageById =
                preventDangerManageService.getDangerManageById(rectifySaveReqDTO.getDangerManagerId());
        if (ObjectUtils.isEmpty(dangerManageById)){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "请填写正确的隐患管理单");
        }
        //每个隐患管理单，只能有一个整改清单
        PreventDangerRectify rectifyByCode =
                preventDangerRectifyService.getRectifyByCode(dangerManageById.getDangerCode());
        if (ObjectUtils.isNotEmpty(rectifyByCode)){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "每个隐患管理单只能有一个整改任务单");
        }
        if (rectifySaveReqDTO.getRectifyTime() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改期限不能为空");
        }

        if (rectifySaveReqDTO.getLiablePersonId() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改责任人不能为空");
        }
        //获取责任人信息
        ResultVO<UserRPCRespDTO> liablePersonResult = accountAuthService.getUserById(rectifySaveReqDTO.getLiablePersonId());
        UserRPCRespDTO liablePerson = (UserRPCRespDTO)liablePersonResult.getData();
        if (ObjectUtils.isEmpty(liablePerson)){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "请正确填写整改责任人");
        }
        if (rectifySaveReqDTO.getRectifyDesc() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改内容说明");
        }
        if (rectifySaveReqDTO.getRectifyTime() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改类型不能为空");
        }

        //获取需要填充的信息
        SnowFlow snowFlow = new SnowFlow();//雪花算法生成器
        String uuid = UUID.randomUUID().toString();
        Date date = new Date();
        long rectifyId = snowFlow.nextId();
        //读取上报主配置
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
        //封装参数
        PreventDangerRectify dangerRectify = BeanCopyUtils.copyBean(rectifySaveReqDTO, PreventDangerRectify.class);
        dangerRectify.setId(rectifyId);
        dangerRectify.setUuid(uuid);
        dangerRectify.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());

        dangerRectify.setGmtCreate(date);
        dangerRectify.setCreateByUserName(userById.getRealName());
        dangerRectify.setGmtModitify(date);
        dangerRectify.setLastEditUserName(userById.getRealName());
        dangerRectify.setEnterpriseId((long) 1);
        dangerRectify.setEnterpriseUuid("1564wq");
        dangerRectify.setCheckAcceptPerson(userById.getRealName());
        dangerRectify.setCheckAcceptPersonId(null);
        dangerRectify.setRectifyDepId(null);

        dangerRectify.setDangerManagerUuid(dangerManageById.getUuid());
        dangerRectify.setDangerManagerId(rectifySaveReqDTO.getDangerManagerId());
        dangerRectify.setDangerCode(dangerManageById.getDangerCode());
        dangerRectify.setLiablePerson(liablePerson.getRealName());

        //设置上报时间为空
        dangerRectify.setReportTime(null);
        //设置本条数据上报更新时间
        dangerRectify.setUpdateReportDataTime(new Date());
        //读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置
        //本模块是否上报，通过DangerManager表的配置进行管理
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
            //设置上报状态为-等待上报
            dangerRectify.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
            //其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作
        }else {
            //设置上报状态为-不上报
            dangerRectify.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
        }
        //不确定是否需要的字段
        dangerRectify.setCheckAcceptTime(null);
        dangerRectify.setCheckAcceptDesc(null);

        int result = preventDangerRectifyService.saveDangerRectify(dangerRectify);

        resultVO.setCount(result);
        return resultVO;
    }

    /**
     * 隐患整改--延期
     */
    @Transactional
    @Override
    public ResultVO<PreventDangerRectify> timeOutRectify(Long userId, PreventDangerRectifyUpdateReqDTO updateReqDTO) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("整改已延期");

        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
        if (rpcResult == null) {
            throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
        }
        if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
            throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
        }
        if (rpcResult.getData() == null) {
            throw new BusinessException(ResultCodes.RPC_DATA_NULL);
        }
        if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
            throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
        }
        UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();

        if (ObjectUtils.isEmpty(userById)) {
            throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
        }
        if (updateReqDTO.getId() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "传参非法");
        }
        if (updateReqDTO.getDangerManagerId() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "隐患管理单不能为空");
        }
        if (updateReqDTO.getRectifyTime() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "延期的时间不能为空");
        }
        if (updateReqDTO.getTimeOutDesc() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "延期说明不能为空");
        }
        PreventDangerRectify rectify = preventDangerRectifyService.getRectifyById(updateReqDTO.getId());
        if (updateReqDTO.getRectifyTime().getTime() - rectify.getRectifyTime().getTime() <= 0){
            throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "延期时间必须大于整改期限");
        }
        PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(rectify.getDangerManagerId());
        if (ObjectUtils.isEmpty(dangerManageById)){
            throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "传参错误");
        }
        if (dangerManageById.getDangerStatus() == StatusEnum.DANGER_MANAGER_NOT_ACCEPT.getCode()){
            throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "超期未整改任务无法延期");
        }

        //读取上报主配置
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
        //封装修改参数
        PreventDangerRectifyUpdateParams updateParams = new PreventDangerRectifyUpdateParams();
        updateParams.setId(updateReqDTO.getId());
        updateParams.setRectifyTime(updateReqDTO.getRectifyTime());
        updateParams.setLastEditUserName(userById.getRealName());
        updateParams.setGmtModitify(new Date());
        updateParams.setTimeOutDesc(updateReqDTO.getTimeOutDesc());

        //设置本条数据上报更新时间 ,上报开关依赖于dangerManager
        updateParams.setUpdateReportDataTime(new Date());
        //读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
            //设置上报状态为-等待上报
            updateParams.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
            //其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作
        }else {
            //设置上报状态为-不上报
            updateParams.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
        }
        //整改单延期成功
        int resultRectify = preventDangerRectifyService.updateRectifyTime(updateParams);
        if (resultRectify < 1){
            throw new AusinessException(E.UPDATE_FAIL, "延期操作失败");
        }
        //管理单变更状态成功
        //封装修改参数
        UpdateRectifyResultParams updateRectifyParams = new UpdateRectifyResultParams();
        updateRectifyParams.setDangerStatus(StatusEnum.DANGER_MANAGER_TIMEOUT_RECTIFY.getCode());
        updateRectifyParams.setDangerManagerId(updateReqDTO.getDangerManagerId());
        updateRectifyParams.setUpdateReportDataTime(new Date());

        //封装延期状态参数
        PreventDangerManageTimeout manageTimeout = new PreventDangerManageTimeout();
        manageTimeout.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());
        manageTimeout.setTimeoutStatus(StatusEnum.DANGER_MANAGER_TIMEOUT_RECTIFY.getCode());
        manageTimeout.setDangerRectifyId(updateReqDTO.getId());
        manageTimeout.setDangerManagerId(updateReqDTO.getDangerManagerId());

        int resultManager = preventDangerManageService.updateRectifyResult(updateRectifyParams);
        if (resultManager < 1){
            throw new AusinessException(E.UPDATE_FAIL, "隐患管理状态变更失败");
        }
        int resultTimeout = preventDangerManageTimeoutService.updateTimeout(manageTimeout);
        if (resultTimeout < 1){
            throw new AusinessException(E.UPDATE_FAIL, "延期状态变更失败");
        }

        return resultVO;
    }

    /**
     * 隐患整改清单-修改
     */
    @Override
    public ResultVO<PreventDangerRectify> updateDangerRectify(Long userId, PreventDangerRectifyUpdateReqDTO rectifyUpdateReqDTO) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("修改成功");

        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
        if (rpcResult == null) {
            throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
        }
        if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
            throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
        }
        if (rpcResult.getData() == null) {
            throw new BusinessException(ResultCodes.RPC_DATA_NULL);
        }
        if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
            throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
        }
        UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();

        if (ObjectUtils.isEmpty(userById)) {
            throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
        }

        if (rectifyUpdateReqDTO.getDangerManagerId() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "参数非法");
        }
        PreventDangerManage dangerManageById =
                preventDangerManageService.getDangerManageById(rectifyUpdateReqDTO.getDangerManagerId());
        if (ObjectUtils.isEmpty(dangerManageById)){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "请填写正确的隐患管理单");
        }
        if (rectifyUpdateReqDTO.getRectifyTime() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改期限不能为空");
        }
        if (rectifyUpdateReqDTO.getLiablePersonId() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改责任人不能为空");
        }
        //获取责任人信息
        ResultVO<UserRPCRespDTO> liablePersonResult = accountAuthService.getUserById(rectifyUpdateReqDTO.getLiablePersonId());
        UserRPCRespDTO liablePerson = (UserRPCRespDTO)liablePersonResult.getData();
        if (ObjectUtils.isEmpty(liablePerson)){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "请正确填写整改责任人");
        }
        if (rectifyUpdateReqDTO.getRectifyDesc() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改内容说明不能为空");
        }
        if (rectifyUpdateReqDTO.getRectifyType() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改类型不能为空");
        }
        if (rectifyUpdateReqDTO.getCost() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改资金不能为空");
        }

        //获取需要填充的信息
        Date date = new Date();
        //读取上报主配置
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
        //封装参数
        PreventDangerRectifyUpdateParams updateParams
                = BeanCopyUtils.copyBean(rectifyUpdateReqDTO, PreventDangerRectifyUpdateParams.class);

        updateParams.setGmtModitify(date);
        updateParams.setLastEditUserName(userById.getRealName());
        updateParams.setDangerManagerUuid(dangerManageById.getUuid());
        updateParams.setLiablePerson(liablePerson.getRealName());

        //设置本条数据上报更新时间 ,上报开关依赖于dangerManager
        updateParams.setUpdateReportDataTime(date);
        //读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
            //设置上报状态为-等待上报
            updateParams.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
            //其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作
        }else {
            //设置上报状态为-不上报
            updateParams.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
        }

        int result = preventDangerRectifyService.updateDangerRectify(updateParams);

        resultVO.setCount(result);
        return resultVO;
    }

    /**
     * 隐患整改清单-验收情况填报-整改
     */
    @Override
    public ResultVO<PreventDangerRectify> applyReport(Long userId, PreventDangerReportRectifyReqDTO reportRectify) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("填报成功");

        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
        if (rpcResult == null) {
            throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
        }
        if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
            throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
        }
        if (rpcResult.getData() == null) {
            throw new BusinessException(ResultCodes.RPC_DATA_NULL);
        }
        if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
            throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
        }
        UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();

        if (ObjectUtils.isEmpty(userById)) {
            throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
        }
        if (reportRectify.getId() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "参数为空");
        }
//        //获取验收责任人信息 验收人已经使用了整改责任人
//        ResultVO<UserRPCRespDTO> checkAcceptPersonResult = accountAuthService.getUserById(reportRectify.getCheckAcceptPersonId());
//        UserRPCRespDTO checkAcceptPerson = (UserRPCRespDTO)checkAcceptPersonResult.getData();

        PreventDangerRectify rectifyById = preventDangerRectifyService.getRectifyById(reportRectify.getId());

        if (!userId.equals(rectifyById.getLiablePersonId())){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "非整改责任人，无法操作");
        }

        PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(reportRectify.getDangerManagerId());

        if (dangerManageById.getDangerStatus().equals(StatusEnum.DANGER_MANAGER_NOT_ACCEPT.getCode())
                || dangerManageById.getDangerStatus().equals(StatusEnum.DANGER_MANAGER_WAIT_ACCEPT.getCode())
                || dangerManageById.getDangerStatus().equals(StatusEnum.DANGER_MANAGER_ACCEPT.getCode())){
            throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "该整改单不是整改中状态，只有在整改的单据才可以申请验收");
        }
        if (reportRectify.getRectifyInfo() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "整改说明不能为空");
        }

        if (dangerManageById.getDangerReview() == StatusEnum.DANGER_RECTIFY_REVIEW.getCode()){
            throw new AusinessException(E.DATA_PARAM_NULL, "隐患已关闭，无法处理");
        }


        //获取需要填充的信息
        Date date = new Date();
        //读取上报主配置
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
        //封装参数
        PreventDangerReportRectifyUpdayeParams reportParams
                = BeanCopyUtils.copyBean(reportRectify, PreventDangerReportRectifyUpdayeParams.class);

        reportParams.setGmtModitify(date);
        reportParams.setLastEditUserName(userById.getRealName());
        reportParams.setApplyTime(reportRectify.getApplyTime());
        reportParams.setRectifyInfo(reportRectify.getRectifyInfo());

        //设置本条数据上报更新时间 ,上报开关依赖于dangerManager
        reportParams.setUpdateReportDataTime(date);
        //读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
            //设置上报状态为-等待上报
            reportParams.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
            //其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作
        }else {
            //设置上报状态为-不上报
            reportParams.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
        }
        //提交数据
        int result = preventDangerRectifyService.applyReport(reportParams);

        if (result < 1) {
            throw new AusinessException(E.UPDATE_FAIL, "提交验收失败");
        }
        //封装修改参数
        UpdateRectifyResultParams updateParams = new UpdateRectifyResultParams();
        updateParams.setDangerStatus(StatusEnum.DANGER_MANAGER_WAIT_ACCEPT.getCode());
        updateParams.setDangerManagerId(reportRectify.getDangerManagerId());
        updateParams.setUpdateReportDataTime(date);
        //设置为待验收
        int manageResult = preventDangerManageService.updateRectifyResult(updateParams);
        if (manageResult < 1) {
            throw new AusinessException(E.UPDATE_FAIL, "状态变更失败");
        }
        resultVO.setCount(result);
        return resultVO;
    }
    /**
     * 隐患管理-关闭隐患单
     */
    @Transactional
    @Override
    public ResultVO<PreventRiskAnaUnit> closeDanger(Long userId, PreventCloseDangerReqDTO closeDangerReqDTO) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("关闭成功");

        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
        if (rpcResult == null) {
            throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
        }
        if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
            throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
        }
        if (rpcResult.getData() == null) {
            throw new BusinessException(ResultCodes.RPC_DATA_NULL);
        }
        if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
            throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
        }
        UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();

        if (ObjectUtils.isEmpty(userById)) {
            throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
        }
        //只有没有处理过的隐患，才能关闭
        //封装参数
        CloseDangerParams closeDangerParams = BeanCopyUtils.copyBean(closeDangerReqDTO, CloseDangerParams.class);

        closeDangerParams.setDangerReview(StatusEnum.DANGER_RECTIFY_REVIEW.getCode());
        closeDangerParams.setGmtModitify(new Date());
        closeDangerParams.setLastEditUserName(userById.getRealName());
        closeDangerParams.setUpdateReportDataTime(new Date());

        int resultManage = preventDangerManageService.closeDanger(closeDangerParams);
        if (resultManage < 1){
            throw new AusinessException(E.UPDATE_FAIL, "关闭隐患管理信息失败");
        }
        //当做删除-进行同步
        int resultRectify = preventDangerRectifyService.closeDanger(closeDangerParams);
        if (resultRectify < 1){
            throw new AusinessException(E.UPDATE_FAIL, "关闭隐患整改信息失败");
        }

        resultVO.setCount(resultManage);

        return resultVO;
    }

    /**
     * 隐患整改清单--验收
     */
    @Override
    public ResultVO<PreventDangerRectify> reportRectify(Long userId, PreventDangerReportRectifyReqDTO reportRectify) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("验收成功");

        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
        if (rpcResult == null) {
            throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
        }
        if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
            throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
        }
        if (rpcResult.getData() == null) {
            throw new BusinessException(ResultCodes.RPC_DATA_NULL);
        }
        if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
            throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
        }
        UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();

        if (ObjectUtils.isEmpty(userById)) {
            throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
        }
        if (reportRectify.getId() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "参数为空");
        }
        if (reportRectify.getDangerManagerId() == null ){
            throw new AusinessException(E.DATA_PARAM_NULL, "参数为空");
        }
        if (reportRectify.getCheckAcceptDesc() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "验收意见不能为空");
        }
        PreventDangerRectify rectifyById = preventDangerRectifyService.getRectifyById(reportRectify.getId());
        if(!rectifyById.getCheckAcceptPersonId().equals(userId)){
            throw new AusinessException(E.DATA_PARAM_NULL, "非验收人，无权操作");
        }
        PreventDangerManage dangerManageById = preventDangerManageService.getDangerManageById(reportRectify.getDangerManagerId());
        if (dangerManageById.getDangerStatus() != StatusEnum.DANGER_MANAGER_WAIT_ACCEPT.getCode()){
            throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "该整改单不是待验收状态，只有待验收的单据才可以同意验收");
        }

        //获取需要填充的信息
        Date date = new Date();
        //读取上报主配置
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
        //封装参数
        PreventDangerReportRectifyUpdayeParams reportParams = new PreventDangerReportRectifyUpdayeParams();

        reportParams.setId(reportRectify.getId());
        reportParams.setGmtModitify(date);
        reportParams.setLastEditUserName(userById.getRealName());
        reportParams.setCheckAcceptTime(date);
        reportParams.setCheckAcceptDesc(reportRectify.getCheckAcceptDesc());
        reportParams.setUpdateReportDataTime(date);

        //设置本条数据上报更新时间 ,上报开关依赖于dangerManager
        reportParams.setUpdateReportDataTime(date);
        //读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
            //设置上报状态为-等待上报
            reportParams.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
            //其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作
        }else {
            //设置上报状态为-不上报
            reportParams.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
        }

        int result = preventDangerRectifyService.reportRectify(reportParams);
        if (result < 1) {
            throw new AusinessException(E.UPDATE_FAIL, "验收信息提交失败");
        }
        //封装修改参数
        UpdateRectifyResultParams updateParams = new UpdateRectifyResultParams();
        updateParams.setDangerStatus(StatusEnum.DANGER_MANAGER_ACCEPT.getCode());
        updateParams.setDangerManagerId(reportRectify.getDangerManagerId());
        updateParams.setUpdateReportDataTime(date);
        //设置为待验收
        int RectifyResult= preventDangerManageService.updateRectifyResult(updateParams);
        if (result < 1) {
            throw new AusinessException(E.UPDATE_FAIL, "验收状态变更失败");
        }
        resultVO.setCount(result);
        return resultVO;
    }

    /**
     * 隐患整改清单-删除
     */
    @Override
    public ResultVO<PreventDangerRectify> deleteDangerRectify(Long userId, PreventDangerRectifyDeleteReqDTO rectifyDeleteReqDTO) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("删除成功");
        PreventDeleteParams deleteParams = new PreventDeleteParams();

        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(userId);
        if (rpcResult == null) {
            throw new BusinessException(ResultCodes.RPC_RESULT_NULL);
        }
        if (!ResultCodes.OK.getCode().equals(rpcResult.getCode())) {
            throw new BusinessException(rpcResult.getCode(), rpcResult.getMsg());
        }
        if (rpcResult.getData() == null) {
            throw new BusinessException(ResultCodes.RPC_DATA_NULL);
        }
        if (!(rpcResult.getData() instanceof UserRPCRespDTO)) {
            throw new BusinessException(ResultCodes.RPC_DATA_TYPE_NOT_MATCH);
        }
        UserRPCRespDTO userById = (UserRPCRespDTO)rpcResult.getData();

        if (ObjectUtils.isEmpty(userById)) {
            throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
        }
        //校验参数
        if (rectifyDeleteReqDTO.getId() == null ){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "请选择正确的删除内容");
        }
        //获取需要填充的信息
        Date date = new Date();
        //封装删除需要的参数
        deleteParams.setId(rectifyDeleteReqDTO.getId());
        deleteParams.setGmtModitify(date);
        deleteParams.setLastEditUserName(userById.getRealName());
        deleteParams.setUpdateReportDataTime(date);

        int result = preventDangerRectifyService.deleteDangerRectify(deleteParams);

        resultVO.setCount(result);
        return resultVO;
    }

    @Override
    public ResultVO countDangerByDate(LocalDate date) {
        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode(ResultCodes.OK.getCode());
        LocalDateTime startTime = LocalDateTime.of(date, LocalTime.of(0,0,0));
        LocalDateTime endTime = LocalDateTime.of(date, LocalTime.of(23,59,59));
        Date start = Date.from(startTime.atZone(ZoneId.systemDefault()).toInstant());
        Date end = Date.from(endTime.atZone(ZoneId.systemDefault()).toInstant());
        resultVO.setData(preventDangerManageService.countByCreateTime(start,end));
        return resultVO;
    }

    @Override
    public ResultVO<PreventDangerManageQueryRespDTO> findByDangerSerialCode(String serialCode) {
        ResultVO<PreventDangerManageQueryRespDTO> resultVO = new ResultVO<>();
        resultVO.setCode(ResultCodes.OK.getCode());
        PreventDangerManage dangerManage = preventDangerManageService.findByDangerSerialCode(serialCode);
        if(dangerManage != null){
            PreventDangerManageQueryRespDTO respDTO = new PreventDangerManageQueryRespDTO();
            BeanUtils.copyProperties(dangerManage,respDTO);
            resultVO.setData(respDTO);
        }
        return resultVO;
    }

    /**
     * 生成隐患编码
     * @param time
     * @param existCount
     * @return
     */
    private String generateDangerSerialCode(Date time,int existCount){
        LocalDateTime t = time.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime();
        LocalDate d = t.toLocalDate();
        StringBuilder stringBuilder = new StringBuilder("");
        stringBuilder.append(d.getYear());
        int mon = d.getMonthValue();
        if(mon < 10){
            stringBuilder.append("0");
            stringBuilder.append(mon);
        }else {
            stringBuilder.append(mon);
        }
        stringBuilder.append(d.getDayOfMonth());
        stringBuilder.append('-');
        int nowSerial = 0;
        if(existCount > 0)
            nowSerial = existCount + 1;
        else
            nowSerial = 1;
        if(nowSerial < 10000){
            if(nowSerial<10){
                stringBuilder.append("000");
            }else if(nowSerial>=10 && nowSerial<100){
                stringBuilder.append("00");
            }else if(nowSerial>=100 && nowSerial<1000){
                stringBuilder.append("0");
            }
            stringBuilder.append(nowSerial);
        }else {
            stringBuilder.append(nowSerial);
        }
        return stringBuilder.toString();
    }
}