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.co.ContextCacheUser;
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.*;
import com.gkhy.safePlatform.doublePrevention.enums.DeviceStatusEnum;
import com.gkhy.safePlatform.doublePrevention.enums.StatusEnum;
import com.gkhy.safePlatform.doublePrevention.enums.SyncEnum;
import com.gkhy.safePlatform.doublePrevention.repository.param.*;
import com.gkhy.safePlatform.doublePrevention.service.ReportService;
import com.gkhy.safePlatform.doublePrevention.service.RiskService;
import com.gkhy.safePlatform.doublePrevention.service.baseService.*;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.FileInputStream;
import java.util.*;

@Service
public class RiskServiceImpl implements RiskService {

    @DubboReference(check = false)
    private AccountAuthService accountAuthService;

    @DubboReference(check = false)
    private AccountDepartmentService accountDepartmentService;

    @Autowired
    private PreventProduceDeviceService preventProduceDeviceService;
    @Autowired
    private PreventRiskMapService preventRiskMapService;
    @Autowired
    private PreventRiskAnaUnitService preventRiskUnitService;
    @Autowired
    private PreventRiskEventService preventRiskEventService;
    @Autowired
    private PreventRiskControlMeasureService preventRiskControlMeasureService;
    @Autowired
    private PreventDangerCheckContentService preventDangerCheckContentService;
    @Autowired
    private PreventRiskControlTemplateService preventRiskControlTemplateService;
    @Autowired
    private PreventReportConfigService preventReportConfigService;
    //生产装置
    /**
     * 生产装置-分页查询
     * */
    @Override
    public ResultVO<PreventProduceDevice> getDevicePage(PreventProduceDeviceQueryReqDTO deviceReqDto) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        List<PreventProduceDeviceQueryRespDTO> list = new ArrayList<>();
        Integer pageIndex = deviceReqDto.getPageIndex();
        Integer pageSize = deviceReqDto.getPageSize();
        //封装查询参数
        PreventProduceDeviceQueryParams queryParams = new PreventProduceDeviceQueryParams();
        if (ObjectUtils.isEmpty(deviceReqDto)){
            throw new AusinessException(E.DATA_PARAM_NULL, "数据传参为空");
        }
        if (deviceReqDto.getRiskLevel() != null ){
            queryParams.setRiskLevel(deviceReqDto.getRiskLevel());
        }
        if (deviceReqDto.getStatus() != null ){
            queryParams.setStatus(deviceReqDto.getStatus());
        }
        if (deviceReqDto.getDepId() != null ){
            queryParams.setDepId(deviceReqDto.getDepId());
        }
        if (deviceReqDto.getLocation() != null ){
            queryParams.setLocation(deviceReqDto.getLocation());
        }
        if (deviceReqDto.getProduceDeviceName() != null ){
            queryParams.setProduceDeviceName(deviceReqDto.getProduceDeviceName());
        }

        //分页查询,获取到所有符合条件的数据
        IPage<PreventProduceDevice> page =
                preventProduceDeviceService.getDevicePage(new Page<>(pageIndex, pageSize), queryParams);
        if (ObjectUtils.isEmpty(page.getRecords())){
            resultVO.setMsg("查询成功,无数据");
            return resultVO;
        }
        for (PreventProduceDevice record : page.getRecords()) {
            PreventProduceDeviceQueryRespDTO respDto = BeanCopyUtils.copyBean(record, PreventProduceDeviceQueryRespDTO.class);
            //校验部门是否存在
            respDto.setPageIndex((int) page.getCurrent());
            respDto.setPageSize((int) page.getSize());
            list.add(respDto);
        }
        resultVO.setCount((int) page.getTotal());

        resultVO.setMsg("查询成功");
        resultVO.setData(list);

        return resultVO;
    }

    /**
     * 生产装置- 查询生产装置列表
     */
    @Override
    public ResultVO<PreventProduceDevice> getListDevices(Long valueOf) {

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

        List<PreventProduceDevice> listDevices = preventProduceDeviceService.getListDevices();
        if (ObjectUtils.isEmpty(listDevices)){
            resultVO.setMsg("查询成功,无数据");
            return resultVO;
        }
        List<PreventProduceDeviceListsQueryRespDTO> respDTOS =
                BeanCopyUtils.copyBeanList(listDevices, PreventProduceDeviceListsQueryRespDTO.class);

        resultVO.setData(respDTOS);

        return resultVO;
    }

    /**
     * 生产装置-根绝风险等级查询
     * */
    @Override
    public ResultVO<PreventProduceDevice> getByLevel(PreventProduceDeviceQueryReqDTO deviceReqDto) {
        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        PreventProduceDevice byLevel = preventProduceDeviceService.getByLevel(deviceReqDto.getRiskLevel());
        resultVO.setData(byLevel);
        return resultVO;
    }
    /**
     * 生产装置-新增
     * */
    @Override
    public ResultVO<PreventProduceDevice> saveDevice(Long userId, PreventProduceDeviceSaveReqDTO deviceSaveReqDto) {

        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.getRealName())){
            throw new BusinessException(ResultCodes.CLIENT_IDENTITY_CHECK_ERROR);
        }
        if (ObjectUtils.isEmpty(deviceSaveReqDto)){
            throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
        }
        if (deviceSaveReqDto.getProduceDeviceName() == null){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"生产装置名称不能为空");
        }
        //查找是否存在同名设备
        PreventProduceDevice deviceByName = preventProduceDeviceService.getDeviceByName(deviceSaveReqDto.getProduceDeviceName());
        if(!ObjectUtils.isEmpty(deviceByName)){
            throw new AusinessException(E.DATA_DATABASE_DUPLICATED, "生产装置已存在，请检查装置名称是否正确，或为装置名称添加编号");
        }
        if (deviceSaveReqDto.getLocation() == null){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"生产装置所在位置不能为空");
        }
        if (deviceSaveReqDto.getRiskLevel() == null){
            throw new RuntimeException("生产装置风险等级不能为空");
        }
        if (deviceSaveReqDto.getDepId() == null){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"生产装置责任部门不能为空");
        }
        //校验部门是否存在
        ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(userId, deviceSaveReqDto.getDepId());
        if(ObjectUtils.isEmpty(depInfoByDepId)){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确责任部门");
        }
        //获取填充信息
        Date date = new Date();
        SnowFlow snowFlow = new SnowFlow();//雪花算法生成器
        String uuid = UUID.randomUUID().toString();
        //封装参数
        PreventProduceDevice device = BeanCopyUtils.copyBean(deviceSaveReqDto, PreventProduceDevice.class);
        device.setId( snowFlow.nextId());
        device.setUuid(uuid);
        device.setStatus(DeviceStatusEnum.DEVICE_USE.getCode());
        device.setEnterpriseId((long) 1);
        device.setEnterpriseUuid("111");

        device.setDepId(deviceSaveReqDto.getDepId());
        DepInfoRPCRespDTO data = (DepInfoRPCRespDTO)depInfoByDepId.getData();
        device.setDepName(data.getDepName());
        device.setDepUuid(null);

        device.setCreateByUserName(userById.getRealName());
        device.setGmtCreate(date);
        device.setLastEditUserName(userById.getRealName());
        device.setGmtModitify(date);
        device.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());
        //执行插入
        int result = preventProduceDeviceService.saveDevice(device);

        resultVO.setCount(result);

        return resultVO;
    }
    /**
     * 生产装置-删除
     * @param deviceDeleteReqDTO
     * @return 查询结果
     */
    @Override
    public ResultVO<PreventProduceDevice> deleteOne(Long userId, PreventProduceDeviceDeleteReqDTO deviceDeleteReqDTO) {
        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("删除成功");

        PreventProduceDeviceDeleteParams param = new PreventProduceDeviceDeleteParams();
        Date date = new Date();

        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(deviceDeleteReqDTO)){
            throw new RuntimeException("请检查是否正确选择删除项");
        }
        PreventProduceDevice device = preventProduceDeviceService.getDeviceById(deviceDeleteReqDTO.getId());
        if (ObjectUtils.isEmpty(device)){
            throw new RuntimeException("请检查该项是否已经被删除");
        }
        //检查生产装置的分析单元是否存在
        List<PreventRiskAnaUnit> unitList = preventRiskUnitService.getRiskUnitByDeviceId(device.getId());
        if (unitList.size() > 0){
            throw new AusinessException(E.NOT_DELETE, "请先删除生产装置对应的分析单元");
        }
        //封装删除参数
        param.setId(deviceDeleteReqDTO.getId());
        param.setGmtModitify(date);
        param.setLastEditUserName(userById.getRealName());
        //执行删除
        int result = preventProduceDeviceService.deleteById(param);
        resultVO.setCount(result);
        return resultVO;
    }

    /**
     * 生产装置-修改
     */
    @Override
    public ResultVO<PreventProduceDevice> updateOneById(Long userId, PreventProduceDeviceUpdateReqDTO deviceUpdateReqDTO) {
        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();

        Date date = new Date();
        if (ObjectUtils.isEmpty(deviceUpdateReqDTO)){
            throw new AusinessException(E.DATA_PARAM_NULL, "修改参数不能为空");
        }
        if (deviceUpdateReqDTO.getId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "请检查生产装置是否存在");
        }
        //检查修改信息的装置是否存在
        PreventProduceDevice deviceById = preventProduceDeviceService.getDeviceById(deviceUpdateReqDTO.getId());
        if(ObjectUtils.isEmpty(deviceById)){
            throw new AusinessException(E.DATA_PARAM_NULL, "生产装置不存在或已删除");
        }
        //检查要修改的名称，是否被占用
        PreventProduceDevice deviceByName = preventProduceDeviceService.getDeviceByName(deviceUpdateReqDTO.getProduceDeviceName());
        //如果查询结果不为空，且修改设备的id与查询到的设备id不同，名称已经被占用
        if(!ObjectUtils.isNotEmpty(deviceByName) && !deviceByName.getId().equals(deviceUpdateReqDTO.getId())){
            throw new AusinessException(E.DATA_DATABASE_EXIST, "生产装置已存在，请检查装置名称是否正确，或为装置名称添加编号");
        }
        if (deviceUpdateReqDTO.getRiskLevel() == null){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "风险等级设置错误，请设置为以下之一：“低风险、一般风险、较大风险、重大风险");
        }

        if (deviceUpdateReqDTO.getDepId() == null){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"生产装置责任部门不能为空");
        }
        //校验部门是否存在
        ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(userId, deviceUpdateReqDTO.getDepId());
        DepInfoRPCRespDTO dep = (DepInfoRPCRespDTO)depInfoByDepId.getData();
        if(ObjectUtils.isEmpty(depInfoByDepId)){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确责任部门");
        }

        if (deviceUpdateReqDTO.getProduceDeviceName() == null || deviceUpdateReqDTO.getProduceDeviceName() ==""){
            throw new AusinessException(E.DATA_PARAM_NULL, "生产装置名称不能设置为空");
        }
        if (deviceUpdateReqDTO.getLocation() == null || deviceUpdateReqDTO.getLocation() ==""){
            throw new AusinessException(E.DATA_PARAM_NULL, "生产装置所在地不能为空");
        }
        //封装修改参数
        PreventProduceDeviceUpdateParams updateParams = new PreventProduceDeviceUpdateParams();

        updateParams.setId(deviceUpdateReqDTO.getId());
        updateParams.setRiskLevel(deviceUpdateReqDTO.getRiskLevel());
        updateParams.setStatus(deviceUpdateReqDTO.getStatus());
        updateParams.setProduceDeviceName(deviceUpdateReqDTO.getProduceDeviceName());
        updateParams.setLocation(deviceUpdateReqDTO.getLocation());

        updateParams.setDepId(deviceUpdateReqDTO.getDepId());
        updateParams.setDepName(dep.getDepName());
        updateParams.setDepUuid(null);

        updateParams.setGmtModitify(date);
        updateParams.setLastEditUserName(userById.getRealName());
        //执行修改
        int result = preventProduceDeviceService.updateProduceDevice(updateParams);

        resultVO.setCount(result);

        return resultVO;
    }

    //风险分布图
    /**
     * 风险分布图-分页查询详细信息
     */
    @Override
    public ResultVO<PreventRiskMap> getMapPage(PreventRiskMapQueryReqDTO riskMapQueryReqDTO) {

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

        List<PreventRiskMapQueryRespDTO> list = new ArrayList<>();

        //获取流
        FileInputStream inputStream = null;
        String base64Str = "";


        Integer pageIndex = riskMapQueryReqDTO.getPageIndex();
        Integer pageSize = riskMapQueryReqDTO.getPageSize();
        //执行查询
        IPage<PreventRiskMap> page = preventRiskMapService.getMapPage(new Page<>(pageIndex, pageSize));
        for (PreventRiskMap record : page.getRecords()) {
            PreventRiskMapQueryRespDTO reqDto = BeanCopyUtils.copyBean(record, PreventRiskMapQueryRespDTO.class);
            reqDto.setPageIndex((int) page.getCurrent());
            reqDto.setPageSize((int) page.getSize());
            //处理图片
            try {
                Base64.Encoder encoder = Base64.getEncoder();
                String filePath = "F:/img/"+record.getImgPath();
                inputStream = new FileInputStream(filePath);
                int available = inputStream.available();
                byte[] bytes = new byte[available];
                inputStream.read(bytes);
                base64Str = encoder.encodeToString(bytes);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    inputStream.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            reqDto.setImg(base64Str);
            //封装数据
            list.add(reqDto);
        }
        //封装返回数据
        resultVO.setData(list);
        resultVO.setCount((int) page.getTotal());

        return resultVO;
    }

    /**
     * 风险分布图-新增
     */
    @Override
    public ResultVO<PreventRiskMap> saveRiskMap(Long userId, PreventRiskMapSaveReqDTO riskMapSaveReqDTO) {

        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();
        PreventRiskMap riskMap = new PreventRiskMap();
        MultipartFile image = riskMapSaveReqDTO.getImg();

        //校验参数
        if (image == null) {
            resultVO.setCode("300");
            resultVO.setMsg("请选择要上传的图片");
            return resultVO;
        }
        if (image.getSize() > 1024 * 1024 * 10) {
            resultVO.setCode("300");
            resultVO.setMsg("文件大小不能大于10M");
            return resultVO;
        }
        //获取文件后缀
        String suffix = image.getOriginalFilename().substring(image.getOriginalFilename().lastIndexOf(".") + 1, image.getOriginalFilename().length());
        if (!"jpg,jpeg,gif,png".toUpperCase().contains(suffix.toUpperCase())) {
            resultVO.setCode("300");
            resultVO.setMsg("请选择jpg,jpeg,gif,png格式的图片");
            return resultVO;
        }
        //处理图片
        String savePath = "F:/img/";
        File savePathFile = new File(savePath);
        if (!savePathFile.exists()) {
            //若不存在该目录，则创建目录
            savePathFile.mkdir();
        }
        //通过UUID生成唯一文件名
        String filename = UUID.randomUUID().toString().replaceAll("-","") + "." + suffix;
        try {
            //将文件保存指定目录
            //file.transferTo(new File(savePath + filename));
            //File file1 = new File(file.getOriginalFilename());
            FileUtils.copyInputStreamToFile(image.getInputStream(),new File(savePath + filename));
        } catch (Exception e) {
            e.printStackTrace();
            resultVO.setCode("300");
            resultVO.setMsg("保存文件异常");
            return resultVO;
        }
        //获取id与uuid
        SnowFlow snowFlow = new SnowFlow();//雪花算法生成器
        String uuid = UUID.randomUUID().toString();
        Date date = new Date();
        //封装数据
        //TODO
        riskMap.setId(snowFlow.nextId());
        riskMap.setUuid(uuid);
        riskMap.setImgPath(filename);
        riskMap.setDescInfo(riskMapSaveReqDTO.getDescInfo());
        riskMap.setEnterpriseId((long) 1);
        riskMap.setEnterpriseUuid("111");
        riskMap.setCreateByUserName(userById.getRealName());
        riskMap.setGmtCreate(date);
        riskMap.setLastEditUserName(userById.getRealName());
        riskMap.setGmtModitify(date);
        riskMap.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());
        //执行插入
        int result = preventRiskMapService.saveRiskMap(riskMap);

        resultVO.setCount(result);
        return resultVO;
    }

    /**
     * 风险分布图-删除
     */
    @Override
    public ResultVO<PreventRiskMap> deleteRiskMap(Long userId, PreventRiskMapDeleteReqDTO riskMapDeleteReqDTO) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("删除成功");
        //获取用户信息

        if (riskMapDeleteReqDTO.getId() == null){
            throw new RuntimeException("请选择删除内容");
        }
        //执行删除
        int result = preventRiskMapService.deleteRiskMap(riskMapDeleteReqDTO.getId());
        //结果校验
        if (result == 0){
            throw new AusinessException(E.DATA_STATUS_NOT_EXIST, "删除失败");
        }
        resultVO.setCount(result);
        return resultVO;
    }

    /**
     * 风险分布图-修改
     */
    @Override
    public ResultVO<PreventRiskMap> updateRiskMap(Long userId, PreventRiskMapUpdateReqDTO riskMapUpdateReqDTO) {

        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();

        PreventRiskMapUpdateParams params = new PreventRiskMapUpdateParams();
        Date date = new Date();
        //封装修改参数
        params.setId(riskMapUpdateReqDTO.getId());
        params.setDescInfo(riskMapUpdateReqDTO.getDescInfo());
        params.setGmtModitify(date);
        params.setLastEditUserName(userById.getRealName());
        //修改
        int result = preventRiskMapService.updateRiskMap(params);
        //结果校验
        if (result == 0){
            throw new AusinessException(E.DATA_STATUS_NOT_EXIST, "删除失败");
        }
        resultVO.setCount(result);
        return resultVO;
    }

    //风险分析单元
    /**
     * 风险分析单元-分页查询
     */
    @Override
    public ResultVO<PreventRiskAnaUnit> getRiskUnitPage(Long userId, PreventRiskAnaUnitQueryReqDTO riskAnaUnitQueryReqDTO) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("查询成功");
        List<PreventRiskAnaUnitQueryRespDTO> list = new ArrayList<>();
        Integer pageIndex = riskAnaUnitQueryReqDTO.getPageIndex();
        Integer pageSize = riskAnaUnitQueryReqDTO.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();
        //校验参数
        //分页查询
        IPage<PreventRiskAnaUnit> page = preventRiskUnitService.getRiskUnitPage(new Page<>(pageIndex, pageSize), riskAnaUnitQueryReqDTO);
        if (ObjectUtils.isEmpty(page.getRecords())){
            resultVO.setMsg("查询成功,无数据");
            return resultVO;
        }
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_ANA_UNIT.getCode());
        for (PreventRiskAnaUnit record : page.getRecords()) {
            PreventRiskAnaUnitQueryRespDTO respDto = BeanCopyUtils.copyBean(record, PreventRiskAnaUnitQueryRespDTO.class);
            //封装设备名称
            PreventProduceDevice deviceById = preventProduceDeviceService.getDeviceById(record.getProduceDeviceId());
            respDto.setPageIndex((int) page.getCurrent());
            respDto.setPageSize((int) page.getSize());
            respDto.setProduceDeviceName(deviceById.getProduceDeviceName());
            //封装上报配置信息
            respDto.setReportState(reportConfigById.getReportState());
            respDto.setReportType(reportConfigById.getReportType());
            list.add(respDto);
        }
        resultVO.setCount((int) page.getTotal());
        resultVO.setData(list);

        return resultVO;
    }

    /**
     * 风险分析单元-新增
     */
    @Override
    public ResultVO<PreventRiskAnaUnit> saveRiskAnaUnit(Long userId, PreventRiskAnaUnitSaveReqDTO riskAnaUnitSaveReqDTO) {
        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();

        PreventRiskMap riskMap = new PreventRiskMap();

        //校验参数
        if (ObjectUtils.isEmpty(riskAnaUnitSaveReqDTO)){
            throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
        }
        if (riskAnaUnitSaveReqDTO.getRiskCode() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "风险分析编码不能为空");
        }
        if (riskAnaUnitSaveReqDTO.getRiskUnitName() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "风险分析单元名称不能为空");
        }
        //判断是否存在同名单元
        PreventRiskAnaUnit riskUnitById = preventRiskUnitService.getRiskUnitByName(riskAnaUnitSaveReqDTO.getRiskUnitName());
        if (!ObjectUtils.isEmpty(riskUnitById)){
            throw new AusinessException(E.DATA_DATABASE_DUPLICATED, "存在同名单元，请修改名称，或为单元添加编号");
        }
        //判断是否存在同名编码
        PreventRiskAnaUnit riskUnitByCode = preventRiskUnitService.getRiskUnitByCode(riskAnaUnitSaveReqDTO.getRiskCode());
        if (!ObjectUtils.isEmpty(riskUnitByCode)){
            throw new AusinessException(E.DATA_DATABASE_DUPLICATED, "存在同名风险编码，请修改编码");
        }
        if (riskAnaUnitSaveReqDTO.getLiableDepId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "责任部门不能为空");
        }
        //校验部门是否存在
        ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(userId, riskAnaUnitSaveReqDTO.getLiableDepId());
        if(ObjectUtils.isEmpty(depInfoByDepId)){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确责任部门");
        }
        DepInfoRPCRespDTO dep = (DepInfoRPCRespDTO)depInfoByDepId.getData();

        if (riskAnaUnitSaveReqDTO.getLiablePersonId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "责任人不能为空");
        }

        if (riskAnaUnitSaveReqDTO.getProduceDeviceId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "生产装置不能为空");
        }
        PreventProduceDevice deviceById = preventProduceDeviceService.getDeviceById(riskAnaUnitSaveReqDTO.getProduceDeviceId());
        if (ObjectUtils.isEmpty(deviceById)){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "未找到对应的生产装置");
        }

        //获取需要填充的信息
        SnowFlow snowFlow = new SnowFlow();//雪花算法生成器
        String uuid = UUID.randomUUID().toString();
        Date date = new Date();
        ResultVO<UserRPCRespDTO> liablePersonResult = accountAuthService.getUserById(riskAnaUnitSaveReqDTO.getLiablePersonId());
        UserRPCRespDTO liablePerson = (UserRPCRespDTO)liablePersonResult.getData();
        //封装参数
        PreventRiskAnaUnit riskAnaUnit = BeanCopyUtils.copyBean(riskAnaUnitSaveReqDTO, PreventRiskAnaUnit.class);

        riskAnaUnit.setId(snowFlow.nextId());
        riskAnaUnit.setUuid(uuid);
        riskAnaUnit.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());

        riskAnaUnit.setEnterpriseId((long) 1);
        riskAnaUnit.setProduceDeviceId(deviceById.getId());
        riskAnaUnit.setProduceDeviceUuid(deviceById.getUuid());
        riskAnaUnit.setEnterpriseUuid("111");
        riskAnaUnit.setLiablePerson(liablePerson.getRealName());
        riskAnaUnit.setLiablePersonUuid(liablePerson.getUuid());
        riskAnaUnit.setLiableDep(dep.getDepName());
        riskAnaUnit.setLiableDepUuid(null);

        riskAnaUnit.setGmtModitify(date);
        riskAnaUnit.setGmtCreate(date);
        riskAnaUnit.setCreateByUserName(userById.getRealName());
        riskAnaUnit.setLastEditUserName(userById.getRealName());

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

        int result = preventRiskUnitService.saveRiskAnaUnit(riskAnaUnit);
        //结果校验
        if (result == 0){
            throw new AusinessException(E.DATA_STATUS_NOT_EXIST, "删除失败");
        }
        resultVO.setCount(result);
        return resultVO;
    }

    /**
     * 风险分析单元-修改
     */
    @Override
    public ResultVO<PreventRiskAnaUnit> updateRiskAnaUnitById(Long userId, PreventRiskAnaUnitUpdateReqDTO riskAnaUnitUpdateReqDTO) {
        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();
        PreventRiskMap riskMap = new PreventRiskMap();
        PreventRiskAnaUnitUpdateParams params = new PreventRiskAnaUnitUpdateParams();
        Date date = new Date();

        //校验参数
        if (ObjectUtils.isEmpty(riskAnaUnitUpdateReqDTO)){
            throw new BusinessException(ResultCodes.CLIENT_PARAM_NULL);
        }
        if (riskAnaUnitUpdateReqDTO.getRiskCode() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "风险分析编码不能为空");
        }
        if (riskAnaUnitUpdateReqDTO.getRiskUnitName() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "风险分析单元名称不能为空");
        }
        //判断是否存在同名单元
        PreventRiskAnaUnit riskUnitById = preventRiskUnitService.getRiskUnitByName(riskAnaUnitUpdateReqDTO.getRiskUnitName());
        //如果查询结果不为空，且查询到的id与请求的id不同——被占用
        if (ObjectUtils.isNotEmpty(riskUnitById) && !riskUnitById.getId().equals(riskAnaUnitUpdateReqDTO.getId())){
            throw new AusinessException(E.DATA_DATABASE_DUPLICATED, "存在同名单元，请修改名称，或为单元添加编号");
        }
        //判断是否存在同名编码
        PreventRiskAnaUnit riskUnitByCode = preventRiskUnitService.getRiskUnitByCode(riskAnaUnitUpdateReqDTO.getRiskCode());
        if (ObjectUtils.isNotEmpty(riskUnitByCode) && !riskUnitByCode.getId().equals(riskAnaUnitUpdateReqDTO.getId())){
            throw new AusinessException(E.DATA_DATABASE_DUPLICATED, "存在同名风险编码，请修改编码");
        }
        if (riskAnaUnitUpdateReqDTO.getLiableDepId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "责任部门不能为空");
        }
        if (riskAnaUnitUpdateReqDTO.getLiablePersonId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "责任人不能为空");
        }
        //校验人是否存在
        ResultVO<DepInfoRPCRespDTO> depInfoByDepId = accountDepartmentService.getDepInfoByDepId(userId, riskAnaUnitUpdateReqDTO.getLiableDepId());
        DepInfoRPCRespDTO liableDep = (DepInfoRPCRespDTO)depInfoByDepId.getData();
        if(ObjectUtils.isEmpty(depInfoByDepId)){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确责任人");
        }


        //获取责任人信息
        ResultVO<UserRPCRespDTO> liablePersonResult = accountAuthService.getUserById(riskAnaUnitUpdateReqDTO.getLiablePersonId());
        UserRPCRespDTO liablePerson = (UserRPCRespDTO)liablePersonResult.getData();
        if(ObjectUtils.isEmpty(liablePerson)){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT,"请输入正确责任部门");
        }
        //TODO 查询责任人，判断是否存在  ？责任人与责任部门是否需要关联--需要方法，getUserByName

        if (riskAnaUnitUpdateReqDTO.getProduceDeviceId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "生产装置不能为空");
        }
        PreventProduceDevice deviceByName = preventProduceDeviceService.getDeviceById(riskAnaUnitUpdateReqDTO.getProduceDeviceId());
        if (ObjectUtils.isEmpty(deviceByName)){
            throw new AusinessException(E.DATA_PARAM_NULL, "未找到对应的生产装置");
        }

        //封装修改参数
        params.setId(riskAnaUnitUpdateReqDTO.getId());
        params.setRiskUnitName(riskAnaUnitUpdateReqDTO.getRiskUnitName());
        params.setRiskCode(riskAnaUnitUpdateReqDTO.getRiskCode());
        params.setProduceDeviceId(deviceByName.getId());
        params.setProduceDeviceUuid(deviceByName.getUuid());
        params.setLiableDepId(riskAnaUnitUpdateReqDTO.getLiableDepId());
        params.setLiablePersonId(riskAnaUnitUpdateReqDTO.getLiablePersonId());
        params.setLiablePersonUuid(liablePerson.getUuid());
        params.setLiableDepUuid(null);
        params.setLiablePerson(liablePerson.getRealName());
        params.setLiableDep(liableDep.getDepName());
        params.setLiableDep(liableDep.getDepName());
        params.setUpdateReportDataTime(date);
        params.setGmtModitify(date);
        params.setLastEditUserName(userById.getRealName());
        params.setUpdateReportDataTime(date);

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

        int result = preventRiskUnitService.updateRiskAnaUnitById(params);
        //结果校验
        if (result == 0){
            throw new AusinessException(E.UPDATE_FAIL, "修改失败");
        }
        resultVO.setCount(result);

        return resultVO;
    }

    /**
     * 安全风险分析单元-手工上报-配置
     */
    @Override
    public ResultVO<PreventRiskAnaUnit> updateRiskAnaUnitReport(Long userId, PreventHandReportConfigReqDTO preventHandReportConfigReqDTO) {

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

        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, "传参非法");
        }
        //查询当前隐患的配置
        PreventRiskAnaUnit riskUnitById = preventRiskUnitService.getRiskUnitById(preventHandReportConfigReqDTO.getId());
        //配置相同
        if (riskUnitById.getReportSwitch() == preventHandReportConfigReqDTO.getReportSwitch()){
            throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "与当前配置相同");
        }
        //读取主配置信息
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_ANA_UNIT.getCode());
        //只有当开启上报，且类型为手动上报时，可以修改
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_AUTO_EXEC_CONFIG.getCode()){
            result = preventRiskUnitService.updateRiskAnaUnitReport(preventHandReportConfigReqDTO);

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

    /**
     * 风险分析单元-删除
     */
    @Override
    public ResultVO<PreventRiskAnaUnit> deleteRiskAnaUnitById(Long userId, PreventRiskAnaUnitDeleteReqDTO riskAnaUnitDeleteReqDTO) {
        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();

        PreventRiskMap riskMap = new PreventRiskMap();
        PreventRiskAnaUnitDeleteParams deleteParams = new PreventRiskAnaUnitDeleteParams();

        Date date = new Date();
        //校验参数
        if (ObjectUtils.isEmpty(riskAnaUnitDeleteReqDTO)) {
            throw new AusinessException(E.DATA_PARAM_NULL, "请选择删除内容");
        }
        //检查风险分析单元对应的风险事件是否全部删除
        List<PreventRiskEvent> eventList = preventRiskEventService.getRiskEventNameByRiskUnitId(riskAnaUnitDeleteReqDTO.getId());
        if (eventList.size() > 0){
            throw new AusinessException(E.NOT_DELETE, "请先删除风险分析单元对应的风险事件");
        }
        //封装参数
        deleteParams.setId(riskAnaUnitDeleteReqDTO.getId());
        deleteParams.setGmtModitify(date);
        deleteParams.setLastEditUserName(userById.getRealName());
        deleteParams.setUpdateReportDataTime(date);
        //删除
        int result = preventRiskUnitService.deleteRiskAnaUnitById(deleteParams);
        //结果校验
        if (result == 0){
            throw new AusinessException(E.DATA_STATUS_NOT_EXIST, "删除失败");
        }
        resultVO.setCount(result);

        return resultVO;
    }

    /**
     * 风险单元list查询
     */
    @Override
    public ResultVO<PreventRiskEvent> listRiskUnits(Long userId) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("查询成功");
        //List<PreventRiskEventQueryRespDTO> list = new ArrayList<>();
        //获取用户信息
        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);
        }
        List<PreventRiskAnaUnit> riskAnaUnits = preventRiskUnitService.listRiskUnits();
        if (ObjectUtils.isEmpty(riskAnaUnits)){
            resultVO.setMsg("查询成功,无数据");
            return resultVO;
        }
        //List<PreventRiskEventListRiskUnitsRespDTO> respDTOS = BeanCopyUtils.copyBeanList(riskAnaUnits, PreventRiskEventListRiskUnitsRespDTO.class);
        List<PreventRiskEventListRiskUnitsRespDTO> list = new ArrayList<>();
        for (PreventRiskAnaUnit riskAnaUnit : riskAnaUnits) {
            PreventRiskEventListRiskUnitsRespDTO respDTO = BeanCopyUtils.copyBean(riskAnaUnit, PreventRiskEventListRiskUnitsRespDTO.class);
            PreventProduceDevice deviceById = preventProduceDeviceService.getDeviceById(respDTO.getProduceDeviceId());
            respDTO.setProduceDeviceName(deviceById.getProduceDeviceName());
            list.add(respDTO);
        }

        resultVO.setData(list);

        return resultVO;
    }

    //风险事件
    /**
     * 风险事件-分页查询
     */
    @Override
    public ResultVO<PreventRiskEvent> getRiskEventPage(Long userId, PreventRiskEventQueryReqDTO riskEventQueryReqDTO) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("查询成功");
        List<PreventRiskEventQueryRespDTO> list = new ArrayList<>();
        PreventRiskEventQueryParams queryParams = new PreventRiskEventQueryParams();
        Integer pageIndex = riskEventQueryReqDTO.getPageIndex();
        Integer pageSize = riskEventQueryReqDTO.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 (riskEventQueryReqDTO.getRiskUnitId() != null ){
            queryParams.setRiskUnitId(riskEventQueryReqDTO.getRiskUnitId());
        }
        if (riskEventQueryReqDTO.getRiskEventName() != null && riskEventQueryReqDTO.getRiskEventName() != ""){
            queryParams.setRiskEventName(riskEventQueryReqDTO.getRiskEventName());
        }
        //获取事件上报配置信息
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_EVENT.getCode());
        //获取到所有符合条件的事件
        IPage<PreventRiskEvent> page = preventRiskEventService.getRiskEventPage(new Page<>(pageIndex, pageSize), queryParams);
        if (ObjectUtils.isEmpty(page.getRecords())){
            resultVO.setMsg("查询成功,无数据");
            return resultVO;
        }
        //遍历集合，为符合条件的事件添加单元名称
        for (PreventRiskEvent record : page.getRecords()) {
            PreventRiskAnaUnit riskUnitById = preventRiskUnitService.getRiskUnitById(record.getRiskUnitId());
            PreventRiskEventQueryRespDTO respDTO = BeanCopyUtils.copyBean(record, PreventRiskEventQueryRespDTO.class);
            respDTO.setRiskUnitName(riskUnitById.getRiskUnitName());
            respDTO.setRiskUnitId(riskUnitById.getId());
            respDTO.setPageIndex((int) page.getCurrent());
            respDTO.setPageSize((int) page.getSize());
            respDTO.setReportState(reportConfigById.getReportState());
            respDTO.setReportType(reportConfigById.getReportType());
            list.add(respDTO);
        }
        resultVO.setCount((int) page.getTotal());
        resultVO.setData(list);

        return resultVO;
    }

    /**
     * 风险事件-新增
     */
    @Override
    public ResultVO<PreventRiskEvent> saveRiskEvent(Long userId, PreventRiskEventSaveReqDTO riskEventSaveReqDTO) {

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

        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 (riskEventSaveReqDTO.getRiskEventName() == null && riskEventSaveReqDTO.getRiskEventName() != ""){
            throw new AusinessException(E.DATA_PARAM_NULL, "事件不能为空");
        }
        //检查是否已经存在同名参数
        PreventRiskEvent riskEventByName = preventRiskEventService.getRiskEventByName(riskEventSaveReqDTO.getRiskEventName());
        if (!ObjectUtils.isEmpty(riskEventByName)){
            throw new AusinessException(E.DATA_DATABASE_EXIST, "存在同名事件，轻为新事件改名或添加编号");
        }

        if (riskEventSaveReqDTO.getRiskUnitId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "风险分析单元不能为空");
        }
        PreventRiskAnaUnit riskUnitById = preventRiskUnitService.getRiskUnitById(riskEventSaveReqDTO.getRiskUnitId());
        if (ObjectUtils.isEmpty(riskUnitById)){
            throw new AusinessException(E.DATA_PARAM_NULL, "请选择正确的风险分析单元");
        }
        //获取需要填充的信息
        SnowFlow snowFlow = new SnowFlow();//雪花算法生成器
        String uuid = UUID.randomUUID().toString();
        Date date = new Date();
        //封装参数
        riskEvent.setId(snowFlow.nextId());
        riskEvent.setUuid(uuid);
        riskEvent.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());
        riskEvent.setRiskEventName(riskEventSaveReqDTO.getRiskEventName());

        riskEvent.setRiskUnitId(riskUnitById.getId());
        riskEvent.setRiskUnitUuid(riskUnitById.getUuid());

        riskEvent.setEnterpriseId((long) 1);
        riskEvent.setEnterpriseUuid("111");
        riskEvent.setGmtModitify(date);
        riskEvent.setGmtCreate(date);
        riskEvent.setCreateByUserName(userById.getRealName());
        riskEvent.setLastEditUserName(userById.getRealName());
        riskEvent.setEventResult(riskEventSaveReqDTO.getEventResult());
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_EVENT.getCode());
        //设置上报时间为空
        riskEvent.setReportTime(null);
        //设置本条数据上报更新时间
        riskEvent.setUpdateReportDataTime(date);
        //读取上报主配置，进行任务记录上报配置,如果开启上报功能，且设置为自动上报,开启上报相关配置
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
            //设置上报状态为-等待上报
            riskEvent.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
            //设置本条数据上报开关为-开启
            riskEvent.setReportSwitch(SyncEnum.REPORT_ON.getCode());
            //其他情况默认不开启上报数据，如果是手动上报，可对单条数据进行操作
        }else {
            //设置上报状态为-不上报
            riskEvent.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
            //设置本条数据上报开关为-关闭
            riskEvent.setReportSwitch(SyncEnum.REPORT_OFF.getCode());
        }

        int result = preventRiskEventService.saveRiskEvent(riskEvent);
        //结果校验
        if (result == 0){
            throw new AusinessException(E.DATA_STATUS_NOT_EXIST, "新增失败");
        }
        resultVO.setCount(result);
        return resultVO;
    }

    /**
     * 风险事件-修改
     */
    @Override
    public ResultVO<PreventRiskEvent> updateRiskEvent(Long userId, PreventRiskEventUpdateReqDTO riskEventUpdateReqDTO) {

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

        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 (riskEventUpdateReqDTO.getRiskEventName() == null && riskEventUpdateReqDTO.getRiskEventName() != ""){
            throw new AusinessException(E.DATA_PARAM_NULL, "事件不能为空");
        }
        //TODO 问题，只修改单元，也会被拦截
        //检查是否已经存在同名参数
        PreventRiskEvent riskEventByName = preventRiskEventService.getRiskEventByName(riskEventUpdateReqDTO.getRiskEventName());
        //如果查询结果不为空，且查询到的id与请求的id不同——被占用
        if (!ObjectUtils.isEmpty(riskEventByName) && !riskEventByName.getId().equals(riskEventUpdateReqDTO.getId())){
            throw new AusinessException(E.DATA_DATABASE_EXIST, "存在同名事件，轻为新事件改名或添加编号");
        }

        if (riskEventUpdateReqDTO.getRiskUnitId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "风险分析单元不能为空");
        }
        PreventRiskAnaUnit riskUnitById = preventRiskUnitService.getRiskUnitById(riskEventUpdateReqDTO.getRiskUnitId());
        if (ObjectUtils.isEmpty(riskUnitById)){
            throw new AusinessException(E.DATA_PARAM_NULL, "请选择正确的风险分析单元");
        }

        //获取需要填充的信息
        updateParams.setId(riskEventUpdateReqDTO.getId());
        updateParams.setRiskEventName(riskEventUpdateReqDTO.getRiskEventName());
        updateParams.setRiskUnitId(riskUnitById.getId());
        updateParams.setRiskUnitUuid(riskUnitById.getUuid());
        updateParams.setGmtModitify(data);
        updateParams.setLastEditUserName(userById.getRealName());
        updateParams.setEventResult(riskEventUpdateReqDTO.getEventResult());

        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_EVENT.getCode());

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

        int result = preventRiskEventService.updateRiskEvent(updateParams);
        //结果校验
        if (result == 0){
            throw new AusinessException(E.DATA_STATUS_NOT_EXIST, "修改失败");
        }
        resultVO.setCount(result);

        return resultVO;
    }

    /**
     * 安全风险事件-手工上报-配置
     */
    @Override
    public ResultVO<PreventRiskAnaUnit> updateRiskEventReport(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, "传参非法");
        }
        //查询当前隐患的配置
        PreventRiskEvent riskEventNameById = preventRiskEventService.getRiskEventNameById(preventHandReportConfigReqDTO.getId());
        //配置相同，做处理
        if (riskEventNameById.getReportSwitch() == preventHandReportConfigReqDTO.getReportSwitch()){
            throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "与当前配置相同");
        }
        int result ;
        //读取主配置信息
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_EVENT.getCode());
        //只有当开启上报，且类型为手动上报时，可以修改
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_AUTO_EXEC_CONFIG.getCode()){
            result = preventRiskEventService.updateRiskEventReport(preventHandReportConfigReqDTO);

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

    /**
     * 风险事件-事件list
     */
    @Override
    public ResultVO<PreventRiskEvent> getListEvents(Long userId) {

        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);
        }
        List<PreventRiskEvent> preventRiskEvents = preventRiskEventService.getListEvents();
        if (ObjectUtils.isEmpty(preventRiskEvents)){
            resultVO.setMsg("查询成功,无数据");
            return resultVO;
        }
        List<PreventRiskEventsListQueryRespDTO> respDTOS
                = BeanCopyUtils.copyBeanList(preventRiskEvents, PreventRiskEventsListQueryRespDTO.class);

        resultVO.setData(respDTOS);
        resultVO.setCount(respDTOS.size());
        return resultVO;
    }

    /**
     * 风险事件-删除
     */
    @Override
    public ResultVO<PreventRiskEvent> deleteRiskEvent(Long userId, PreventRiskEventDeleteReqDTO riskEventDeleteReqDTO) {
        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("删除成功");
        PreventRiskEvent riskEvent = new PreventRiskEvent();
        Date data = new Date();

        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();
        PreventDeleteParams deleteParams = new PreventDeleteParams();
        //校验参数
        if (riskEventDeleteReqDTO.getId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "请选择要删除的内容");
        }
        //检查风险事件对应的管控措施
        List<PreventRiskControlMeasure> measureList =
                preventRiskControlMeasureService.getRiskControlMeasureByRiskEventId(riskEventDeleteReqDTO.getId());
        if (measureList.size() > 0){
            throw new AusinessException(E.NOT_DELETE, "请先删除风险事件对应的风险管控措施");
        }
        //封装参数
        deleteParams.setId(riskEventDeleteReqDTO.getId());
        deleteParams.setGmtModitify(data);
        deleteParams.setLastEditUserName(userById.getRealName());
        deleteParams.setUpdateReportDataTime(data);
        int result = preventRiskEventService.deleteRiskEventById(deleteParams);
        //结果校验
        if (result == 0){
            throw new AusinessException(E.DATA_STATUS_NOT_EXIST, "删除失败");
        }
        resultVO.setCount(result);
        return resultVO;
    }

    //管控措施
    /**
     * 管控措施-分页查询
     */
    @Override
    public ResultVO<PreventRiskControlMeasure> getRiskControlMeasurePage(Long userId, PreventRiskControlMeasureQueryReqDTO measureQueryReqDTO) {

        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("查询成功");
        List<PreventRiskControlMeasureQueryRespDTO> list = new ArrayList<>();
        PreventRiskControlMeasureQueryParams queryParams = new PreventRiskControlMeasureQueryParams();
        Integer pageIndex = measureQueryReqDTO.getPageIndex();
        Integer pageSize = measureQueryReqDTO.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 (measureQueryReqDTO.getControlType() != null) {
            queryParams.setControlType(measureQueryReqDTO.getControlType());
        }
        if (measureQueryReqDTO.getRiskEventId() != null) {
                queryParams.setRiskEventId(measureQueryReqDTO.getRiskEventId());
            }
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_MEASURE.getCode());
        //获取到所有符合条件的措施
        IPage<PreventRiskControlMeasure> page =
                preventRiskControlMeasureService.getRiskControlMeasurePage(new Page<>(pageIndex, pageSize), queryParams);
        if (ObjectUtils.isEmpty(page.getRecords())){
            resultVO.setMsg("查询成功,无数据");
            return resultVO;
        }
        //遍历集合，为符合条件的措施添加事件名称
        for (PreventRiskControlMeasure record : page.getRecords()) {
            PreventRiskControlMeasureQueryRespDTO respDTO = BeanCopyUtils.copyBean(record, PreventRiskControlMeasureQueryRespDTO.class);
           //为措施添加事件名称
            PreventRiskEvent riskEventNameById = preventRiskEventService.getRiskEventNameById(record.getRiskEventId());
            respDTO.setRiskEventName(riskEventNameById.getRiskEventName());
            //为措施添加隐患排查内容
            PreventDangerCheckContent checkContent = preventDangerCheckContentService.getCheckContentByMeasureId(record.getId());
            respDTO.setCheckContent(checkContent.getCheckContent());
            respDTO.setPageSize((int) page.getSize());
            respDTO.setPageIndex((int) page.getCurrent());
            respDTO.setReportState(reportConfigById.getReportState());
            respDTO.setReportType(reportConfigById.getReportType());
            list.add(respDTO);
        }
        resultVO.setData(list);
        resultVO.setCount((int) page.getTotal());
        return resultVO;
    }

    /**
     * 生产装置ID- 查询单元
     */
    @Override
    public ResultVO<PreventRiskAnaUnit> getRiskAnaUnitByDeviceId(Long uid, Long deviceId) {

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

        //获取用户信息
        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(uid);
        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();

        List<PreventRiskAnaUnit> riskUnitByDeviceId = preventRiskUnitService.getRiskUnitByDeviceId(deviceId);
        if (ObjectUtils.isEmpty(riskUnitByDeviceId)){
            resultVO.setMsg("查询成功,无数据");
            return resultVO;
        }
        PreventProduceDevice deviceById = preventProduceDeviceService.getDeviceById(deviceId);

        List<PreventGetAnaUnitByDeviceIdRespDTO> list = new ArrayList<>();
        for (PreventRiskAnaUnit preventRiskAnaUnit : riskUnitByDeviceId) {
            PreventGetAnaUnitByDeviceIdRespDTO respDTO = BeanCopyUtils.copyBean(preventRiskAnaUnit, PreventGetAnaUnitByDeviceIdRespDTO.class);
            respDTO.setProduceDeviceName(deviceById.getProduceDeviceName());
            list.add(respDTO);
        }
        resultVO.setData(list);

        return resultVO;
    }

    /**
     * 安全风险事件-手工上报-配置
     */
    @Override
    public ResultVO<PreventRiskAnaUnit> updateMeasuresReport(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, "传参非法");
        }
        //查询当前隐患的配置
        PreventRiskControlMeasure controlMeasureById = preventRiskControlMeasureService.getControlMeasureById(preventHandReportConfigReqDTO.getId());
        //配置相同，做处理
        if (controlMeasureById.getReportSwitch() == preventHandReportConfigReqDTO.getReportSwitch()){
            throw new AusinessException(E.DATA_PARAM_CHECK_INVALID, "与当前配置相同");
        }
        int result ;
        //读取主配置信息
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_MEASURE.getCode());
        //只有当开启上报，且类型为手动上报时，可以修改
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_AUTO_EXEC_CONFIG.getCode()){
            result = preventRiskControlMeasureService.updateMeasuresReport(preventHandReportConfigReqDTO);

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

    /**
     * 管控措施-新增
     */
    @Transactional
    @Override
    public ResultVO<PreventRiskControlMeasure> saveRiskControlMeasure(Long userId, PreventRiskControlMeasureSaveReqDTO measureSaveReqDTO) {

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

        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 (measureSaveReqDTO.getRiskEventId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "风险事件不能为空");
        }
        PreventRiskEvent riskEventById = preventRiskEventService.getRiskEventNameById(measureSaveReqDTO.getRiskEventId());
        if (ObjectUtils.isEmpty(riskEventById)){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "请检查风险事件是否正确");
        }
        if (measureSaveReqDTO.getControlType() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "管控方式不能为空，或设置有误");
        }
        if (measureSaveReqDTO.getClassify1() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "管控方式分类1不能为空，或设置有误");
        }
        if (measureSaveReqDTO.getClassify2() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "管控方式分类2不能为空，或设置有误");
        }
        if (measureSaveReqDTO.getControlMeasureCode() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "管控措施编码不能为空");
        }
        PreventRiskControlMeasure riskControlMeasureByCode =
                preventRiskControlMeasureService.getRiskControlMeasureByCodeAndEventId(riskEventById.getId(), measureSaveReqDTO.getControlMeasureCode());
        if (ObjectUtils.isNotEmpty(riskControlMeasureByCode)){
            throw new AusinessException(E.DATA_DATABASE_EXIST, "本事件已经存在同编码的管控措施，请修改名称或添加编号");
        }
        if (measureSaveReqDTO.getCheckContent() == null && measureSaveReqDTO.getCheckContent() == ""){
            throw new AusinessException(E.DATA_PARAM_NULL, "检查内容不能为空");
        }

        //获取需要填充的信息
        SnowFlow snowFlow = new SnowFlow();//雪花算法生成器
        String uuid = UUID.randomUUID().toString();
        Date date = new Date();
        long measureId = snowFlow.nextId();
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_MEASURE.getCode());
        //封装管控措施参数
        PreventRiskControlMeasure controlMeasure = BeanCopyUtils.copyBean(measureSaveReqDTO, PreventRiskControlMeasure.class);
        controlMeasure.setId(measureId);
        controlMeasure.setUuid(uuid);
        controlMeasure.setControlMeasureCode(measureSaveReqDTO.getControlMeasureCode());
        controlMeasure.setRiskEventId(riskEventById.getId());
        controlMeasure.setRiskEventUuid(riskEventById.getUuid());
        controlMeasure.setEnterpriseId((long) 1);
        controlMeasure.setEnterpriseUuid("123");
        controlMeasure.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());
        controlMeasure.setGmtModitify(date);
        controlMeasure.setGmtCreate(date);
        controlMeasure.setCreateByUserName(userById.getRealName());
        controlMeasure.setLastEditUserName(userById.getRealName());

        //创建管控措施不需要的字段填充
        controlMeasure.setCheckTaskUnitId(null);
        controlMeasure.setCheckTaskUnitUuid(null);
        controlMeasure.setCheckWorkId(null);
        controlMeasure.setCheckWorkUuid(null);
        controlMeasure.setCheckTaskId(null);
        controlMeasure.setCheckTaskUuid(null);

        controlMeasure.setReportTime(null);
        //读取上报主配置，进行任务记录上报配置,如果开启上报功能
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()){
            //自动上报
            if (reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
                //设置上报状态为-等待上报
                controlMeasure.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
                //设置本条数据上报开关为-开启
                controlMeasure.setReportSwitch(SyncEnum.REPORT_ON.getCode());
                //设置本条数据上报更新时间
                controlMeasure.setUpdateReportDataTime(date);
            }
            //手动上报
            if (reportConfigById.getReportType() == SyncEnum.REPORT_AUTO_EXEC_CONFIG.getCode()){
                //设置上报状态为-不上报
                controlMeasure.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
                //设置本条数据上报开关为-关闭
                controlMeasure.setReportSwitch(SyncEnum.REPORT_OFF.getCode());
                //设置本条数据上报更新时间
                controlMeasure.setUpdateReportDataTime(date);
            }
        }
        //如果主配置关闭上报功能
        if (reportConfigById.getReportState() == SyncEnum.REPORT_OFF.getCode()){
            //设置上报状态为-不上报
            controlMeasure.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
            //设置本条数据上报开关为-关闭
            controlMeasure.setReportSwitch(SyncEnum.REPORT_OFF.getCode());
            //设置本条数据上报更新时间
            controlMeasure.setUpdateReportDataTime(date);
        }

        //封装隐患检查内容的参数
        checkContent.setControlMeasureId(measureId);
        checkContent.setControlMeasureUuid(uuid);
        checkContent.setCheckContent(measureSaveReqDTO.getCheckContent());


        //执行措施插入
        int measureResult = preventRiskControlMeasureService.saveRiskControlMeasure(controlMeasure);
        //执行隐患检查内容插入
        int checkContentResult = preventDangerCheckContentService.saveDangerCheckContent(checkContent);

        resultVO.setCount(measureResult);
        return resultVO;
    }

    /**
     * 管控措施-修改
     */
    @Transactional
    @Override
    public ResultVO<PreventRiskControlMeasure> updateRiskControlMeasure(Long userId, PreventRiskControlMeasureUpdateReqDTO measureUpdateReqDTO) {

        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();

        PreventRiskAnaUnitUpdateParams params = new PreventRiskAnaUnitUpdateParams();
        PreventDangerCheckContent checkContent = new PreventDangerCheckContent();
        Date date = new Date();

        //校验参数
        if (measureUpdateReqDTO.getRiskEventId() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "风险事件不能为空");
        }
        //根据事件名称查询信息
        PreventRiskEvent riskEventById = preventRiskEventService.getRiskEventNameById(measureUpdateReqDTO.getRiskEventId());
        if (ObjectUtils.isEmpty(riskEventById)){
            throw new AusinessException(E.DATA_DATABASE_NO_EXISTENT, "请检查风险事件是否正确");
        }
        if (measureUpdateReqDTO.getControlType() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "管控方式不能为空，或设置有误");
        }
        if (measureUpdateReqDTO.getClassify1() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "管控方式分类1不能为空，或设置有误");
        }
        if (measureUpdateReqDTO.getClassify2() == null){
            throw new AusinessException(E.DATA_PARAM_NULL, "管控方式分类2不能为空，或设置有误");
        }
        //根据措施编码与事件id查询
        PreventRiskControlMeasure riskControlMeasureById
                = preventRiskControlMeasureService.getRiskControlMeasureByCodeAndEventId(riskEventById.getId(), measureUpdateReqDTO.getControlMeasureCode());
        //如果查询结果不为空，且查询到的id与请求的id不同——被占用
        if (ObjectUtils.isNotEmpty(riskControlMeasureById) && !measureUpdateReqDTO.getId().equals(riskControlMeasureById.getId())){
            throw new AusinessException(E.DATA_DATABASE_EXIST, "本事件已经存在同编码的管控措施，请修改名称或添加编号");
        }
        if (measureUpdateReqDTO.getCheckContent() == null && measureUpdateReqDTO.getCheckContent() == ""){
            throw new AusinessException(E.DATA_PARAM_NULL, "检查内容不能为空");
        }

        //封装修改参数
        PreventRiskControlMeasureUpdateParams updateParams =
                BeanCopyUtils.copyBean(measureUpdateReqDTO, PreventRiskControlMeasureUpdateParams.class);

        updateParams.setRiskEventId(riskEventById.getId());
        updateParams.setRiskEventUuid(riskEventById.getUuid());
        updateParams.setGmtModitify(date);
        updateParams.setLastEditUserName(userById.getRealName());
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_MEASURE.getCode());
        //读取上报主配置，进行任务记录上报配置,如果开启上报功能
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()){
            //自动上报
            if (reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
                //设置上报状态为-等待上报
                updateParams.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
                //设置本条数据上报开关为-开启
                updateParams.setReportSwitch(SyncEnum.REPORT_ON.getCode());
                //设置本条数据上报更新时间
                updateParams.setUpdateReportDataTime(date);
            }
            //手动上报
            if (reportConfigById.getReportType() == SyncEnum.REPORT_AUTO_EXEC_CONFIG.getCode()){
                //设置上报状态为-不上报
                updateParams.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
                //设置本条数据上报开关为-关闭
                updateParams.setReportSwitch(SyncEnum.REPORT_OFF.getCode());
                //设置本条数据上报更新时间
                updateParams.setUpdateReportDataTime(date);
            }
        }
        //如果主配置关闭上报功能
        if (reportConfigById.getReportState() == SyncEnum.REPORT_OFF.getCode()){
            //设置上报状态为-不上报
            updateParams.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
            //设置本条数据上报开关为-关闭
            updateParams.setReportSwitch(SyncEnum.REPORT_OFF.getCode());
            //设置本条数据上报更新时间
            updateParams.setUpdateReportDataTime(date);
        }

        //执行内容修改
        preventDangerCheckContentService.updateDangerCheckContent(measureUpdateReqDTO.getId(), measureUpdateReqDTO.getCheckContent());
        //执行措施修改
        int result = preventRiskControlMeasureService.updateRiskControlMeasure(updateParams);
        if (result == 0){
            throw new BusinessException(ResultCodes.SERVER_UPDATE_ERROR);
        }
        resultVO.setCount(result);
        return resultVO;
    }

    /**
     * 管控措施- 管控措施模板
     */
    @Override
    public ResultVO<PreventRiskControlMeasure> listMeasures(Long userId) {

        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();

        List<PreventRiskControlTemplate> listMeasureTemplates = preventRiskControlTemplateService.listMeasureTemplates();

        List<PreventRiskMeasureTemplatesListQueryRespDTO> respDTOS
                = BeanCopyUtils.copyBeanList(listMeasureTemplates, PreventRiskMeasureTemplatesListQueryRespDTO.class);

        resultVO.setCount(respDTOS.size());
        resultVO.setData(respDTOS);
        return resultVO;
    }
    /**
     * 管控措施- 管控措施列表
     */
    @Override
    public ResultVO<PreventRiskControlMeasure> listControlMeasure(ContextCacheUser currentUser) {
        ResultVO resultVO = new ResultVO<>();
        resultVO.setCode("200");
        resultVO.setMsg("查询成功");
        //获取用户信息

        ResultVO<UserRPCRespDTO> rpcResult = accountAuthService.getUserById(currentUser.getUid());
        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();

        List<PreventRiskControlMeasure> listControlMeasures = preventRiskControlMeasureService.listControlMeasure();
        if (ObjectUtils.isEmpty(listControlMeasures)){
            resultVO.setMsg("查询成功,无数据");
            return resultVO;
        }
        List<PreventRiskControlMeasureListRespDTO> list = new ArrayList<>();
        //List<PreventRiskControlMeasureListRespDTO> respDTOS = BeanCopyUtils.copyBeanList(listControlMeasures, PreventRiskControlMeasureListRespDTO.class);
        for (PreventRiskControlMeasure controlMeasure : listControlMeasures) {
            PreventDangerCheckContent checkContentByMeasureId = preventDangerCheckContentService.getCheckContentByMeasureId(controlMeasure.getId());
            PreventRiskControlMeasureListRespDTO respDTO = BeanCopyUtils.copyBean(controlMeasure, PreventRiskControlMeasureListRespDTO.class);
            respDTO.setCheckContent(checkContentByMeasureId.getCheckContent());
            list.add(respDTO);
        }

        resultVO.setCount(list.size());
        resultVO.setData(list);

        return resultVO;
    }

    /**
     * 管控措施-删除
     */
    @Override
    public ResultVO<PreventRiskControlMeasure> deleteRiskControlMeasure(Long userId, PreventRiskControlMeasureDeleteReqDTO measureDeleteReqDTO) {

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

        PreventRiskControlMeasureDeleteParams deleteParams = new PreventRiskControlMeasureDeleteParams();
        Date date = new Date();

        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);
        }
        //校验参数，封装id
        if (measureDeleteReqDTO.getId() != null){
            deleteParams.setId(measureDeleteReqDTO.getId());
        }
        PreventRiskControlMeasure controlMeasure
                = preventRiskControlMeasureService.getControlMeasureById(measureDeleteReqDTO.getId());
/*        //如果riskWorkId，checkTaskUnitId不为空，不能删除
        if (controlMeasure.getRiskWorkId() != null && controlMeasure.getCheckTaskUnitId() != null){
            throw new AusinessException(E.NOT_DELETE, "需要先把检查作业、检查任务对该措施的使用取消");
        }*/
        //封装措施修改参数
        deleteParams.setGmtModitify(date);
        deleteParams.setLastEditUserName(userById.getRealName());
        deleteParams.setUpdateReportDataTime(date);

        int result = preventRiskControlMeasureService.deleteRiskControlMeasure(deleteParams);
        //校验结果
        if (result == 0) {
            throw new AusinessException(E.NOT_DELETE, "删除失败");
        }

        resultVO.setCount(result);
        return resultVO;
    }




    /**
     * 风险分布图-图
     */
    @Override
    public ResultVO<PreventRiskMap> getMapImage(Long id) {

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


        FileInputStream inputStream = null;
        String base64Str = "";
        try {
            Base64.Encoder encoder = Base64.getEncoder();

            PreventRiskMap mapById = preventRiskMapService.getById(id);
            String filePath = "F:/img/"+mapById.getImgPath();

            inputStream = new FileInputStream(filePath);
            int available = inputStream.available();
            byte[] bytes = new byte[available];
            inputStream.read(bytes);
            base64Str = encoder.encodeToString(bytes);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                inputStream.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        resultVO.setData(base64Str);

        return resultVO;
    }
}