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

import com.github.pagehelper.util.StringUtil;
import com.ruoyi.common.constant.TrHiddenDangerCheckConstants;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.security.ShiroUtils;
import com.ruoyi.doublePrevention.entity.PreventRiskDangerInfo;
import com.ruoyi.doublePrevention.entity.dto.resp.PreventRiskUnitCodeAndNameListQueryRespDTO;
import com.ruoyi.doublePrevention.service.RiskService;
import com.ruoyi.doublePrevention.service.baseService.PreventRiskDangerConfirmLogService;
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.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 org.apache.commons.lang3.ObjectUtils;
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/dangerReport")
public class DangerReportController extends BaseController {
    private String prefix = "tr/hiddenDangerCheck/dangerReport";

    @Autowired
    private IHiddenDangerCheckService hiddenDangerCheckService;

    @Autowired
    private IHiddenDangerCheckPointService hiddenDangerCheckPointService;


    @Autowired
    private IHiddenTroubleTypeService hiddenTroubleTypeService;

    @Autowired
    private IUserService userService;

    @Autowired
    private RiskService riskService;

    @Autowired
    private PreventRiskDangerConfirmLogService confirmLogService;

    @GetMapping()
    public String hiddenDangerCheck(ModelMap mmap) {
        User currentUser = getSysUser();
        mmap.put("currentUser", currentUser);
        return prefix + "/dangerReport";
    }



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


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

        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<HiddenDangerCheckPoint>());
        }
        hiddenDangerCheckPoint.setJudgeQueryByUserIdList(userIdList);//隐患整改人ID 为登陆账号companyId下的userId的
        startPage();
        List<HiddenDangerCheckPoint> list = hiddenDangerCheckPointService.selectHiddenDangerCheckPointList(hiddenDangerCheckPoint);
        return getDataTable(list);
    }



    /**
     * 查询隐患上报列表
     */
    @PostMapping("/list")
    @ResponseBody
    public TableDataInfo list(HiddenDangerCheckPoint hiddenDangerCheckPoint) {
        startPage();
        //查询 （第一：隐患来源为隐患上报生成 ---danger_sources为 2(隐患主动上报生成)
        // 第二：1.隐患上报创建人（register_user_id） 或者 2.（判定人（judge_user_id），report_status 不为null ）------为本登录帐号userId的
        hiddenDangerCheckPoint.setJudgeQueryByUserId(getSysUser().getUserId());
        List<HiddenDangerCheckPoint> list = hiddenDangerCheckPointService.selectHiddenDangerCheckPointList(hiddenDangerCheckPoint);
        List<HiddenDangerCheckPoint> resultList = new ArrayList<>();

        for (HiddenDangerCheckPoint dangerCheckPoint : list) {
            PreventRiskDangerInfo dangerInfo = riskService.getDangerInfoById(dangerCheckPoint.getId());
            if (ObjectUtils.isNotEmpty(dangerInfo)){
                dangerCheckPoint.setHazardCode(dangerInfo.getHazardCode());
                dangerCheckPoint.setDangerSrc(dangerInfo.getDangerSrc());
                dangerCheckPoint.setDangerReason(dangerInfo.getDangerReason());
                dangerCheckPoint.setHazardDangerType(dangerInfo.getHazardDangerType());
                dangerCheckPoint.setDangerResult(dangerInfo.getDangerResult());
            }
            resultList.add(dangerCheckPoint);
        }
        return getDataTable(list);
    }

    /**
     * 新增隐患上报
     */
    @GetMapping("/addDangerReport")
    public String addDangerReport(ModelMap mmap) {
        //获取所在公司人员信息
        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);
        }
        mmap.put("dangerSrc", 0);

        //隐患类别
        HiddenTroubleType hiddenTroubleType = new HiddenTroubleType();
        hiddenTroubleType.setCompanyId(sysUser.getCompanyId());
        List<HiddenTroubleType> hiddenTroubleTypeList = hiddenTroubleTypeService.selectHiddenTroubleTypeList(hiddenTroubleType);
        mmap.put("hiddenTroubleTypeList", hiddenTroubleTypeList);
        List<PreventRiskUnitCodeAndNameListQueryRespDTO> respDTOS = riskService.listRiskUnitCodeAndName();
        mmap.put("riskUnits", respDTOS);
        return prefix + "/addDangerReport";
    }

    /**
     * 新增保存隐患上报
     */
    @Log(title = "隐患上报", businessType = BusinessType.INSERT)
    @PostMapping("/addDangerReportSave")
    @ResponseBody
    @Transactional
    public AjaxResult addDangerReportSave(HiddenDangerCheckPoint hdcp) {
        if (ObjectUtils.isEmpty(hdcp.getCheckPerson())){
            throw new RuntimeException("检查人不能为空");
        }
        if (ObjectUtils.isEmpty(hdcp.getFindTime())){
            throw new RuntimeException("发现时间不能为空");
        }
        if (ObjectUtils.isEmpty(hdcp.getDangerSrc())){
            throw new RuntimeException("隐患来源不能为空");
        }
        HiddenDangerCheck hiddenDangerCheck  = new HiddenDangerCheck();
        hiddenDangerCheck.setCreateBy(ShiroUtils.getLoginName());//创建者
        hiddenDangerCheck.setCreateTime(DateUtils.getNowDate());//获取创建时间
        hiddenDangerCheck.setDangerDeptId(hdcp.getDangerDeptId());
        hiddenDangerCheck.setDangerDeptName(hdcp.getDangerDeptName());
        hiddenDangerCheck.setDangerPlaceId(hdcp.getDangerPlaceId());
        hiddenDangerCheck.setDangerPlaceName(hdcp.getDangerPlaceName());
        hiddenDangerCheckService.insertHiddenDangerCheck(hiddenDangerCheck);//构造隐患排查对象保存，主要保存隐患责任部门，隐患地点

        hdcp.setCheckId(hiddenDangerCheck.getCheckId());
        hdcp.setCreateBy(ShiroUtils.getLoginName());//创建者
        hdcp.setCreateTime(DateUtils.getNowDate());//获取创建时间
        hdcp.setRegisterCreateTime(DateUtils.getNowDate());//设置隐患登记上报创建时间
        hdcp.setRegisterUserId(getSysUser().getUserId());//设置隐患登记上报创建人ID
        hdcp.setRegisterUserName(getSysUser().getUserName());//设置隐患登记上报创建人名称
        hdcp.setDangerSources(TrHiddenDangerCheckConstants.DANGER_SOURCES_REPORT_PRODUCE); //隐患来源(隐患主动上报生成)

        hdcp.setCompanyId(getSysUser().getCompanyId());
        int i = hiddenDangerCheckPointService.insertHiddenDangerCheckPoint(hdcp);
        if (i< 1){
            throw new RuntimeException("添加隐患信息失败");
        }

        // 此处插入附属表  ---  此处已弃用，在核查整改后插入20250623再次启用
        //获取Id返回值
        hdcp.getId();
        int result = riskService.insertDangerInfo(hdcp.getId(), hdcp);
        if (result< 1){
            throw new RuntimeException("添加隐患附属信息失败");
        }

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

        return toAjax(i);
    }


    /**
     * 新增隐患上报全流程
     */
    @GetMapping("/addDangerReportWholeProcess")
    public String addDangerReportWholeProcess(ModelMap mmap) {
        //获取所在公司人员信息
        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);
        }

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

        return prefix + "/addDangerReportWholeProcess";
    }

    /**
     * 新增保存隐患上报全流程
     */
    @Log(title = "隐患上报全流程", businessType = BusinessType.INSERT)
    @PostMapping("/addDangerReportWholeProcessSave")
    @ResponseBody
    @Transactional
    public AjaxResult addDangerReportWholeProcessSave(HiddenDangerCheckPoint hdcp) {
        //新增隐患上报
        HiddenDangerCheck hiddenDangerCheck  = new HiddenDangerCheck();
//        hiddenDangerCheck.setCreateBy(ShiroUtils.getLoginName());//创建者
//        hiddenDangerCheck.setCreateTime(DateUtils.getNowDate());//获取创建时间
        if (ObjectUtils.isEmpty(hdcp.getCheckPerson())){
            throw new RuntimeException("检查人不能为空");
        }
        if (ObjectUtils.isEmpty(hdcp.getFindTime())){
            throw new RuntimeException("发现时间不能为空");
        }
        if (ObjectUtils.isEmpty(hdcp.getDangerSrc())){
            throw new RuntimeException("隐患来源不能为空");
        }
        hiddenDangerCheck.setCreateBy(ShiroUtils.getLoginName());//创建者
        hiddenDangerCheck.setCreateTime(hdcp.getRectifyCreateTime());//获取创建时间

        hiddenDangerCheck.setDangerDeptId(hdcp.getDangerDeptId());
        hiddenDangerCheck.setDangerDeptName(hdcp.getDangerDeptName());
        hiddenDangerCheck.setDangerPlaceId(hdcp.getDangerPlaceId());
        hiddenDangerCheck.setDangerPlaceName(hdcp.getDangerPlaceName());
        hiddenDangerCheckService.insertHiddenDangerCheck(hiddenDangerCheck);//构造隐患排查对象保存，主要保存隐患责任部门，隐患地点

        //1.全流程隐患上报信息封装


        hdcp.setCheckId(hiddenDangerCheck.getCheckId());
        hdcp.setCreateBy(ShiroUtils.getLoginName());//创建者
//        hdcp.setCreateTime(DateUtils.getNowDate());//获取创建时间
//        hdcp.setRegisterCreateTime(DateUtils.getNowDate());//设置隐患登记上报创建时间
//        hdcp.setRegisterUserId(getSysUser().getUserId());//设置隐患登记上报创建人ID
//        hdcp.setRegisterUserName(getSysUser().getUserName());//设置隐患登记上报创建人名称


        hdcp.setCreateTime(hdcp.getRectifyCreateTime());//获取创建时间
//        hdcp.setRegisterCreateTime(DateUtils.getNowDate());//设置隐患登记上报创建时间

        hdcp.setDangerSources(TrHiddenDangerCheckConstants.DANGER_SOURCES_REPORT_PRODUCE); //隐患来源(隐患主动上报生成)


        //隐患上报提交
        hdcp.setRegisterSubmitTime(hdcp.getJudgeCreateTime());//设置隐患上报提交时间
//        hdcp.setRegisterSubmitTime(DateUtils.getNowDate());//设置隐患上报提交时间



        //隐患上报判定
//        hdcp.setJudgeCreateTime(DateUtils.getNowDate());//设置隐患上报判定时间
        if (!StringUtils.isEmpty(hdcp.getReportStatus())) {
            if (TrHiddenDangerCheckConstants.REPORT_STATUS_NOT_DANGER.equals(hdcp.getReportStatus())) {//隐患上报(不是隐患)
                hdcp.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_NOT);//是否为隐患(正常)
                hdcp.setExamineUserId(null);
                hdcp.setExamineUserName(null);
            } else if (TrHiddenDangerCheckConstants.REPORT_STATUS_YES_DANGER.equals(hdcp.getReportStatus())) {//隐患上报(是隐患)
                hdcp.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_YES);//是否为隐患(隐患)
                hdcp.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_EXAMINE);//隐患核查阶段(数据进入到隐患核查阶段)
                hdcp.setExamineStatus(TrHiddenDangerCheckConstants.EXAMINE_STATUS_NOT_EXAMINE);//核查状态(待核查)
            }
        }

        //隐患核查

//        hdcp.setExamineCreateTime(DateUtils.getNowDate());//设置核查时间
        hdcp.setExamineStatus(TrHiddenDangerCheckConstants.EXAMINE_STATUS_ALREADY_EXAMINE);//核查状态(已核查)
        if(!StringUtil.isEmpty(hdcp.getDangerLevel())){
            if(("0".equals(hdcp.getDangerLevel()))
                    ||("1".equals(hdcp.getDangerLevel()))){//0 一般隐患 1 重大隐患
                hdcp.setRectifyStatus(TrHiddenDangerCheckConstants.RECTIFY_STATUS_NOT_RECTIFY);//整改状态(未整改)
                hdcp.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_RECTIFY);//隐患整改阶段(数据进入到隐患整改阶段)
            }else if(("2".equals(hdcp.getDangerLevel()))){ //2 不是隐患
                hdcp.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_NOT);//是否为隐患(正常)
            }
        }


        //隐患整改
//        hdcp.setRectifyCreateTime(DateUtils.getNowDate());//设置整改时间
        hdcp.setRectifyStatus(TrHiddenDangerCheckConstants.RECTIFY_STATUS_ALREADY_RECTIFY);//整改状态(已整改)
        hdcp.setAcceptStatus(TrHiddenDangerCheckConstants.ACCEPT_STATUS_NOT_ACCEPT);//验收状态(未验收)
        hdcp.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_ACCEPT);//隐患验收阶段(数据进入到隐患验收阶段)


        //4.全流程隐患整改信息封装-未操作

        //隐患验收
        if (!StringUtils.isEmpty(hdcp.getAcceptResult())) {
            //验收结果 (0不通过 打回上一级整改阶段  1通过)
            if ("0".equals(hdcp.getAcceptResult())) {
//                hdcp.setAcceptCreateTime(DateUtils.getNowDate());//设置验收时间
                hdcp.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_RECTIFY);//隐患整改阶段(数据进入到隐患整改阶段)
                hdcp.setRectifyStatus(TrHiddenDangerCheckConstants.RECTIFY_STATUS_NOT_RECTIFY);//整改状态(未整改)
                hdcp.setAcceptStatus(TrHiddenDangerCheckConstants.ACCEPT_STATUS_ALREADY_ACCEPT_NOT_PASS);//验收状态(验收未通过)
            } else if ("1".equals(hdcp.getAcceptResult())) {
//              hdcp.setAcceptCreateTime(DateUtils.getNowDate());//设置验收时间
                hdcp.setAcceptStatus(TrHiddenDangerCheckConstants.ACCEPT_STATUS_ALREADY_ACCEPT_PASS);//验收状态(验收通过)

                //5.全流程隐患验收信息封装-未操作

            }
        }
        hdcp.setCompanyId(getSysUser().getCompanyId());

        hdcp.setUpdateBy(ShiroUtils.getLoginName());
        hdcp.setUpdateTime(hdcp.getAcceptCreateTime());

        int i = hiddenDangerCheckPointService.insertHiddenDangerCheckPoint(hdcp);

        // todo-2022 全流程隐患附属信息插入
        //获取返回值id
        hdcp.getId();
        int result = riskService.insertDangerInfo(hdcp.getId(), hdcp);
        if (result < 1){
            throw new RuntimeException("全流程隐患信息保存失败");
        }

        return toAjax(i);
    }




    /**
     * 修改隐患上报
     */
    @GetMapping("/editDangerReport/{id}")
    public String editDangerReport(@PathVariable("id") Long id, ModelMap mmap) {
        HiddenDangerCheckPoint hdcp = hiddenDangerCheckPointService.selectHiddenDangerCheckPointById(id);
        // todo-2022 修改前查询
        PreventRiskDangerInfo dangerInfo = riskService.getDangerInfoById(hdcp.getId());

        if (ObjectUtils.isNotEmpty(dangerInfo)){
            hdcp.setHazardCode(dangerInfo.getHazardCode());
            hdcp.setDangerSrc(dangerInfo.getDangerSrc());
            hdcp.setDangerReason(dangerInfo.getDangerReason());
            hdcp.setHazardDangerType(dangerInfo.getHazardDangerType());
            hdcp.setDangerResult(dangerInfo.getDangerResult());
        }

        mmap.put("hiddenDangerCheckPoint", hdcp);

        //获取所在公司人员信息
        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 + "/editDangerReport";
    }

    /**
     * 修改保存隐患上报
     */
    @Log(title = "隐患上报", businessType = BusinessType.UPDATE)
    @PostMapping("/editDangerReportSave")
    @ResponseBody
    @Transactional
    public AjaxResult editDangerReportSave(HiddenDangerCheckPoint hiddenDangerCheckPoint) {
        HiddenDangerCheckPoint hdcp = hiddenDangerCheckPointService.selectHiddenDangerCheckPointById(hiddenDangerCheckPoint.getId());
        if(hdcp!=null&&hdcp.getCheckId()!=null){
            HiddenDangerCheck hiddenDangerCheck = hiddenDangerCheckService.selectHiddenDangerCheckById(hdcp.getCheckId());
            hiddenDangerCheck.setUpdateBy(ShiroUtils.getLoginName());//更新者
            hiddenDangerCheck.setUpdateTime(DateUtils.getNowDate());//设置更新时间
            hiddenDangerCheck.setDangerDeptId(hiddenDangerCheckPoint.getDangerDeptId());
            hiddenDangerCheck.setDangerDeptName(hiddenDangerCheckPoint.getDangerDeptName());
            hiddenDangerCheck.setDangerPlaceId(hiddenDangerCheckPoint.getDangerPlaceId());
            hiddenDangerCheck.setDangerPlaceName(hiddenDangerCheckPoint.getDangerPlaceName());
            hiddenDangerCheckService.updateHiddenDangerCheck(hiddenDangerCheck);

            hiddenDangerCheckPoint.setUpdateBy(ShiroUtils.getLoginName());//更新者
            hiddenDangerCheckPoint.setUpdateTime(DateUtils.getNowDate());//设置更新时间
            hiddenDangerCheckPointService.updateHiddenDangerCheckPoint(hiddenDangerCheckPoint);

            // todo-2022 此处修改附属表 20250623再次启用
            int result = riskService.updateDangerInfo(hiddenDangerCheckPoint);
            if (result < 1){
                throw new RuntimeException("修改失败");
            }

            hiddenDangerCheckPointService.getTaskCountTotal(getSysUser().getUserId());//查询未执行任务总数量并推送
            return AjaxResult.success();
        }else{
            return AjaxResult.error("数据有误！");
        }

    }


    /**
     * 判定隐患上报
     */
    @GetMapping("/editJudgeDangerReport/{id}")
    public String editJudgeDangerReport(@PathVariable("id") Long id, ModelMap mmap) {
        HiddenDangerCheckPoint hdcp = hiddenDangerCheckPointService.selectHiddenDangerCheckPointById(id);
        mmap.put("hiddenDangerCheckPoint", hdcp);

        //获取所在公司人员信息
        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);
        }

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


        return prefix + "/editJudgeDangerReport";
    }


    /**
     * 修改判定隐患上报保存
     */
    @Log(title = "修改判定隐患上报保存", businessType = BusinessType.UPDATE)
    @PostMapping("/editJudgeDangerReportSave")
    @ResponseBody
    @Transactional
    public AjaxResult editJudgeDangerReportSave(HiddenDangerCheckPoint hiddenDangerCheckPoint) {
        hiddenDangerCheckPoint.setJudgeCreateTime(DateUtils.getNowDate());//设置隐患上报判定时间
        if (!StringUtils.isEmpty(hiddenDangerCheckPoint.getReportStatus())) {
            if (TrHiddenDangerCheckConstants.REPORT_STATUS_NOT_DANGER.equals(hiddenDangerCheckPoint.getReportStatus())) {//隐患上报(不是隐患)
                hiddenDangerCheckPoint.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_NOT);//是否为隐患(正常)
                hiddenDangerCheckPoint.setExamineUserId(null);
                hiddenDangerCheckPoint.setExamineUserName(null);
            } else if (TrHiddenDangerCheckConstants.REPORT_STATUS_YES_DANGER.equals(hiddenDangerCheckPoint.getReportStatus())) {//隐患上报(是隐患)
                hiddenDangerCheckPoint.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_YES);//是否为隐患(隐患)
                hiddenDangerCheckPoint.setDangerLevel("0");//默认设置为一般隐患
                hiddenDangerCheckPoint.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_EXAMINE);//隐患核查阶段(数据进入到隐患核查阶段)
                hiddenDangerCheckPoint.setExamineStatus(TrHiddenDangerCheckConstants.EXAMINE_STATUS_NOT_EXAMINE);//核查状态(待核查)

//                //
//                int result = riskService.updateDangerInfoJudge(hiddenDangerCheckPoint);
//                if (result < 1){
//                    throw new RuntimeException("整改信息保存失败");
//                }

            }
        }
        int i = hiddenDangerCheckPointService.updateHiddenDangerCheckPoint(hiddenDangerCheckPoint);

        int result = confirmLogService.saveConfirmLog(hiddenDangerCheckPoint);
        if (result < 1){
            return AjaxResult.error("操作失败");
        }

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

        return toAjax(i);
    }


    /**
     * 删除隐患上报
     */
    @Log(title = "隐患上报", businessType = BusinessType.DELETE)
    @PostMapping("/removeDangerReport")
    @ResponseBody
    @Transactional
    public AjaxResult removeDangerReport(String ids) {
        if(StringUtils.isEmpty(ids)){
            return AjaxResult.error("id不能为空");
        }
        HiddenDangerCheckPoint hdcp  = hiddenDangerCheckPointService.selectHiddenDangerCheckPointById(Long.valueOf(ids));
        if(hdcp.getCheckId()!=null){
            hiddenDangerCheckPointService.deleteHiddenDangerCheckPointById(hdcp.getId());
            hiddenDangerCheckService.deleteHiddenDangerCheckById(hdcp.getCheckId());

            // todo-2022 此处删除附属表
//            int result = riskService.deleteDangerInfo(hdcp.getId());
//            if (result < 1){
//                throw  new RuntimeException("删除失败");
//            }

            hiddenDangerCheckPointService.getTaskCountTotal(getSysUser().getUserId());//查询未执行任务总数量并推送
            return AjaxResult.success();
        }
        return AjaxResult.error("数据有误");
    }


    /**
     * 隐患上报--提交
     * 隐患信息提交，此处不改。思路：使用stage 进行阶段判断。只有认定后的隐患，才需要上报。
     */
    @Log(title = "隐患上报--提交")
    @PostMapping("/submitDangerReport")
    @ResponseBody
    public AjaxResult submitDangerReport(String id) {
        HiddenDangerCheckPoint hiddenDangerCheckPoint = hiddenDangerCheckPointService.selectHiddenDangerCheckPointById(Long.valueOf(id));
        hiddenDangerCheckPoint.setReportStatus(TrHiddenDangerCheckConstants.REPORT_STATUS_NOT_JUDGE);//隐患上报(未判定)
        hiddenDangerCheckPoint.setRegisterSubmitTime(DateUtils.getNowDate());//设置隐患上报提交时间
        int i = hiddenDangerCheckPointService.updateHiddenDangerCheckPoint(hiddenDangerCheckPoint);
        hiddenDangerCheckPointService.getTaskCountTotal(getSysUser().getUserId());//查询未执行任务总数量并推送
        return toAjax(i);
    }


    /**
     * 未判定--查看
     */
    @Log(title = "未判定--查看")
    @GetMapping("/detailNotJudge/{id}")
    public String detailNotJudge(@PathVariable("id") Long id, ModelMap mmap) {
        //隐患排查检查点信息实体
        HiddenDangerCheckPoint hiddenDangerCheckPoint = hiddenDangerCheckPointService.selectHiddenDangerCheckPointById(Long.valueOf(id));
        PreventRiskDangerInfo dangerInfo = riskService.getDangerInfoById(hiddenDangerCheckPoint.getId());
        if (ObjectUtils.isNotEmpty(dangerInfo)){
            hiddenDangerCheckPoint.setHazardCode(dangerInfo.getHazardCode());
            hiddenDangerCheckPoint.setDangerSrc(dangerInfo.getDangerSrc());
            hiddenDangerCheckPoint.setDangerReason(dangerInfo.getDangerReason());
            hiddenDangerCheckPoint.setHazardDangerType(dangerInfo.getHazardDangerType());
            hiddenDangerCheckPoint.setDangerResult(dangerInfo.getDangerResult());
        }
        mmap.put("hiddenDangerCheckPoint", hiddenDangerCheckPoint);
        return prefix + "/detailNotJudge";
    }


    /**
     * 不是隐患--查看
     */
    @Log(title = "不是隐患--查看")
    @GetMapping("/detailNotDanger/{id}")
    public String detailNotDanger(@PathVariable("id") Long id, ModelMap mmap) {
        //隐患排查检查点信息实体
        HiddenDangerCheckPoint hiddenDangerCheckPoint = hiddenDangerCheckPointService.selectHiddenDangerCheckPointById(Long.valueOf(id));
        PreventRiskDangerInfo dangerInfo = riskService.getDangerInfoById(hiddenDangerCheckPoint.getId());
        if (ObjectUtils.isNotEmpty(dangerInfo)){
            hiddenDangerCheckPoint.setHazardCode(dangerInfo.getHazardCode());
            hiddenDangerCheckPoint.setDangerSrc(dangerInfo.getDangerSrc());
            hiddenDangerCheckPoint.setDangerReason(dangerInfo.getDangerReason());
            hiddenDangerCheckPoint.setHazardDangerType(dangerInfo.getHazardDangerType());
            hiddenDangerCheckPoint.setDangerResult(dangerInfo.getDangerResult());
        }
        mmap.put("hiddenDangerCheckPoint", hiddenDangerCheckPoint);
        return prefix + "/detailNotDanger";
    }

    /**
     * 是隐患--查看
     */
    @Log(title = "是隐患--查看")
    @GetMapping("/detailYesDanger/{id}")
    public String detailYesDanger(@PathVariable("id") Long id, ModelMap mmap) {
        //隐患排查检查点信息实体
        HiddenDangerCheckPoint hiddenDangerCheckPoint = hiddenDangerCheckPointService.selectHiddenDangerCheckPointById(Long.valueOf(id));
        PreventRiskDangerInfo dangerInfo = riskService.getDangerInfoById(hiddenDangerCheckPoint.getId());
        if (ObjectUtils.isNotEmpty(dangerInfo)){
            hiddenDangerCheckPoint.setHazardCode(dangerInfo.getHazardCode());
            hiddenDangerCheckPoint.setDangerSrc(dangerInfo.getDangerSrc());
            hiddenDangerCheckPoint.setDangerReason(dangerInfo.getDangerReason());
            hiddenDangerCheckPoint.setHazardDangerType(dangerInfo.getHazardDangerType());
            hiddenDangerCheckPoint.setDangerResult(dangerInfo.getDangerResult());
        }
        mmap.put("hiddenDangerCheckPoint", hiddenDangerCheckPoint);
        return prefix + "/detailYesDanger";
    }
}