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.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.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.service.IRiskCheckPointService;
import com.ruoyi.project.tr.riskEvaluationPlan.service.IRiskEvaluationPlanService;
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;

/**
 * 隐患排查计划执行Controller
 *
 * @date 2020-05-08
 */
@Controller
@RequestMapping("/tr/hiddenDangerCheck/dangerPlanExecute")
public class DangerPlanExecuteController extends BaseController {
    private String prefix = "tr/hiddenDangerCheck/dangerPlanExecute";

    @Autowired
    private IHiddenDangerCheckService hiddenDangerCheckService;

    @Autowired
    private IHiddenDangerCheckPointService hiddenDangerCheckPointService;

    @Autowired
    private IHiddenTroubleTypeService hiddenTroubleTypeService;

    @Autowired
    private IUserService userService;

    @Autowired
    private IRiskCheckPointService riskCheckPointService;

    @Autowired
    private RiskService riskService;


    @Autowired
    private IRiskEvaluationPlanService riskEvaluationPlanService;

    @GetMapping()
    public String hiddenDangerCheck() {
        return prefix + "/dangerPlanExecute";
    }


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


    /**
     * 查询隐患核查列表
     */
    @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>());
        }
        hiddenDangerCheck.setCheckUserIdList(userIdList);//排查人ID 为登陆账号companyId下的userId的
        hiddenDangerCheck.setPlanFormulateStatusExclude(TrHiddenDangerCheckConstants.PLAN_FORMULATE_STATUS_NOT_STARTED);//排除---------隐患排查计划制定(未开始)的
        startPage();
        List<HiddenDangerCheck> list = hiddenDangerCheckService.selectHiddenDangerCheckList(hiddenDangerCheck);
        return getDataTable(list);
    }


    /**
     * 查询隐患排查计划执行列表
     */
    @PostMapping("/list")
    @ResponseBody
    public TableDataInfo list(HiddenDangerCheck hiddenDangerCheck) {
        startPage();
        hiddenDangerCheck.setCheckUserId(getSysUser().getUserId());//排查人为本登录帐号userId的
        hiddenDangerCheck.setPlanFormulateStatusExclude(TrHiddenDangerCheckConstants.PLAN_FORMULATE_STATUS_NOT_STARTED);//排除---------隐患排查计划制定(未开始)的
        List<HiddenDangerCheck> list = hiddenDangerCheckService.selectHiddenDangerCheckList(hiddenDangerCheck);
        return getDataTable(list);
    }


    /**
     * 隐患排查计划执行列表导出
     */
    @Log(title = "隐患排查计划执行列表", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    @ResponseBody
    public AjaxResult export(HiddenDangerCheck hiddenDangerCheck) {
        hiddenDangerCheck.setCheckUserId(getSysUser().getUserId());//排查人为本登录帐号userId的
        hiddenDangerCheck.setPlanFormulateStatusExclude(TrHiddenDangerCheckConstants.PLAN_FORMULATE_STATUS_NOT_STARTED);//排除---------隐患排查计划制定(未开始)的
        List<HiddenDangerCheck> listTemp = hiddenDangerCheckService.selectHiddenDangerCheckList(hiddenDangerCheck);
        String stringTemp = JSON.toJSONString(listTemp);
        List<HiddenDangerCheckByPlanExecuteExport> listExport = JSON.parseArray(stringTemp, HiddenDangerCheckByPlanExecuteExport.class);


        for (HiddenDangerCheckByPlanExecuteExport 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.getPlanExecuteStatus())) {
                    export.setPlanExecuteStatus("未开始");
                } else if ("2".equals(export.getPlanExecuteStatus())) {
                    export.setPlanExecuteStatus("已完成");
                }
            }
        }

        ExcelUtil<HiddenDangerCheckByPlanExecuteExport> util = new ExcelUtil<HiddenDangerCheckByPlanExecuteExport>(HiddenDangerCheckByPlanExecuteExport.class);
        return util.exportExcel(listExport, "隐患排查计划执行列表");

    }


//    /**
//     * 设置为记录正常
//     */
//    @Log(title = "设置为记录正常")
//    @PostMapping("/editSetNormal")
//    @ResponseBody
//    public AjaxResult editSetNormal(String id) {
//        HiddenDangerCheck hiddenDangerCheck = hiddenDangerCheckService.selectHiddenDangerCheckById(Long.valueOf(id));
//        hiddenDangerCheck.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_NOT);//是否为隐患(正常)
//        hiddenDangerCheck.setCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)
//        hiddenDangerCheck.setPlanFormulateStatus(TrHiddenDangerCheckConstants.PLAN_FORMULATE_STATUS_ALREADY_COMPLETE);//隐患排查计划制定(已完成)
//        hiddenDangerCheck.setPlanExecuteStatus(TrHiddenDangerCheckConstants.PLAN_EXECUTE_STATUS_ALREADY_COMPLETE);//隐患排查计划执行(已完成)
//        return toAjax(hiddenDangerCheckService.updateHiddenDangerCheck(hiddenDangerCheck));
//    }
//
//
//
//    /**
//     * 隐患登记
//     */
//    @Log(title = "隐患登记")
//    @GetMapping("/editDangerRegister/{checkId}")
//    public String editDangerRegister(@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.setCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)
//        hiddenDangerCheck.setExamineStatus(TrHiddenDangerCheckConstants.EXAMINE_STATUS_NOT_EXAMINE);//核查状态(待核查)
//        hiddenDangerCheck.setPlanFormulateStatus(TrHiddenDangerCheckConstants.PLAN_FORMULATE_STATUS_ALREADY_COMPLETE);//隐患排查计划制定(已完成)
//        hiddenDangerCheck.setPlanExecuteStatus(TrHiddenDangerCheckConstants.PLAN_EXECUTE_STATUS_ALREADY_COMPLETE);//隐患排查计划执行(已完成)
//        hiddenDangerCheck.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_EXAMINE);//隐患核查阶段(数据进入到隐患核查阶段)
//
//        hiddenDangerCheck.setDangerSources(TrHiddenDangerCheckConstants.DANGER_SOURCES_PLAN_PRODUCE); //隐患来源(隐患计划排查生成)
//
//        return toAjax(hiddenDangerCheckService.updateHiddenDangerCheck(hiddenDangerCheck));
//    }
//
//
//    /**
//     * 隐患登记查看
//     */
//    @GetMapping("/detailDangerRegister/{checkId}")
//    public String detail(@PathVariable("checkId") Long checkId, ModelMap mmap) {
//        HiddenDangerCheck hiddenDangerCheck = hiddenDangerCheckService.selectHiddenDangerCheckById(checkId);
//        mmap.put("hiddenDangerCheck", hiddenDangerCheck);
//        return prefix + "/detailDangerRegister";
//    }


    /**
     * 操作隐患排查计划执行
     */
    @Log(title = "操作隐患排查计划执行")
    @GetMapping("/editDangerPlanExecute/{checkId}")
    public String editDangerPlanExecute(@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 + "/editDangerPlanExecute";
    }


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


    /**
     * 隐患排查计划执行--保存
     */
    @Log(title = "隐患排查计划执行--保存", businessType = BusinessType.UPDATE)
    @PostMapping("/editDangerPlanExecuteSave")
    @ResponseBody
    public AjaxResult editDangerPlanExecuteSave(HiddenDangerCheck hiddenDangerCheck) {
//        hiddenDangerCheck.setRegisterCreateTime(DateUtils.getNowDate());//设置隐患登记上报创建时间
//        hiddenDangerCheck.setRegisterUserId(getSysUser().getUserId());//设置隐患登记上报创建人ID
//        hiddenDangerCheck.setRegisterUserName(getSysUser().getUserName());//设置隐患登记上报创建人名称
//        hiddenDangerCheck.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_YES);//是否为隐患(是隐患)
        hiddenDangerCheck.setCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)
        hiddenDangerCheck.setCheckTime(DateUtils.getNowDate());//设置排查时间
//        hiddenDangerCheck.setExamineStatus(TrHiddenDangerCheckConstants.EXAMINE_STATUS_NOT_EXAMINE);//核查状态(待核查)
        hiddenDangerCheck.setPlanFormulateStatus(TrHiddenDangerCheckConstants.PLAN_FORMULATE_STATUS_ALREADY_COMPLETE);//隐患排查计划制定(已完成)
        hiddenDangerCheck.setPlanExecuteStatus(TrHiddenDangerCheckConstants.PLAN_EXECUTE_STATUS_ALREADY_COMPLETE);//隐患排查计划执行(已完成)
//        hiddenDangerCheck.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_EXAMINE);//隐患核查阶段(数据进入到隐患核查阶段)

//        hiddenDangerCheck.setDangerSources(TrHiddenDangerCheckConstants.DANGER_SOURCES_PLAN_PRODUCE); //隐患来源(隐患计划排查生成)

        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);//核查状态(待核查)
                    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.setCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)
//        hiddenDangerCheckPoint.setPlanFormulateStatus(TrHiddenDangerCheckConstants.PLAN_FORMULATE_STATUS_ALREADY_COMPLETE);//隐患排查计划制定(已完成)
//        hiddenDangerCheckPoint.setPlanExecuteStatus(TrHiddenDangerCheckConstants.PLAN_EXECUTE_STATUS_ALREADY_COMPLETE);//隐患排查计划执行(已完成)

        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";
    }


    /**
     * 检查点隐患登记--保存
     * todo-2022 手机端-暂时未改动
     */
    @Log(title = "检查点隐患登记--保存", businessType = BusinessType.UPDATE)
    @PostMapping("/editPointDangerRegisterSave")
    @ResponseBody
    @Transactional
    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.setCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)
        hiddenDangerCheckPoint.setExamineStatus(TrHiddenDangerCheckConstants.EXAMINE_STATUS_NOT_EXAMINE);//核查状态(待核查)
//        hiddenDangerCheckPoint.setPlanFormulateStatus(TrHiddenDangerCheckConstants.PLAN_FORMULATE_STATUS_ALREADY_COMPLETE);//隐患排查计划制定(已完成)
//        hiddenDangerCheckPoint.setPlanExecuteStatus(TrHiddenDangerCheckConstants.PLAN_EXECUTE_STATUS_ALREADY_COMPLETE);//隐患排查计划执行(已完成)
        hiddenDangerCheckPoint.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_EXAMINE);//隐患核查阶段(数据进入到隐患核查阶段)

        hiddenDangerCheckPoint.setDangerSources(TrHiddenDangerCheckConstants.DANGER_SOURCES_PLAN_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);

            // todo-2022 此处插入附属表
            //获取Id返回值
            hiddenDangerCheckPoint.getId();
            int result = riskService.insertDangerInfo(hiddenDangerCheckPoint.getId(), hiddenDangerCheckPoint);
            if (result< 1){
                throw new RuntimeException("添加隐患附属信息失败");
            }

        } else {
            hiddenDangerCheckPoint.setUpdateBy(getSysUser().getLoginName());
            hiddenDangerCheckPoint.setUpdateTime(DateUtils.getNowDate());
            i = hiddenDangerCheckPointService.updateHiddenDangerCheckPoint(hiddenDangerCheckPoint);

            // todo-2022 此处修改附属表
            int result = riskService.updateDangerInfo(hiddenDangerCheckPoint);
            if (result < 1){
                throw new RuntimeException("修改失败");
            }
        }
        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("/removeDangerPlanExecute")
    @ResponseBody
    public AjaxResult removeDangerPlanExecute(String ids) {
        return toAjax(hiddenDangerCheckService.deleteHiddenDangerCheckByIds(ids));
    }



}