package com.ruoyi.project.tr.hiddenDangerCheck.controller;

import com.alibaba.fastjson.JSON;
import com.ruoyi.common.constant.TrHiddenDangerCheckConstants;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.common.utils.security.ShiroUtils;
import com.ruoyi.doublePrevention.service.RiskService;
import com.ruoyi.framework.aspectj.lang.annotation.Log;
import com.ruoyi.framework.aspectj.lang.enums.BusinessType;
import com.ruoyi.framework.web.controller.BaseController;
import com.ruoyi.framework.web.domain.AjaxResult;
import com.ruoyi.framework.web.page.TableDataInfo;
import com.ruoyi.project.system.company.domain.Company;
import com.ruoyi.project.system.company.service.ICompanyService;
import com.ruoyi.project.system.role.service.IRoleService;
import com.ruoyi.project.system.roleRegion.domain.RoleRegion;
import com.ruoyi.project.system.user.domain.User;
import com.ruoyi.project.system.user.service.IUserService;
import com.ruoyi.project.tr.hiddenDangerCheck.domain.HiddenDangerCheck;
import com.ruoyi.project.tr.hiddenDangerCheck.domain.HiddenDangerCheckByPlanExecuteExport;
import com.ruoyi.project.tr.hiddenDangerCheck.domain.HiddenDangerCheckByScheduleExport;
import com.ruoyi.project.tr.hiddenDangerCheck.service.IHiddenDangerCheckService;
import com.ruoyi.project.tr.hiddenDangerCheckPoint.domain.HiddenDangerCheckPoint;
import com.ruoyi.project.tr.hiddenDangerCheckPoint.service.IHiddenDangerCheckPointService;
import com.ruoyi.project.tr.hiddenTroubleType.domain.HiddenTroubleType;
import com.ruoyi.project.tr.hiddenTroubleType.service.IHiddenTroubleTypeService;
import com.ruoyi.project.tr.riskCheckPoint.domain.RiskCheckPoint;
import com.ruoyi.project.tr.riskCheckPoint.service.IRiskCheckPointService;
import com.ruoyi.project.tr.riskEvaluationPlan.domain.RiskEvaluationPlan;
import com.ruoyi.project.tr.riskEvaluationPlan.service.IRiskEvaluationPlanService;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

/**
 * 定时隐患排查Controller
 *
 * @date 2020-05-08
 */
@Controller
@RequestMapping("/tr/hiddenDangerCheck/dangerSchedule")
public class DangerScheduleController extends BaseController {
    private String prefix = "tr/hiddenDangerCheck/dangerSchedule";

    @Autowired
    private IHiddenDangerCheckService hiddenDangerCheckService;

    @Autowired
    private IHiddenTroubleTypeService hiddenTroubleTypeService;

    @Autowired
    private IUserService userService;

    @Autowired
    private IRiskEvaluationPlanService riskEvaluationPlanService;

    @Autowired
    private IRiskCheckPointService riskCheckPointService;

    @Autowired
    private IHiddenDangerCheckPointService hiddenDangerCheckPointService;

    @Autowired
    private ICompanyService companyService;

    @Autowired
    private IRoleService roleService;

    @Autowired
    private RiskService riskService;

    @GetMapping()
    public String hiddenDangerCheck(ModelMap mmap) {
        mmap.put("userId", getSysUser().getUserId());
        mmap.put("companyId", getSysUser().getCompanyId());
        Set<String> roleSet = roleService.selectRoleKeys(getSysUser().getUserId());
        if (roleSet.contains("common")) {
            mmap.put("role", "common");
        }else{
            mmap.put("role", "");
        }
        return prefix + "/dangerSchedule";
    }


    @GetMapping("/listByCompanyId/{companyId}")
    public String listByCompanyId(@PathVariable("companyId") Long companyId, ModelMap mmap) {
        mmap.put("companyId", companyId);
        return prefix + "/dangerScheduleByCompanyId";
    }


    /**
     * 查询隐患核查列表
     */
    @PostMapping("/listByCompanyId")
    @ResponseBody
    public TableDataInfo listByCompanyId(String companyId, HiddenDangerCheck hiddenDangerCheck) {

        User userQuery = new User();
        userQuery.setCompanyId(Long.valueOf(companyId));
        List<User> userList = userService.selectUserList(userQuery);
        List<Long> userIdList = new ArrayList<>();
        for (User user : userList) {
            userIdList.add(user.getUserId());
        }
        if (userIdList.size() == 0) {
            return getDataTable(new ArrayList<HiddenDangerCheck>());
        }
        //排查人为 为登陆账号companyId下的userId的
        hiddenDangerCheck.setScheduleCheckUserIdList(userIdList);
        startPage();
        List<HiddenDangerCheck> list = hiddenDangerCheckService.selectHiddenDangerCheckList(hiddenDangerCheck);
        return getDataTable(list);
    }


    /**
     * 查询定时隐患排查列表
     */
    @PostMapping("/list")
    @ResponseBody
    public TableDataInfo list(HiddenDangerCheck hiddenDangerCheck) {
        Set<String> roleSet = roleService.selectRoleKeys(getSysUser().getUserId());
        if (roleSet.contains("common")) {
            List<Long> companyIdList = new ArrayList<>();
            Company companyParent = companyService.selectCompanyById(getSysUser().getCompanyId());
            companyIdList.add(companyParent.getCompanyId());
            Company sonQuery = new Company();
            sonQuery.setParentId(companyParent.getCompanyId());
            List<Company> sonList = companyService.selectCompanyList(sonQuery);
            for (Company son : sonList) {
                companyIdList.add(son.getCompanyId());
            }
            User userQuery = new User();
            userQuery.setCompanyIdList(companyIdList);
            List<User> userList = userService.selectUserList(userQuery);
            List<Long> userIdList = new ArrayList<>();
            for (User user : userList) {
                userIdList.add(user.getUserId());
            }
            hiddenDangerCheck.setScheduleCheckUserIdList(userIdList);//排查人为（本公司和子公司用户）userId的
            startPage();
            List<HiddenDangerCheck> list = hiddenDangerCheckService.selectHiddenDangerCheckList(hiddenDangerCheck);
            return getDataTable(list);
        }
        startPage();
        hiddenDangerCheck.setScheduleCheckUserId(getSysUser().getUserId());//排查人为本登录帐号userId的
        List<HiddenDangerCheck> list = hiddenDangerCheckService.selectHiddenDangerCheckList(hiddenDangerCheck);
        return getDataTable(list);
    }


    /**
     * 定时隐患排查列表导出
     */
    @Log(title = "定时隐患排查列表", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    @ResponseBody
    public AjaxResult export(HiddenDangerCheck hiddenDangerCheck) {
        hiddenDangerCheck.setScheduleCheckUserId(getSysUser().getUserId());//排查人为本登录帐号userId的
        List<HiddenDangerCheck> list = hiddenDangerCheckService.selectHiddenDangerCheckList(hiddenDangerCheck);
        List<HiddenDangerCheck> listTemp = hiddenDangerCheckService.selectHiddenDangerCheckList(hiddenDangerCheck);
        String stringTemp = JSON.toJSONString(listTemp);
        List<HiddenDangerCheckByScheduleExport> listExport = JSON.parseArray(stringTemp, HiddenDangerCheckByScheduleExport.class);

        for (HiddenDangerCheckByScheduleExport export : listExport) {
            if (export != null) {
                if ("1".equals(export.getCheckType())) {
                    export.setCheckTypeName("基础清单排查");
                } else if ("2".equals(export.getCheckType())) {
                    export.setCheckTypeName("风险单元清单排查");
                }

                if (("1".equals(export.getCheckType())) && (!StringUtils.isEmpty(export.getRiskName()))) {
                    export.setBasicRiskNameLabel(export.getRiskName());
                }


                if ((!("1".equals(export.getCheckType()))) && (!StringUtils.isEmpty(export.getRiskName()))) {
                    export.setRiskNameLabel(export.getRiskName());
                }


                if ("1".equals(export.getRiskType())) {
                    export.setRiskType("设备设施清单");
                } else if ("2".equals(export.getRiskType())) {
                    export.setRiskType("作业活动清单");
                } else if ("3".equals(export.getRiskType())) {
                    export.setRiskType("工艺节点清单");
                } else {
                    export.setRiskType("");
                }


                Long typeCycleNum = export.getTroubleshootTypeCycleNum();
                Long typeCycleType = export.getTroubleshootTypeCycleType();
                String typeCycleTypeLabel = "";
                if (typeCycleType == 1L) {
                    typeCycleTypeLabel = "小时";
                } else if (typeCycleType == 2L) {
                    typeCycleTypeLabel = "日";
                } else if (typeCycleType == 3L) {
                    typeCycleTypeLabel = "周";
                } else if (typeCycleType == 4L) {
                    typeCycleTypeLabel = "月";
                } else if (typeCycleType == 5L) {
                    typeCycleTypeLabel = "年";
                }
                String troubleshootCycleInfo = typeCycleNum + typeCycleTypeLabel + "1次";
                export.setTroubleshootCycleInfo(troubleshootCycleInfo);


                if ("0".equals(export.getScheduleCheckStatus())) {
                    export.setScheduleCheckStatus("未排查");
                } else if ("1".equals(export.getScheduleCheckStatus())) {
                    export.setScheduleCheckStatus("已排查");
                }
            }
        }

        ExcelUtil<HiddenDangerCheckByScheduleExport> util = new ExcelUtil<HiddenDangerCheckByScheduleExport>(HiddenDangerCheckByScheduleExport.class);
        return util.exportExcel(listExport, "定时隐患排查列表");

    }


//    @GetMapping("/detailCheckItems/{checkId}")
//    public String detailCheckItems(@PathVariable("checkId") Long checkId, ModelMap mmap) {
//        //隐患排查实体
//        HiddenDangerCheck hiddenDangerCheck = hiddenDangerCheckService.selectHiddenDangerCheckById(Long.valueOf(checkId));
//        mmap.put("hiddenDangerCheck", hiddenDangerCheck);
//        List<RiskCheckPoint> checkItems = new ArrayList<RiskCheckPoint>();
//        String planLabel = "";//风险单元是否评价
//        if (hiddenDangerCheck != null
//                && (!StringUtils.isEmpty(hiddenDangerCheck.getCheckType()))
//                && ("2".equals(hiddenDangerCheck.getCheckType()))
//                && (hiddenDangerCheck.getRiskId() != null)) {
//            //查询该风险单元最近的评价计划
//            RiskEvaluationPlan plan = riskEvaluationPlanService.getRiskEvaluationPlanByRecent(hiddenDangerCheck.getRiskId());
//            if (plan == null) {
//                planLabel = "0";//该风险单元未评价，暂无排查项目
//                mmap.put("planLabel", planLabel);
//                return prefix + "/detailCheckItems";
//            }
//            RiskCheckPoint checkPoint = new RiskCheckPoint();
//            checkPoint.setPlanId(plan.getPlanId());
//            List<RiskCheckPoint> checkPointList = riskCheckPointService.selectRiskCheckPointList(checkPoint);
//            planLabel = "1";//该风险单元已评价，显示排查项目
//            mmap.put("checkPointList", checkPointList);//排查项目信息
//        }
//        mmap.put("planLabel", planLabel);
//        return prefix + "/detailCheckItems";
//    }


//    /**
//     * 设置为记录正常
//     */
//    @Log(title = "设置为记录正常")
//    @PostMapping("/editSetNormal")
//    @ResponseBody
//    public AjaxResult editSetNormal(String id) {
//        HiddenDangerCheck hiddenDangerCheck = hiddenDangerCheckService.selectHiddenDangerCheckById(Long.valueOf(id));
//        hiddenDangerCheck.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_NOT);//是否为隐患(正常)
//        hiddenDangerCheck.setScheduleCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)（定时任务生成的数据）
//        hiddenDangerCheck.setCheckTime(DateUtils.getNowDate());//设置排查时间
//        return toAjax(hiddenDangerCheckService.updateHiddenDangerCheck(hiddenDangerCheck));
//    }
//
//
//    /**
//     * 隐患登记
//     */
//    @Log(title = "隐患登记")
//    @GetMapping("/editDangerRegister/{checkId}")
//    public String dangerRegister(@PathVariable("checkId") Long checkId, ModelMap mmap) {
//        //隐患排查实体
//        HiddenDangerCheck hiddenDangerCheck = hiddenDangerCheckService.selectHiddenDangerCheckById(Long.valueOf(checkId));
//        mmap.put("hiddenDangerCheck", hiddenDangerCheck);
//
//        //隐患类别
//        User sysUser = getSysUser();
//        HiddenTroubleType hiddenTroubleType = new HiddenTroubleType();
//        hiddenTroubleType.setCompanyId(sysUser.getCompanyId());
//        List<HiddenTroubleType> hiddenTroubleTypeList = hiddenTroubleTypeService.selectHiddenTroubleTypeList(hiddenTroubleType);
//        mmap.put("hiddenTroubleTypeList", hiddenTroubleTypeList);
//
//        //获取所在公司人员信息
//        if (sysUser != null && sysUser.getCompanyId() != null) {
//            User userTemp = new User();
//            userTemp.setCompanyId(sysUser.getCompanyId());
//            List<User> userList = userService.selectUserList(userTemp);
//            mmap.put("userList", userList);
//        }
//        return prefix + "/editDangerRegister";
//    }
//
//
//    /**
//     * 隐患登记--保存
//     */
//    @Log(title = "隐患登记--保存", businessType = BusinessType.UPDATE)
//    @PostMapping("/editDangerRegisterSave")
//    @ResponseBody
//    public AjaxResult editDangerRegisterSave(HiddenDangerCheck hiddenDangerCheck) {
//        hiddenDangerCheck.setRegisterCreateTime(DateUtils.getNowDate());//设置隐患登记上报创建时间
//        hiddenDangerCheck.setRegisterUserId(getSysUser().getUserId());//设置隐患登记上报创建人ID
//        hiddenDangerCheck.setRegisterUserName(getSysUser().getUserName());//设置隐患登记上报创建人名称
//        hiddenDangerCheck.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_YES);//是否为隐患(是隐患)
//        hiddenDangerCheck.setScheduleCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)
//        hiddenDangerCheck.setExamineStatus(TrHiddenDangerCheckConstants.EXAMINE_STATUS_NOT_EXAMINE);//核查状态(待核查)
//        hiddenDangerCheck.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_EXAMINE);//隐患核查阶段(数据进入到隐患核查阶段)
//        hiddenDangerCheck.setCheckTime(DateUtils.getNowDate());//设置排查时间
//        return toAjax(hiddenDangerCheckService.updateHiddenDangerCheck(hiddenDangerCheck));
//    }
//
//
//    /**
//     * 隐患登记查看
//     */
//    @GetMapping("/detailDangerRegister/{checkId}")
//    public String detailDangerRegister(@PathVariable("checkId") Long checkId, ModelMap mmap) {
//        HiddenDangerCheck hiddenDangerCheck = hiddenDangerCheckService.selectHiddenDangerCheckById(checkId);
//        mmap.put("hiddenDangerCheck", hiddenDangerCheck);
//        return prefix + "/detailDangerRegister";
//    }


    /**
     * 操作定时隐患排查
     */
    @Log(title = "操作定时隐患排查")
    @GetMapping("/editDangerSchedule/{checkId}")
    public String editDangerSchedule(@PathVariable("checkId") Long checkId, ModelMap mmap) {
        //隐患排查实体
        HiddenDangerCheck hiddenDangerCheck = hiddenDangerCheckService.selectHiddenDangerCheckById(Long.valueOf(checkId));
        mmap.put("hiddenDangerCheck", hiddenDangerCheck);

        //获取所在公司人员信息
        User sysUser = getSysUser();
        if (sysUser != null && sysUser.getCompanyId() != null) {
            User userTemp = new User();
            userTemp.setCompanyId(sysUser.getCompanyId());
            List<User> userList = userService.selectUserList(userTemp);
            mmap.put("userList", userList);
        }

        return prefix + "/editDangerSchedule";
    }


    /**
     * 查看定时隐患排查
     */
    @Log(title = "查看定时隐患排查")
    @GetMapping("/detailDangerSchedule/{checkId}")
    public String detailDangerPlanExecute(@PathVariable("checkId") Long checkId, ModelMap mmap) {
        //隐患排查实体
        HiddenDangerCheck hiddenDangerCheck = hiddenDangerCheckService.selectHiddenDangerCheckById(Long.valueOf(checkId));
        mmap.put("hiddenDangerCheck", hiddenDangerCheck);
        return prefix + "/detailDangerSchedule";
    }


    /**
     * 定时隐患排查执行--保存
     */
    @Log(title = "定时隐患排查执行--保存", businessType = BusinessType.UPDATE)
    @PostMapping("/editDangerScheduleSave")
    @ResponseBody
    public AjaxResult editDangerScheduleSave(HiddenDangerCheck hiddenDangerCheck) {
        hiddenDangerCheck.setScheduleCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)
        hiddenDangerCheck.setCheckTime(DateUtils.getNowDate());//设置排查时间

        HiddenDangerCheckPoint hdcpTemp = new HiddenDangerCheckPoint();
        hdcpTemp.setCheckId(hiddenDangerCheck.getCheckId());
        List<HiddenDangerCheckPoint> hdcpList = hiddenDangerCheckPointService.selectHiddenDangerCheckPointList(hdcpTemp);

        for (HiddenDangerCheckPoint hdcp : hdcpList) {
            if (StringUtils.isEmpty(hdcp.getWhetherDanger())) {
                return AjaxResult.error("检查点需全部操作，请操作检查点。");
            }
        }


        hdcpList.forEach(hdcp -> {
            if (hdcp != null) {
                hdcp.setUpdateBy(ShiroUtils.getLoginName());//更新者
                hdcp.setUpdateTime(DateUtils.getNowDate());//更新时间\
                //是隐患设置核查人ID、核查人名称
                if ((!StringUtils.isEmpty(hdcp.getWhetherDanger())) &&
                        (TrHiddenDangerCheckConstants.WHETHER_DANGER_YES.equals(hdcp.getWhetherDanger()))) {
                    hdcp.setExamineStatus(TrHiddenDangerCheckConstants.EXAMINE_STATUS_NOT_EXAMINE);//核查状8态(待核查)
                    hdcp.setExamineUserId(hiddenDangerCheck.getExamineUserId());//核查人ID
                    hdcp.setExamineUserName(hiddenDangerCheck.getExamineUserName());//核查人名称
                    hdcp.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_EXAMINE);//3隐患核查阶段(/** 更新者 */数据进入到3隐患核查阶段)
                }
                hiddenDangerCheckPointService.updateHiddenDangerCheckPoint(hdcp);
            }
        });

        int i = hiddenDangerCheckService.updateHiddenDangerCheck(hiddenDangerCheck);
        hiddenDangerCheckPointService.getTaskCountTotal(getSysUser().getUserId());//查询未执行任务总数量并推送

        return toAjax(i);
    }


    /**
     * 设置检查点为记录正常
     */
    @Log(title = "设置检查点为记录正常")
    @PostMapping("/editPointSetNormal")
    @ResponseBody
    public AjaxResult editPointSetNormal(String id) {
        HiddenDangerCheckPoint hiddenDangerCheckPoint = hiddenDangerCheckPointService.selectHiddenDangerCheckPointById(Long.valueOf(id));
        hiddenDangerCheckPoint.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_NOT);//是否为隐患(正常)
//        hiddenDangerCheckPoint.setScheduleCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)（定时任务生成的数据）
//        hiddenDangerCheckPoint.setCheckTime(DateUtils.getNowDate());//设置排查时间

        int i = hiddenDangerCheckPointService.updateHiddenDangerCheckPoint(hiddenDangerCheckPoint);
        hiddenDangerCheckPointService.getTaskCountTotal(getSysUser().getUserId());//查询未执行任务总数量并推送

        return toAjax(i);
    }


    /**
     * 检查点隐患登记
     */
    @Log(title = "检查点隐患登记")
    @GetMapping("/editPointDangerRegister/{id}")
    public String editPointDangerRegister(@PathVariable("id") Long id, ModelMap mmap) {
        //隐患排查检查点实体
        HiddenDangerCheckPoint hiddenDangerCheckPoint = hiddenDangerCheckPointService.selectHiddenDangerCheckPointById(Long.valueOf(id));
        mmap.put("hiddenDangerCheckPoint", hiddenDangerCheckPoint);

        //隐患类别
        User sysUser = getSysUser();
        HiddenTroubleType hiddenTroubleType = new HiddenTroubleType();
        hiddenTroubleType.setCompanyId(sysUser.getCompanyId());
        List<HiddenTroubleType> hiddenTroubleTypeList = hiddenTroubleTypeService.selectHiddenTroubleTypeList(hiddenTroubleType);
        mmap.put("hiddenTroubleTypeList", hiddenTroubleTypeList);

        return prefix + "/editPointDangerRegister";
    }


    /**
     * 检查点隐患登记--保存
     */
    @Log(title = "检查点隐患登记--保存", businessType = BusinessType.UPDATE)
    @PostMapping("/editPointDangerRegisterSave")
    @ResponseBody
    public AjaxResult editPointDangerRegisterSave(HiddenDangerCheckPoint hiddenDangerCheckPoint) {
        hiddenDangerCheckPoint.setRegisterCreateTime(DateUtils.getNowDate());//设置隐患登记上报创建时间
        hiddenDangerCheckPoint.setRegisterUserId(getSysUser().getUserId());//设置隐患登记上报创建人ID
        hiddenDangerCheckPoint.setRegisterUserName(getSysUser().getUserName());//设置隐患登记上报创建人名称
        hiddenDangerCheckPoint.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_YES);//是否为隐患(是隐患)
        hiddenDangerCheckPoint.setScheduleCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)
        hiddenDangerCheckPoint.setExamineStatus(TrHiddenDangerCheckConstants.EXAMINE_STATUS_NOT_EXAMINE);//核查状态(待核查)
        hiddenDangerCheckPoint.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_EXAMINE);//隐患核查阶段(数据进入到隐患核查阶段)
//        hiddenDangerCheckPoint.setCheckTime(DateUtils.getNowDate());//设置排查时间
        hiddenDangerCheckPoint.setDangerSources(TrHiddenDangerCheckConstants.DANGER_SOURCES_SCHEDULE_PRODUCE); //隐患来源(定时器任务生成)

        HiddenDangerCheckPoint queryExist = new HiddenDangerCheckPoint();
        queryExist.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_YES);//是否为隐患(是隐患)
        queryExist.setCheckPointId(hiddenDangerCheckPoint.getCheckPointId());
        queryExist.setCheckId(hiddenDangerCheckPoint.getCheckId());
        List<HiddenDangerCheckPoint> queryExistList = hiddenDangerCheckPointService.selectHiddenDangerCheckPointList(queryExist);
        int i = 0;
        if (queryExistList.size() > 0) {
            hiddenDangerCheckPoint.setId(null);
            hiddenDangerCheckPoint.setCheckTime(DateUtils.getNowDate());
            hiddenDangerCheckPoint.setCreateBy(getSysUser().getLoginName());
            hiddenDangerCheckPoint.setCreateTime(DateUtils.getNowDate());

            hiddenDangerCheckPoint.setCompanyId(getSysUser().getCompanyId());
            i = hiddenDangerCheckPointService.insertHiddenDangerCheckPoint(hiddenDangerCheckPoint);
        } else {
            hiddenDangerCheckPoint.setUpdateBy(getSysUser().getLoginName());
            hiddenDangerCheckPoint.setUpdateTime(DateUtils.getNowDate());
            i = hiddenDangerCheckPointService.updateHiddenDangerCheckPoint(hiddenDangerCheckPoint);
        }
        hiddenDangerCheckPointService.getTaskCountTotal(getSysUser().getUserId());//查询未执行任务总数量并推送

        return toAjax(i);
    }


    /**
     * 检查点隐患登记--保存,第二次以上登记隐患
     */
    @Log(title = "检查点隐患登记--保存", businessType = BusinessType.UPDATE)
    @PostMapping("/editPointDangerRegisterSaveTwo")
    @ResponseBody
    public AjaxResult editPointDangerRegisterSaveTwo(HiddenDangerCheckPoint hiddenDangerCheckPoint) {
        hiddenDangerCheckPoint.setRegisterCreateTime(DateUtils.getNowDate());//设置隐患登记上报创建时间
        hiddenDangerCheckPoint.setRegisterUserId(getSysUser().getUserId());//设置隐患登记上报创建人ID
        hiddenDangerCheckPoint.setRegisterUserName(getSysUser().getUserName());//设置隐患登记上报创建人名称
        hiddenDangerCheckPoint.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_YES);//是否为隐患(是隐患)
        hiddenDangerCheckPoint.setScheduleCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)
        hiddenDangerCheckPoint.setExamineStatus(TrHiddenDangerCheckConstants.EXAMINE_STATUS_NOT_EXAMINE);//核查状态(待核查)
        hiddenDangerCheckPoint.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_EXAMINE);//隐患核查阶段(数据进入到隐患核查阶段)
//        hiddenDangerCheckPoint.setCheckTime(DateUtils.getNowDate());//设置排查时间
        hiddenDangerCheckPoint.setDangerSources(TrHiddenDangerCheckConstants.DANGER_SOURCES_SCHEDULE_PRODUCE); //隐患来源(定时器任务生成)

        hiddenDangerCheckPoint.setCompanyId(getSysUser().getCompanyId());
        int i = hiddenDangerCheckPointService.insertHiddenDangerCheckPoint(hiddenDangerCheckPoint);

        hiddenDangerCheckPointService.getTaskCountTotal(getSysUser().getUserId());//查询未执行任务总数量并推送

        return toAjax(i);
    }


    /**
     * 隐患登记查看
     */
    @GetMapping("/detailPointDangerRegister/{id}")
    public String detailPointDangerRegister(@PathVariable("id") Long id, ModelMap mmap) {
        HiddenDangerCheckPoint hiddenDangerCheckPoint = hiddenDangerCheckPointService.selectHiddenDangerCheckPointById(id);
        mmap.put("hiddenDangerCheckPoint", hiddenDangerCheckPoint);
        return prefix + "/detailPointDangerRegister";
    }


    /**
     * 删除定时隐患排查
     */
    @Log(title = "删除定时隐患排查", businessType = BusinessType.DELETE)
    @PostMapping("/remove")
    @ResponseBody
    @Transactional
    public AjaxResult remove(String ids) {
        //老代码
        int result = hiddenDangerCheckService.deleteHiddenDangerCheckByIds(ids);

        // todo-2022 删除定时核查任务 新代码添加
        int result1 = riskService.deleteDangerCheck(ids);
        if (result1 < 1){
            throw new RuntimeException("删除核查任务附属表失败");
        }

        return toAjax(result);
    }


}