using APT.BaseData.Domain.ApiModel;
using APT.BaseData.Domain.Entities;
using APT.BaseData.Domain.Entities.FM;
using APT.BaseData.Domain.Enums;
using APT.BaseData.Domain.Enums.PF;
using APT.BaseData.Domain.IServices;
using APT.BaseData.Domain.IServices.BS;
using APT.BaseData.Domain.IServices.FM;
using APT.BaseData.Services.Services.FM;
using APT.Infrastructure.Api;
using APT.Infrastructure.Core;
using APT.MS.Domain.Entities.BS;
using APT.MS.Domain.Entities.FO;
using APT.MS.Domain.Entities.HM;
using APT.MS.Domain.Entities.PF;
using APT.MS.Domain.Entities.SC.SC;
using APT.MS.Domain.Enums;
using InfluxData.Net.InfluxDb.Models.Responses;
using MySqlX.XDevAPI.Common;
using NPOI.SS.Formula.Functions;
using Org.BouncyCastle.Utilities;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography;
namespace APT.BaseData.Services.DomainServices
{
    /// 
    /// 审批流回调 
    /// 代码规范 每个模块的代码 写在对应 代码块中 
    /// 多添加一个审批流回调 1、写方法 2、完善 CallBack 方法
    /// 原有的api继续提供 审批调用
    /// 
    public class PFApproveCallBackService : CommonService, IPFApproveCallBackService
    {
        IPFCodeRuleService CodeRuleService { get; set; }
        IFMNotificationTaskService NotificationTaskService { get; set; }
        IPFSysLogService SysLogService { get; set; }
        IPFApproveCallBackMTService PFApproveCallBackMTService { get; set; }
        IPFApproveCallBackSEService PFApproveCallBackSEService { get; set; }
        IFMDepartmentService DepartmentService { get; set; }
        IBSSafeCheckService SafeCheckService { get; set; }
        public PFApproveCallBackService(IRepository repository, IPFCodeRuleService codeRuleService, IFMNotificationTaskService notificationTaskService, IPFSysLogService sysLogService, IPFApproveCallBackMTService pFApproveCallBackMTService, IPFApproveCallBackSEService pFApproveCallBackSEService, IFMDepartmentService departmentService, IBSSafeCheckService safeCheckService)
            : base(repository)
        {
            CodeRuleService = codeRuleService;
            NotificationTaskService = notificationTaskService;
            SysLogService = sysLogService;
            PFApproveCallBackMTService = pFApproveCallBackMTService;
            PFApproveCallBackSEService = pFApproveCallBackSEService;
            DepartmentService = departmentService;
            SafeCheckService = safeCheckService;
        }
        public string RejectContent(Guid id)
        {
            var result = string.Empty;
            var orgId = APT.Infrastructure.Api.AppContext.CurrentSession.OrgId;
            var newFilter = new BaseFilter(orgId);
            newFilter.SelectField = new List { "Nav_ApproveDetails" };
            var approveInfo = this.GetEntities(t => t.DATA_ID == id, newFilter).OrderByDescending(m => m.CREATE_TIME).FirstOrDefault();
            if (approveInfo != null && approveInfo.Nav_ApproveDetails.Any())
            {
                var detail = approveInfo.Nav_ApproveDetails.FirstOrDefault(t => t.NODE_APPROVE_STATUS == 20);
                if (detail != null)
                {
                    var userInfo = this.GetEntity(t => t.ID == detail.APPROVE_USER_ID && t.ENABLE_STATUS == 0);
                    result = userInfo?.NAME + "驳回,内容:" + detail.CONTEXT;
                }
            }
            return result;
        }
        /// 
        /// 添加审批流
        /// 
        /// 
        /// 
        /// 
        public bool CallBack(string CALLBACK_INTERFACE, string DATA_ID)
        {
            bool result = false;
            if (!string.IsNullOrEmpty(CALLBACK_INTERFACE))
            {
                switch (CALLBACK_INTERFACE)
                {
                    case "HM/HMEvaluationPlan/PersonalApprove":
                        result = PersonalApprove(DATA_ID);
                        break;
                    case "HM/HMRiskTask/PersonalApprove":
                        result = PersonalApprove_HMRiskTask(DATA_ID);
                        break;
                    case "HM/HMRiskRecord/PersonalApprove":
                        result = PersonalApprove_HMRiskRecord(DATA_ID);
                        break;
                    case "HM/HMHazardTask/PersonalApprove":
                        result = PersonalApprove_HMHazardTask(DATA_ID);
                        break;
                    case "HM/HMHazardRecord/PersonalApprove":
                        result = PersonalApprove_HMHazardRecord(DATA_ID);
                        break;
                    case "HM/HMEvaluateResult/PersonalApprove1":
                        result = PersonalApprove1(DATA_ID);
                        break;
                    case "HM/HMEvaluateResult/PersonalApprove2":
                        result = PersonalApprove2(DATA_ID);
                        break;
                    case "BS/BSRiskSubmit/DealEnd":
                        result = DealEnd(DATA_ID);
                        break;
                    case "BS/BSRiskSubmit/Notice":
                        result = Notice(DATA_ID);
                        break;
                    case "BS/BSRiskSubmitContentTemp/ApproveBackBS048":
                        result = ApproveBackBS048(DATA_ID);
                        break;
                    case "BS/BSRiskSubmitDelayApply/DealEnd":
                        result = DealEnd_BS_DelayApply(DATA_ID);
                        break;
                    case "BS/BSSafeCheck/CheckAuditEnd":
                        result = CheckAuditEnd(DATA_ID);
                        break;
                    case "BS/BSSafeCheck/CheckPlanAuditEnd":
                        result = CheckPlanAuditEnd(DATA_ID);
                        break;
                    case "FO/FOCrucialLicenseJob/BackUpdate":
                        result = BackUpdate(DATA_ID);
                        break;
                    case "FO/FOCrucialLicenseJobOutsource/BackUpdate":
                        result = BackUpdate_FOCrucialLicenseJobOutsource(DATA_ID);
                        break;
                    case "HM/HMCrucialTaskAnalysis/BackUpdate":
                        result = BackUpdate_HMCrucialTaskAnalysis(DATA_ID);
                        break;
                    case "HM/HMJobtaskIdentify/BackUpdate":
                        result = BackUpdate_HMJobtaskIdentify(DATA_ID);
                        break;
                    case "HM/HMLicenseAnalysis/BackUpdate":
                        result = BackUpdate_HMLicenseAnalysis(DATA_ID);
                        break;
                    case "HM/HMOperationTaskDistinguishAnalyze/BackUpdate":
                        result = BackUpdate_HMOperationTaskDistinguishAnalyze(DATA_ID);
                        break;
                    case "HM/HMOrdinaryTaskAnalysis/BackUpdate":
                        result = BackUpdate_HMOrdinaryTaskAnalysis(DATA_ID);
                        break;
                    case "SC/SCMTMeeting/MeetingNoticeBack"://会议通知回调
                        result = PFApproveCallBackMTService.MeetingNoticeBack(DATA_ID);
                        break;
                    case "SC/SCMtMeetingMinutes/MeetingMinutesBack"://会议纪要回调
                        result = PFApproveCallBackMTService.MeetingMinutesBack(DATA_ID);
                        break;
                    case "SE/SEDepTrainPlan/departmentTrainPlanAgree"://安全教育模块部门培训计划通过
                        result = PFApproveCallBackSEService.departmentTrainPlanAgree(DATA_ID);
                        break;
                    case "SE/SEYearTrainPlan/yearTrainPlanAgree"://安全教育模块年度培训计划通过
                        result = PFApproveCallBackSEService.yearTrainPlanAgree(DATA_ID);
                        break;
                    case "FO/FOJobEventRecord/BackUpdate"://绩效测量与评估
                        result = BackUpdate_FOJobEventRecord(DATA_ID);
                        break;
                  
                    #region    职业卫生
                    //case "OH/OHHealthExamPlan/PlanMasterBack"://绩效测量与评估
                    //    result = PFApproveCallBackMTService.PlanMasterBack(DATA_ID);
                    //    break;
                    #endregion
                    #region    应急管理
                    case "CM/CMRspEstimate/EstimateBack"://绩效测量与评估
                        result = PFApproveCallBackMTService.EstimateBack(DATA_ID);
                        break;
                    case "CM/CMDrillPlan/DrillPlanEnd"://绩效测量与评估
                        result = PFApproveCallBackMTService.DrillPlanEnd(DATA_ID);
                        break;
                    case "CM/CMDrillPlan/DrillRecordEnd"://应急演练活动记录表							
                        result = PFApproveCallBackMTService.DrillRecordEnd(DATA_ID);
                        break;
                    #endregion
                    default:
                        SysLogService.AddLog(APT.Infrastructure.Api.AppContext.CurrentSession.OrgId.Value, APT.Infrastructure.Api.AppContext.CurrentSession.UserID.Value, PFSysLogTypeEnum.CommonApproveCallBack, "PF119", "审批流回调方法未完善", "PFApproveCallBackService=>CallBack: " + CALLBACK_INTERFACE, DATA_ID);
                        break;
                }
            }
            return result;
        }
        /// 
        /// 添加审批流 (默认审批直接回调这个方法)
        /// 
        /// 
        /// 
        /// 
        public bool CallBack(string CALLBACK_INTERFACE, List listDATA_ID)
        {
            bool result = false;
            if (!string.IsNullOrEmpty(CALLBACK_INTERFACE))
            {
                switch (CALLBACK_INTERFACE)
                {
                    case "BS/BSRiskSubmit/DealEnd":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            DealEnd(listDATA_ID[i]);
                        }
                        break;
                    case "BS/BSRiskSubmit/Notice":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            Notice(listDATA_ID[i]);
                        }
                        break;
                    case "BS/BSRiskSubmitContentTemp/ApproveBackBS048":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            ApproveBackBS048(listDATA_ID[i]);
                        }
                        break;
                    case "BS/BSRiskSubmitDelayApply/DealEnd":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            DealEnd_BS_DelayApply(listDATA_ID[i]);
                        }
                        break;
                    case "BS/BSSafeCheck/CheckAuditEnd":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            CheckAuditEnd(listDATA_ID[i]);
                        }
                        break;
                    case "BS/BSSafeCheck/CheckPlanAuditEnd":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            CheckPlanAuditEnd(listDATA_ID[i]);
                        }
                        break;
                    case "FO/FOCrucialLicenseJob/BackUpdate":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            BackUpdate(listDATA_ID[i]);
                        }
                        break;
                    case "FO/FOCrucialLicenseJobOutsource/BackUpdate":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            BackUpdate_FOCrucialLicenseJobOutsource(listDATA_ID[i]);
                        }
                        break;
                    case "HM/HMCrucialTaskAnalysis/BackUpdate":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            BackUpdate_HMCrucialTaskAnalysis(listDATA_ID[i]);
                        }
                        break;
                    case "HM/HMEvaluateResult/PersonalApprove1":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            PersonalApprove1(listDATA_ID[i]);
                        }
                        break;
                    case "HM/HMEvaluateResult/PersonalApprove2":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            PersonalApprove2(listDATA_ID[i]);
                        }
                        break;
                    case "HM/HMEvaluationPlan/PersonalApprove":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            PersonalApprove(listDATA_ID[i]);
                        }
                        break;
                    case "HM/HMHazardRecord/PersonalApprove":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            PersonalApprove_HMHazardRecord(listDATA_ID[i]);
                        }
                        break;
                    case "HM/HMHazardTask/PersonalApprove":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            PersonalApprove_HMHazardTask(listDATA_ID[i]);
                        }
                        break;
                    case "HM/HMJobtaskIdentify/BackUpdate":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            BackUpdate_HMJobtaskIdentify(listDATA_ID[i]);
                        }
                        break;
                    case "HM/HMLicenseAnalysis/BackUpdate":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            BackUpdate_HMLicenseAnalysis(listDATA_ID[i]);
                        }
                        break;
                    case "HM/HMOperationTaskDistinguishAnalyze/BackUpdate":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            BackUpdate_HMOperationTaskDistinguishAnalyze(listDATA_ID[i]);
                        }
                        break;
                    case "HM/HMOrdinaryTaskAnalysis/BackUpdate":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            BackUpdate_HMOrdinaryTaskAnalysis(listDATA_ID[i]);
                        }
                        break;
                    case "HM/HMRiskRecord/PersonalApprove":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            PersonalApprove_HMRiskRecord(listDATA_ID[i]);
                        }
                        break;
                    case "HM/HMRiskTask/PersonalApprove":
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            PersonalApprove_HMRiskTask(listDATA_ID[i]);
                        }
                        break;
                    case "SC/SCMTMeeting/MeetingNoticeBack"://会议通知回调
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            PFApproveCallBackMTService.MeetingNoticeBack(listDATA_ID[i]);
                        }
                        break;
                    case "SC/SCMtMeetingMinutes/MeetingMinutesBack"://会议纪要回调
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            PFApproveCallBackMTService.MeetingMinutesBack(listDATA_ID[i]);
                        }
                        break;
                    //case "TI/TISafePdtCostRecord/RecordBack"://安全生产费用使用记录回调
                    //    for (int i = 0; i < listDATA_ID.Count; i++)
                    //    {
                    //        PFApproveCallBackMTService.RecordBack(listDATA_ID[i]);
                    //    }
                    //    break;
                    //case "AE/AEAccidentEventReport/EventBack"://安全生产费用使用记录回调
                    //    for (int i = 0; i < listDATA_ID.Count; i++)
                    //    {
                    //        PFApproveCallBackMTService.EventBack(listDATA_ID[i]);
                    //    }
                    //    break;
                    //case "AE/AEInvestigationRecord/LeaderCheck"://勘察记录组长审批完成后回调
                    //    for (int i = 0; i < listDATA_ID.Count; i++)
                    //    {
                    //        PFApproveCallBackMTService.LeaderCheck(listDATA_ID[i]);
                    //    }
                    //    break;
                    //case "AE/AEAccidentEventSurveyResult/EventResultBack"://事故事件调查结果审批回调回调
                    //    for (int i = 0; i < listDATA_ID.Count; i++)
                    //    {
                    //        PFApproveCallBackMTService.EventResultBack(listDATA_ID[i]);
                    //    }
                    //    break;
                    
                   
                    case "SC/SCStandardCreate/BackUpdate"://绩效测量与评估
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            BackUpdate_SCStandardCreate(listDATA_ID[i]);
                        }
                        break;
                   
                    case "FO/FOJobEventRecord/BackUpdate"://绩效测量与评估
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            BackUpdate_FOJobEventRecord(listDATA_ID[i]);
                        }
                        break;
                    #region    职业卫生
                    //case "OH/OHHealthExamPlan/PlanMasterBack"://职业卫生 体检计划 人事部经理审批
                    //    for (int i = 0; i < listDATA_ID.Count; i++)
                    //    {
                    //        PFApproveCallBackMTService.PlanMasterBack(listDATA_ID[i]);
                    //    }
                    //    break;
                    #endregion
                    #region    应急管理
                    case "CM/CMRspEstimate/EstimateBack"://绩效测量与评估
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            PFApproveCallBackMTService.EstimateBack(listDATA_ID[i]);
                        }
                        break;
                    case "CM/CMDrillPlan/DrillPlanEnd"://年度应急演练计划表  审批结束
                        for (int i = 0; i < listDATA_ID.Count; i++)
                        {
                            PFApproveCallBackMTService.DrillPlanEnd(listDATA_ID[i]);
                        }
                        break;
                    #endregion
                    default:
                        SysLogService.AddLog(APT.Infrastructure.Api.AppContext.CurrentSession.OrgId.Value, APT.Infrastructure.Api.AppContext.CurrentSession.UserID.Value, PFSysLogTypeEnum.CommonApproveCallBack, "PF119", "审批流回调方法未完善", "PFApproveCallBackService=> list CallBack: " + CALLBACK_INTERFACE, String.Join(',', listDATA_ID));
                        break;
                }
                //判断执行回调方法
            }
            return result;
        }
        #region  BS
        /// 
        /// 隐患上报 审核通过 给每个通知负责人发送通知
        /// 
        /// 
        /// 
        private bool Notice(string id)
        {
            //给对应通知责任人发送待办
            T_BS_RISK_SUBMIT_NOTICE entity = this.GetEntity(id, new string[] { "Nav_ListRiskSubmitContent.Nav_SafeCheckDetail", "Nav_ListRiskSubmitContent.Nav_User" });
            List listMainConbinAdd = new List();
            List listMainConbinQuestionAdd = new List();
            List listMainConbinDepAdd = new List();
            //更新对应的检查问题
            List listSafecheckDetail = new List();
            T_BS_SAFE_CHECK safeCheck = null;
            T_FM_DEPARTMENT depMainCheck = null;
            List listDepMainCheck = new List();
            int delayDays = 0;
            var delays = GetEntity(e => e.QUESTION_LEVEL == entity.QUESTION_LEVEL);
            if (delays != null)
            {
                delayDays = delays.MAX_DELAY_DAYS;
            }
            else
            {
                switch (entity.QUESTION_LEVEL)
                {
                    case (int)BSQuestionLevelEnum.重大:
                        delayDays = (int)BSDelayDaysEnum.重大;
                        break;
                    case (int)BSQuestionLevelEnum.A:
                        delayDays = (int)BSDelayDaysEnum.A;
                        break;
                    case (int)BSQuestionLevelEnum.B:
                        delayDays = (int)BSDelayDaysEnum.B;
                        break;
                    case (int)BSQuestionLevelEnum.C:
                        delayDays = (int)BSDelayDaysEnum.C;
                        break;
                    case (int)BSQuestionLevelEnum.D:
                        delayDays = (int)BSDelayDaysEnum.D;
                        break;
                    default:
                        break;
                }
            }
            List listContent = entity.Nav_ListRiskSubmitContent;
            //var sysFilter = new SystemCodeFilter();
            //sysFilter.CodeType = (int)PFCodeRuleType.消息通知;
            //sysFilter.Count = listContent.Count;
            //sysFilter.OrgId = entity.ORG_ID;
            //var codes = CodeRuleService.NewGenSerial(sysFilter);
            //var codeList = codes.Split(new char[] { ',' });
            string[] codeList = new string[listContent.Count];
            string codeTemp = "YHTZ" + DateTime.Now.ToString("yyyyMMddHHmmss");
            for (int j = 0; j < listContent.Count; j++)
            {
                codeList[j] = codeTemp + j;
            }
            //T_BS_RISK_SUBMIT entityMain = this.GetEntity(entity.RISK_SUBMIT_ID.Value);
            T_BS_RISK_SUBMIT entityMain = null;
            var listContentID = listContent.Select(e => e.ID);
            var listConts = GetEntities(e => e.RISK_SUBMIT_ID == entity.RISK_SUBMIT_ID.Value && !listContentID.Contains(e.ID) && !e.USER_ID.HasValue && e.NOTICEDATE.HasValue);//除了这单 别的都有分配通知责任人通知时间
            if (listConts == null || !listConts.Any())
            {
                entityMain = GetEntity(entity.RISK_SUBMIT_ID.Value);
                entityMain.SUBMITFINISHTIME = DateTime.Now;
                if (!entityMain.STARTTIME.HasValue)
                {
                    entityMain.STARTTIME = entityMain.CREATE_TIME;
                }
                if (entityMain.STARTTIME.HasValue || entityMain.STARTTIME.Value.AddDays(1) > entityMain.SUBMITFINISHTIME)
                    entityMain.ISSUBMITFINISHINTTIME = true;
                else
                    entityMain.ISSUBMITFINISHINTTIME = false;
            }
            List listNotice = new List();
            List listNoticePerson = new List();
            T_BS_RISK_SUBMIT_NOTICE_PERSON temp = null;
            List listDataID = new List();
            List listUserID = new List();
            List listUserName = new List();
            List listName = new List();
            int i = 0;
            foreach (var item in listContent)
            {
                i++;
                item.CODE = entity.CODE + "_" + i.ToString();
                item.NAME = "隐患整改通知:" + entity.NAME;
                item.LastDateSystem = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd 23:59:59")).AddDays(delayDays);
                item.NOTICEDATE = DateTime.Now;
                item.RiskContentState = (int)RiskContentState.Notice;
                //隐患上报 问题 通知责任人 相同 同一个通知 (后续分配整改信息) 
                temp = listNoticePerson.FirstOrDefault(x => x.USER_ID == item.USER_ID);
                if (temp == null)
                {
                    temp = new T_BS_RISK_SUBMIT_NOTICE_PERSON();
                    temp.ID = Guid.NewGuid();
                    temp.USER_ID = item.USER_ID.Value;
                    temp.ORG_ID = item.ORG_ID;
                    temp.NAME = item.NAME;
                    temp.CODE = item.CODE;
                    temp.RISK_SUBMIT_ID = item.RISK_SUBMIT_ID;
                    temp.RISK_SUBMIT_NOTICE_ID = item.RISK_SUBMIT_NOTICE_ID;
                    temp.QUESTION_LEVEL = item.QUESTION_LEVEL;
                    listNoticePerson.Add(temp);
                    listDataID.Add(temp.ID);
                    listUserID.Add(temp.USER_ID);
                    listUserName.Add(item.Nav_User.NAME);
                    listName.Add(temp.NAME);
                }
                item.RISK_SUBMIT_NOTICE_PERSON_ID = temp.ID;//个人通知ID绑定明细
                if (item.Nav_SafeCheckDetail != null)
                {
                    if (item.Nav_SafeCheckDetail.CHECKRESULT.HasValue && item.Nav_SafeCheckDetail.CHECKRESULT == 30)
                    {
                        //添加安全检查库信息
                        #region MyRegion
                        if (safeCheck == null)
                        {
                            safeCheck = GetEntity(item.Nav_SafeCheckDetail.SAFE_CHECK_ID);
                        }
                        T_BS_CHECK_QUESTION ques = new T_BS_CHECK_QUESTION();
                        ques.ID = Guid.NewGuid();
                        ques.ORG_ID = item.ORG_ID;
                        ques.DESCREPTION = item.DESCREPTION;
                        ques.DEMAND = item.DEMAND;
                        ques.IS_DELETED = false;
                        ques.ENABLE_STATUS = 0;
                        ques.CHECK_CONTENTS_ID = item.CHECK_CONTENTS_ID;
                        ques.QUESTION_LEVEL = (BSQuestionLevelEnum)(item.Nav_SafeCheckDetail.QUESTION_LEVEL.HasValue ? item.Nav_SafeCheckDetail.QUESTION_LEVEL.Value : 20);
                        listMainConbinQuestionAdd.Add(ques);
                        //添加隐患库
                        //检查问题 手动输入 没有 整改建议与措施 不能入库
                        T_BS_CHECK_MAIN modelAdd = new T_BS_CHECK_MAIN();
                        modelAdd.ID = Guid.NewGuid();
                        modelAdd.ISRISK = true;
                        modelAdd.CHECKOBJECT = safeCheck.CHECKOBJECT.Value;
                        modelAdd.CHECK_PROJECT_ID = item.Nav_SafeCheckDetail.CHECK_PROJECT_ID;
                        modelAdd.CHECK_QUESTION_ID = ques.ID;
                        modelAdd.CHECKCONTENT = item.CHECKCONTENT;
                        modelAdd.CHECKPROOF = item.Nav_SafeCheckDetail.CHECKPROOF;
                        modelAdd.QUESTION_LEVEL = item.Nav_SafeCheckDetail.QUESTION_LEVEL.HasValue ? item.Nav_SafeCheckDetail.QUESTION_LEVEL.Value : 20;
                        if (modelAdd.QUESTION_LEVEL == 10)
                            modelAdd.SERIOUS_RISK = 1;
                        else
                            modelAdd.SERIOUS_RISK = 0;
                        modelAdd.CHECK_TYPE_ID = safeCheck.CHECK_TYPE_ID;
                        modelAdd.CHECK_TYPE_LEVEL_ID = safeCheck.CHECK_TYPE_LEVEL_ID;
                        modelAdd.RISK_AREA_ID = item.RISK_AREA_ID;
                        modelAdd.ENABLE_STATUS = 0;// FMEnableStatusEnum.启用;
                        modelAdd.NUM = 0;
                        modelAdd.IS_DELETED = false;
                        modelAdd.ORG_ID = item.ORG_ID;
                        //modelAdd.FORM_ID = item.FORM_ID;
                        modelAdd.CREATE_TIME = DateTime.Now;
                        modelAdd.CREATER_ID = safeCheck.USERID_DOPLAN.Value;
                        //modelCheck.CHECK_PROJECT_CATEGORY_ID = content.CHECK_PROJECT_CATEGORY_ID;
                        //modelAdd.CHECK_PROJECT_CATEGORY_ID = item.CHECK_PROJECT_CATEGORY_ID.Value;
                        modelAdd.CHECK_PROJECT_CATEGORY_ID = item.Nav_SafeCheckDetail.CHECK_PROJECT_CATEGORY_ID.Value;
                        depMainCheck = listDepMainCheck.FirstOrDefault(e => e.ID == item.Nav_SafeCheckDetail.DEPARTMENT_ID);
                        if (depMainCheck == null)
                        {
                            depMainCheck = GetEntity(item.Nav_SafeCheckDetail.DEPARTMENT_ID.Value);
                            listDepMainCheck.Add(depMainCheck);
                        }
                        BSPLANCHECKOBJECTEnum RESPONOBJECT = BSPLANCHECKOBJECTEnum.ClassMonitor;
                        //wyw1114-1
                        //modelAdd.DEPARTMENT_ID = item.DEPARTMENT_ID;
                        if (item.CREATER_ID == depMainCheck.USER_ID)
                        {
                            if (depMainCheck.DEPARTMENT_TYPE == 2)
                            {
                                RESPONOBJECT = BSPLANCHECKOBJECTEnum.ClassMonitor;
                            }
                            else
                            {
                                RESPONOBJECT = BSPLANCHECKOBJECTEnum.Head;
                            }
                        }
                        else
                        {
                            RESPONOBJECT = BSPLANCHECKOBJECTEnum.Hon;
                        }
                        listMainConbinDepAdd.Add(new T_BS_CHECK_CONTENT_MAIN_DEPARTMENT()
                        {
                            ID = Guid.NewGuid(),
                            MAIN_ID = modelAdd.ID,
                            ORG_ID = modelAdd.ORG_ID,
                            DEPARTMENT_ID = item.DEPARTMENT_ID,
                            RESPONOBJECT = RESPONOBJECT
                        });
                        listMainConbinAdd.Add(modelAdd);
                        //更新对应的检查问题
                        item.Nav_SafeCheckDetail.CHECK_MAIN_ID = modelAdd.ID;
                        listSafecheckDetail.Add(item.Nav_SafeCheckDetail);
                        #endregion
                    }
                    else if (!item.Nav_SafeCheckDetail.CHECK_MAIN_ID.HasValue && !item.Nav_SafeCheckDetail.CHECK_QUESTION_ID.HasValue)
                    {
                        #region MyRegion
                        if (safeCheck == null)
                        {
                            safeCheck = GetEntity(item.Nav_SafeCheckDetail.SAFE_CHECK_ID);
                        }
                        //添加隐患库
                        //检查问题 手动输入 没有 整改建议与措施 不能入库
                        T_BS_CHECK_MAIN modelAdd = new T_BS_CHECK_MAIN();
                        modelAdd.ID = Guid.NewGuid();
                        modelAdd.ISRISK = true;
                        modelAdd.CHECKOBJECT = safeCheck.CHECKOBJECT.Value;
                        modelAdd.CHECK_PROJECT_ID = item.Nav_SafeCheckDetail.CHECK_PROJECT_ID;
                        modelAdd.CHECK_QUESTION_ID = item.CHECK_QUESTION_ID;
                        modelAdd.CHECKCONTENT = item.CHECKCONTENT;
                        modelAdd.CHECKPROOF = item.Nav_SafeCheckDetail.CHECKPROOF;
                        modelAdd.QUESTION_LEVEL = item.Nav_SafeCheckDetail.QUESTION_LEVEL.HasValue ? item.Nav_SafeCheckDetail.QUESTION_LEVEL.Value : 20;
                        if (modelAdd.QUESTION_LEVEL == 10)
                            modelAdd.SERIOUS_RISK = 1;
                        else
                            modelAdd.SERIOUS_RISK = 0;
                        modelAdd.CHECK_TYPE_ID = safeCheck.CHECK_TYPE_ID;
                        modelAdd.CHECK_TYPE_LEVEL_ID = safeCheck.CHECK_TYPE_LEVEL_ID;
                        modelAdd.RISK_AREA_ID = item.RISK_AREA_ID;
                        modelAdd.ENABLE_STATUS = 0;// FMEnableStatusEnum.启用;
                        modelAdd.NUM = 0;
                        modelAdd.IS_DELETED = false;
                        modelAdd.ORG_ID = item.ORG_ID;
                        //modelAdd.FORM_ID = item.FORM_ID;
                        modelAdd.CREATE_TIME = DateTime.Now;
                        modelAdd.CREATER_ID = safeCheck.USERID_DOPLAN.Value;
                        //modelCheck.CHECK_PROJECT_CATEGORY_ID = content.CHECK_PROJECT_CATEGORY_ID;
                        //modelAdd.CHECK_PROJECT_CATEGORY_ID = item.CHECK_PROJECT_CATEGORY_ID.Value;
                        modelAdd.CHECK_PROJECT_CATEGORY_ID = item.Nav_SafeCheckDetail.CHECK_PROJECT_CATEGORY_ID.Value;
                        depMainCheck = listDepMainCheck.FirstOrDefault(e => e.ID == item.Nav_SafeCheckDetail.DEPARTMENT_ID);
                        if (depMainCheck == null)
                        {
                            depMainCheck = GetEntity(item.Nav_SafeCheckDetail.DEPARTMENT_ID.Value);
                            listDepMainCheck.Add(depMainCheck);
                        }
                        BSPLANCHECKOBJECTEnum RESPONOBJECT = BSPLANCHECKOBJECTEnum.ClassMonitor;
                        //wyw1114-1
                        //modelAdd.DEPARTMENT_ID = item.DEPARTMENT_ID;
                        if (item.CREATER_ID == depMainCheck.USER_ID)
                        {
                            if (depMainCheck.DEPARTMENT_TYPE == 2)
                            {
                                RESPONOBJECT = BSPLANCHECKOBJECTEnum.ClassMonitor;
                            }
                            else
                            {
                                RESPONOBJECT = BSPLANCHECKOBJECTEnum.Head;
                            }
                        }
                        else
                        {
                            RESPONOBJECT = BSPLANCHECKOBJECTEnum.Hon;
                        }
                        listMainConbinDepAdd.Add(new T_BS_CHECK_CONTENT_MAIN_DEPARTMENT()
                        {
                            ID = Guid.NewGuid(),
                            MAIN_ID = modelAdd.ID,
                            ORG_ID = modelAdd.ORG_ID,
                            DEPARTMENT_ID = item.DEPARTMENT_ID,
                            RESPONOBJECT = RESPONOBJECT
                        });
                        listMainConbinAdd.Add(modelAdd);
                        //更新对应的检查问题
                        item.Nav_SafeCheckDetail.CHECK_MAIN_ID = modelAdd.ID;
                        listSafecheckDetail.Add(item.Nav_SafeCheckDetail);
                        #endregion
                    }
                }
                #region MyRegion
                //if (item.Nav_SafeCheckDetail != null && !item.Nav_SafeCheckDetail.CHECK_MAIN_ID.HasValue && !item.Nav_SafeCheckDetail.CHECK_QUESTION_ID.HasValue)
                //{
                //    //组合的安全检查 完善数据库
                //    #region MyRegion
                //    if (safeCheck == null)
                //    {
                //        safeCheck = GetEntity(item.Nav_SafeCheckDetail.SAFE_CHECK_ID);
                //    }
                //    //添加隐患库
                //    //检查问题 手动输入 没有 整改建议与措施 不能入库
                //    T_BS_CHECK_MAIN modelAdd = new T_BS_CHECK_MAIN();
                //    modelAdd.ID = Guid.NewGuid();
                //    modelAdd.ISRISK = true;
                //    modelAdd.CHECKOBJECT = safeCheck.CHECKOBJECT.Value;
                //    modelAdd.CHECK_PROJECT_ID = item.Nav_SafeCheckDetail.CHECK_PROJECT_ID;
                //    modelAdd.CHECK_QUESTION_ID = item.CHECK_QUESTION_ID;
                //    modelAdd.CHECKCONTENT = item.CHECKCONTENT;
                //    modelAdd.CHECKPROOF = item.Nav_SafeCheckDetail.CHECKPROOF;
                //    modelAdd.QUESTION_LEVEL = item.Nav_SafeCheckDetail.QUESTION_LEVEL.HasValue ? item.Nav_SafeCheckDetail.QUESTION_LEVEL.Value : 20;
                //    if (modelAdd.QUESTION_LEVEL == 10)
                //        modelAdd.SERIOUS_RISK = 1;
                //    else
                //        modelAdd.SERIOUS_RISK = 0;
                //    modelAdd.CHECK_TYPE_ID = safeCheck.CHECK_TYPE_ID;
                //    modelAdd.CHECK_TYPE_LEVEL_ID = safeCheck.CHECK_TYPE_LEVEL_ID;
                //    modelAdd.RISK_AREA_ID = item.RISK_AREA_ID;
                //    modelAdd.ENABLE_STATUS = 0;// FMEnableStatusEnum.启用;
                //    modelAdd.NUM = 0;
                //    modelAdd.IS_DELETED = false;
                //    modelAdd.ORG_ID = item.ORG_ID;
                //    //modelAdd.FORM_ID = item.FORM_ID;
                //    modelAdd.CREATE_TIME = DateTime.Now;
                //    modelAdd.CREATER_ID = safeCheck.USERID_DOPLAN.Value;
                //    //modelCheck.CHECK_PROJECT_CATEGORY_ID = content.CHECK_PROJECT_CATEGORY_ID;
                //    //modelAdd.CHECK_PROJECT_CATEGORY_ID = item.CHECK_PROJECT_CATEGORY_ID.Value;
                //    modelAdd.CHECK_PROJECT_CATEGORY_ID = item.Nav_SafeCheckDetail.CHECK_PROJECT_CATEGORY_ID.Value;
                //    depMainCheck = listDepMainCheck.FirstOrDefault(e => e.ID == item.Nav_SafeCheckDetail.DEPARTMENT_ID);
                //    if (depMainCheck == null)
                //    {
                //        depMainCheck = GetEntity(item.Nav_SafeCheckDetail.DEPARTMENT_ID.Value);
                //        listDepMainCheck.Add(depMainCheck);
                //    }
                //    BSPLANCHECKOBJECTEnum RESPONOBJECT = BSPLANCHECKOBJECTEnum.ClassMonitor;
                //    //wyw1114-1
                //    //modelAdd.DEPARTMENT_ID = item.DEPARTMENT_ID;
                //    if (item.CREATER_ID == depMainCheck.USER_ID)
                //    {
                //        if (depMainCheck.DEPARTMENT_TYPE == 2)
                //        {
                //            RESPONOBJECT = BSPLANCHECKOBJECTEnum.ClassMonitor;
                //        }
                //        else
                //        {
                //            RESPONOBJECT = BSPLANCHECKOBJECTEnum.Head;
                //        }
                //    }
                //    else
                //    {
                //        RESPONOBJECT = BSPLANCHECKOBJECTEnum.Hon;
                //    }
                //    listMainConbinDepAdd.Add(new T_BS_CHECK_CONTENT_MAIN_DEPARTMENT()
                //    {
                //        ID = Guid.NewGuid(),
                //        MAIN_ID = modelAdd.ID,
                //        ORG_ID = modelAdd.ORG_ID,
                //        DEPARTMENT_ID = item.DEPARTMENT_ID,
                //        RESPONOBJECT = RESPONOBJECT
                //    });
                //    listMainConbinAdd.Add(modelAdd);
                //    //更新对应的检查问题
                //    item.Nav_SafeCheckDetail.CHECK_MAIN_ID = modelAdd.ID;
                //    listSafecheckDetail.Add(item.Nav_SafeCheckDetail);
                //    #endregion
                //} 
                #endregion
            }
            //更新日期
            //给隐患上报隐患通知责任人  发送待办
            listNotice = NotificationTaskService.InsertUserNoticeTaskModels(codeList, listName, listDataID, entity.ORG_ID, listUserID, listUserName, DateTime.Now, DateTime.Now.AddHours(24), (int)FMNoticeTypeEnum.消息, "BS042");
            //if (listNoticePerson != null && listNoticePerson.Count > 0)
            //{
            //    foreach (var item in listNoticePerson)
            //    {
            //        item.Nav_User = null;
            //    }
            //}
            UnifiedCommit(() =>
            {
                if (entityMain != null)//审批结束 如果隐患上报 全部明细都审批完成 登记完成时间
                    UpdateEntityNoCommit(entityMain);
                if (listNoticePerson.Count > 0)
                    BantchSaveEntityNoCommit(listNoticePerson);
                if (listContent.Count > 0)
                    BantchUpdateEntityNoCommit(listContent);
                if (listNotice.Count > 0)
                    BantchSaveEntityNoCommit(listNotice);
                if (listMainConbinAdd.Count > 0)//确定检查问题  添加安全检查记录
                    BantchSaveEntityNoCommit(listMainConbinAdd);
                if (listMainConbinDepAdd.Count > 0)//确定检查问题  添加安全检查记录
                    BantchSaveEntityNoCommit(listMainConbinDepAdd);
                if (listMainConbinQuestionAdd.Count > 0)//确定检查问题  添加检查问题
                    BantchSaveEntityNoCommit(listMainConbinQuestionAdd);
                if (listSafecheckDetail.Count > 0)//确定检查问题  添加安全检查记录
                    BantchUpdateEntityNoCommit(listSafecheckDetail);
            });
            return true;
        }
        /// 
        /// 隐患上报  完成   修改各种状态   完善隐患库
        /// 
        /// 
        /// 
        private bool DealEnd(string id)
        {
            var deal = GetEntity(id, new string[] { "Nav_Submit.Nav_ListRiskSubmitContent", "Nav_Submit.Nav_ListRiskSubmitContent.Nav_SafeCheck", "Nav_SubmitContent.Nav_SafeCheckDetail", "Nav_SubmitContent.Nav_CheckMain", "Nav_SubmitContent.Nav_Question", "Nav_SubmitContent.Nav_Contents" });
            deal.DEALSITUATION = (int)DealSituation.End;//结束
            T_BS_RISK_SUBMIT subModel = deal.Nav_Submit;
            List listContent = subModel.Nav_ListRiskSubmitContent;
            //如果是手动上报 都是选择检查问题 不存在隐患入库
            var content = deal.Nav_SubmitContent;
            //deal.Nav_SubmitContent = null;//不能清空  否则RISK_SUBMIT_CONTENT_ID 会被清空
            var modelNoOK = listContent.FirstOrDefault(e => e.ID != content.ID && (!e.ISBACK.HasValue || !e.ISBACK.Value) && e.RiskContentState.HasValue && e.RiskContentState != (int)RiskContentState.OK && e.RiskContentState != (int)RiskContentState.BackOK);
            if (modelNoOK == null)
            {
                subModel.ISORDEREND = true;
            }
            content.OKDATE = DateTime.Now;
            content.RiskContentState = (int)RiskContentState.OK;
            if (!content.LastDateUser.HasValue || content.LastDateUser.Value > content.OKDATE)
                content.ISFINISHINTTIME = true;
            else
                content.ISFINISHINTTIME = false;
            var check = content.Nav_CheckMain;
            //根据隐患上报中检查结果 
            //未发现此问题 无需隐患上报
            //以问题描述一致 无需完善隐患库
            //其他  手动填写 需要完善隐患库 
            //书写 隐患待上报 内容 发送给安环部对应的人 标准化描述 再审批流 入库   
            //检查问题
            T_BS_CHECK_QUESTION modelQues = null;
            T_BS_CHECK_MAIN modelCheck = null;
            T_BS_CHECK_CONTENT_MAIN_DEPARTMENT mainDep = null;
            if (content.Nav_SafeCheckDetail == null)
            {
                if (content.CHECK_MAIN_ID.HasValue)
                {
                    #region     旧版
                    var checkMain = GetEntity(content.CHECK_MAIN_ID.Value);
                    if (checkMain.CHECK_TYPE_ID == subModel.CHECK_TYPE_ID && checkMain.CHECK_TYPE_LEVEL_ID == subModel.CHECK_TYPE_LEVEL_ID && checkMain.CHECK_QUESTION_ID == content.CHECK_QUESTION_ID && checkMain.RISK_AREA_ID == content.RISK_AREA_ID)
                    {
                        //全部都一样 
                    }
                    else
                    {
                        //手动隐患上报
                        //选择 检查问题
                        //填写检查依据、检查区域
                        modelCheck = new T_BS_CHECK_MAIN();
                        modelCheck.ID = Guid.NewGuid();
                        modelCheck.CHECK_QUESTION_ID = content.CHECK_QUESTION_ID;
                        modelCheck.CHECKPROOF = content.PROOF;//检查依据
                        modelCheck.QUESTION_LEVEL = content.QUESTION_LEVEL;
                        modelCheck.SERIOUS_RISK = (content.QUESTION_LEVEL == (int)BSQuestionLevelEnum.重大) ? 1 : 0;
                        modelCheck.CHECK_TYPE_ID = subModel.CHECK_TYPE_ID;
                        modelCheck.CHECK_TYPE_LEVEL_ID = subModel.CHECK_TYPE_LEVEL_ID;
                        modelCheck.RISK_AREA_ID = content.RISK_AREA_ID;
                        modelCheck.CHECKOBJECT = content.Nav_SafeCheck.CHECKOBJECT.Value;
                        modelCheck.CHECK_PROJECT_ID = content.CHECK_PROJECT_ID;
                        modelCheck.CHECKCONTENT = content.CHECKCONTENT;
                        modelCheck.CHECK_PROJECT_PROJECT_CATEGORY_ID = content.CHECK_PROJECT_PROJECT_CATEGORY_ID;
                        modelCheck.CHECK_PROJECT_CATEGORY_ID = content.CHECK_PROJECT_CATEGORY_ID;
                        modelCheck.NUM = content.CHECK_MAIN_ID != null ? content.Nav_CheckMain.NUM : 0;
                        modelCheck.ENABLE_STATUS = (int)FMEnableStatusEnum.启用;
                        modelCheck.IS_DELETED = false;
                        modelCheck.ORG_ID = deal.ORG_ID;
                        //modelCheck.ENTITY_ORG_TPYE = content.Nav_CheckMain.ENTITY_ORG_TPYE;
                        //modelCheck.FORM_ID = content.Nav_CheckMain.FORM_ID;
                        //modelCheck.FLOW_STATUS = content.Nav_CheckMain.FLOW_STATUS;
                        //modelCheck.FLOW_SEND_STATUS = content.Nav_CheckMain.FLOW_SEND_STATUS;
                        //modelCheck.FLOW_ID = content.Nav_CheckMain.FLOW_ID;
                        modelCheck.CREATE_TIME = DateTime.Now;
                        modelCheck.CREATER_ID = APT.Infrastructure.Api.AppContext.CurrentSession.UserID;
                        //modelCheck.MODIFY_TIME = content.Nav_CheckMain.MODIFY_TIME;
                        //modelCheck.MODIFIER_ID = content.Nav_CheckMain.MODIFIER_ID;
                        modelCheck.ISRISK = true;
                        modelCheck.CHECK_CONTENTS_ID = content.CHECK_CONTENTS_ID;
                        BSPLANCHECKOBJECTEnum RESPONOBJECT = BSPLANCHECKOBJECTEnum.ClassMonitor;
                        var dep = GetEntity(content.DEPARTMENT_ID.Value);
                        if (dep.USER_ID == content.USER_ID)
                        {
                            if (dep.DEPARTMENT_TYPE == 2)
                            {
                                RESPONOBJECT = BSPLANCHECKOBJECTEnum.ClassMonitor;
                            }
                            else
                            {
                                RESPONOBJECT = BSPLANCHECKOBJECTEnum.Head;
                            }
                        }
                        else
                        {
                            RESPONOBJECT = BSPLANCHECKOBJECTEnum.Hon;
                        }
                        mainDep = new T_BS_CHECK_CONTENT_MAIN_DEPARTMENT()
                        {
                            ID = Guid.NewGuid(),
                            MAIN_ID = modelCheck.ID,
                            ORG_ID = modelCheck.ORG_ID,
                            DEPARTMENT_ID = content.DEPARTMENT_ID,
                            RESPONOBJECT = RESPONOBJECT
                        };
                    }
                    #endregion
                }
                else
                {
                    #region     新版 BS060
                    //检查内容 检查问题 整改建议与措施
                    modelCheck = new T_BS_CHECK_MAIN();
                    modelCheck.ID = Guid.NewGuid();
                    modelCheck.CHECK_QUESTION_ID = content.CHECK_QUESTION_ID;
                    modelCheck.CHECKPROOF = content.PROOF;//检查依据
                    modelCheck.QUESTION_LEVEL = content.QUESTION_LEVEL;
                    modelCheck.SERIOUS_RISK = (content.QUESTION_LEVEL == (int)BSQuestionLevelEnum.重大) ? 1 : 0;
                    modelCheck.CHECK_TYPE_ID = subModel.CHECK_TYPE_ID;
                    modelCheck.CHECK_TYPE_LEVEL_ID = subModel.CHECK_TYPE_LEVEL_ID;
                    modelCheck.RISK_AREA_ID = content.RISK_AREA_ID;
                    modelCheck.CHECKOBJECT = (int)content.Nav_Contents.CHECKOBJECT;//.Nav_SafeCheck.CHECKOBJECT.Value;
                    modelCheck.CHECK_PROJECT_ID = content.CHECK_PROJECT_ID;
                    modelCheck.CHECKCONTENT = content.CHECKCONTENT;
                    modelCheck.CHECK_PROJECT_PROJECT_CATEGORY_ID = content.CHECK_PROJECT_PROJECT_CATEGORY_ID;
                    modelCheck.CHECK_PROJECT_CATEGORY_ID = content.CHECK_PROJECT_CATEGORY_ID;
                    modelCheck.NUM = 1;
                    modelCheck.ENABLE_STATUS = (int)FMEnableStatusEnum.启用;
                    modelCheck.IS_DELETED = false;
                    modelCheck.ORG_ID = deal.ORG_ID;
                    modelCheck.CREATE_TIME = DateTime.Now;
                    modelCheck.CREATER_ID = APT.Infrastructure.Api.AppContext.CurrentSession.UserID;
                    modelCheck.ISRISK = true;
                    modelCheck.CHECK_CONTENTS_ID = content.CHECK_CONTENTS_ID;
                    BSPLANCHECKOBJECTEnum RESPONOBJECT = BSPLANCHECKOBJECTEnum.ClassMonitor;
                    var dep = GetEntity(content.DEPARTMENT_ID.Value);
                    if (dep.USER_ID == content.USER_ID)
                    {
                        if (dep.DEPARTMENT_TYPE == 2)
                        {
                            RESPONOBJECT = BSPLANCHECKOBJECTEnum.ClassMonitor;
                        }
                        else
                        {
                            RESPONOBJECT = BSPLANCHECKOBJECTEnum.Head;
                        }
                    }
                    else
                    {
                        RESPONOBJECT = BSPLANCHECKOBJECTEnum.Hon;
                    }
                    mainDep = new T_BS_CHECK_CONTENT_MAIN_DEPARTMENT()
                    {
                        ID = Guid.NewGuid(),
                        MAIN_ID = modelCheck.ID,
                        ORG_ID = modelCheck.ORG_ID,
                        DEPARTMENT_ID = content.DEPARTMENT_ID,
                        RESPONOBJECT = RESPONOBJECT
                    };
                    #endregion
                }
            }
            else if (content.Nav_SafeCheckDetail.CHECKRESULT == (int)CHECKRESULTEnum.Same)
            {
                //安全检查 如果是 与问题描述一致 也不存在此问题
                //无需 完善检查问题
            }
            else
            {
                //安全检查 结果 其他  隐患上报  隐患入库
                //检查问题描述 检查依据   检查等级  是否重大隐患 根据页面数据赖
                //检查区域等 根据检查问题来
                //检查问题
                modelQues = new T_BS_CHECK_QUESTION();
                modelQues.ID = Guid.NewGuid();
                modelQues.ORG_ID = deal.ORG_ID;
                modelQues.DESCREPTION = content.DESCREPTION;//问题描述
                modelQues.DEMAND = content.Nav_Question.DEMAND;//整改建议与措施
                modelQues.CHECK_CONTENTS_ID = content.CHECK_CONTENTS_ID;
                modelQues.QUESTION_LEVEL = (BSQuestionLevelEnum)content.QUESTION_LEVEL;
                modelCheck = new T_BS_CHECK_MAIN();
                modelCheck.ID = Guid.NewGuid();
                modelCheck.CHECK_QUESTION_ID = modelQues.ID;
                modelCheck.CHECKPROOF = content.PROOF;//检查依据
                modelCheck.QUESTION_LEVEL = content.QUESTION_LEVEL;
                modelCheck.SERIOUS_RISK = (content.QUESTION_LEVEL == (int)BSQuestionLevelEnum.重大) ? 1 : 0;
                //var deal = GetEntity(id, new string[] { "Nav_Submit.Nav_ListRiskSubmitContent", "Nav_SubmitContent.Nav_SafeCheckDetail.Nav_CheckMain", "Nav_SubmitContent.Nav_Question" });
                modelCheck.CHECKOBJECT = content.Nav_SafeCheck.CHECKOBJECT.Value;
                modelCheck.CHECK_PROJECT_ID = content.CHECK_PROJECT_ID;
                modelCheck.CHECKCONTENT = content.CHECKCONTENT;
                modelCheck.CHECK_TYPE_ID = content.Nav_SafeCheck.CHECK_TYPE_ID;
                modelCheck.CHECK_TYPE_LEVEL_ID = content.Nav_SafeCheck.CHECK_TYPE_LEVEL_ID;
                modelCheck.RISK_AREA_ID = content.RISK_AREA_ID;
                modelCheck.ENABLE_STATUS = (int)FMEnableStatusEnum.启用;
                modelCheck.NUM = content.CHECK_MAIN_ID != null ? content.Nav_CheckMain.NUM : 0;
                modelCheck.IS_DELETED = false;
                modelCheck.ORG_ID = deal.ORG_ID;
                //modelCheck.ENTITY_ORG_TPYE = content.Nav_CheckMain.ENTITY_ORG_TPYE;
                //modelCheck.FORM_ID = content.Nav_CheckMain.FORM_ID;
                //modelCheck.FLOW_STATUS = content.Nav_CheckMain.FLOW_STATUS;
                //modelCheck.FLOW_SEND_STATUS = content.Nav_CheckMain.FLOW_SEND_STATUS;
                //modelCheck.FLOW_ID = content.Nav_CheckMain.FLOW_ID;
                modelCheck.CREATE_TIME = DateTime.Now;
                modelCheck.CREATER_ID = APT.Infrastructure.Api.AppContext.CurrentSession.UserID;
                //modelCheck.MODIFY_TIME = content.Nav_CheckMain.MODIFY_TIME;
                //modelCheck.MODIFIER_ID = content.Nav_CheckMain.MODIFIER_ID;
                modelCheck.CHECK_PROJECT_PROJECT_CATEGORY_ID = content.CHECK_PROJECT_PROJECT_CATEGORY_ID;
                modelCheck.CHECK_PROJECT_CATEGORY_ID = content.CHECK_PROJECT_CATEGORY_ID;
                modelCheck.ISRISK = true;
                modelCheck.CHECK_CONTENTS_ID = content.CHECK_CONTENTS_ID;
                //wyw1114-1
                //modelCheck.DEPARTMENT_ID = content.DEPARTMENT_ID;
                BSPLANCHECKOBJECTEnum RESPONOBJECT = BSPLANCHECKOBJECTEnum.ClassMonitor;
                var dep = GetEntity(content.DEPARTMENT_ID.Value);
                if (dep.USER_ID == content.USER_ID)
                {
                    if (dep.DEPARTMENT_TYPE == 2)
                    {
                        RESPONOBJECT = BSPLANCHECKOBJECTEnum.ClassMonitor;
                    }
                    else
                    {
                        RESPONOBJECT = BSPLANCHECKOBJECTEnum.Head;
                    }
                }
                else
                {
                    RESPONOBJECT = BSPLANCHECKOBJECTEnum.Hon;
                }
                mainDep = new T_BS_CHECK_CONTENT_MAIN_DEPARTMENT()
                {
                    ID = Guid.NewGuid(),
                    MAIN_ID = modelCheck.ID,
                    ORG_ID = modelCheck.ORG_ID,
                    DEPARTMENT_ID = content.DEPARTMENT_ID,
                    RESPONOBJECT = RESPONOBJECT
                };
            }
            UnifiedCommit(() =>
            {
                UpdateEntityNoCommit(deal);//修改状态 审批结束
                if (subModel.ISORDEREND)//隐患上报单 是否完成
                    UpdateEntityNoCommit(subModel);
                UpdateEntityNoCommit(content);//隐患上报内容明细
                if (modelQues != null)
                    UpdateEntityNoCommit(modelQues);
                if (modelCheck != null)
                    UpdateEntityNoCommit(modelCheck);
                if (mainDep != null)
                    UpdateEntityNoCommit(mainDep);
            });
            return true;
        }
        /// 
        /// 隐患上报详情待入库 审批回调
        /// api/BS/BSRiskSubmit/DealEnd
        /// 
        /// 
        ///  
        private bool ApproveBackBS048(string id)
        {
            //问题ID 判断检查问题描述 整改建议与措施  
            //如果不完全一致 添加问题 修改问题ID
            //入库
            Guid idGuid = new Guid(id);
            T_BS_RISK_SUBMIT_CONTENT_TEMP model = GetEntity(idGuid, new string[] { "Nav_CheckQuestion" });
            T_BS_CHECK_QUESTION modelQ = GetEntity(e => e.DEMAND == model.DEMAND && e.DESCREPTION == model.DESCREPTION);
            bool isNeedInsertQuestion = false;
            bool isNeedInsertMain = false;
            if (modelQ == null)
            {
                isNeedInsertQuestion = true;
                //添加 问题
                modelQ = new T_BS_CHECK_QUESTION();
                modelQ.DEMAND = model.DEMAND;
                modelQ.DESCREPTION = model.DESCREPTION;
                modelQ.IS_DELETED = false;
                modelQ.ID = Guid.NewGuid();
                modelQ.NUM = 0;
                modelQ.ORG_ID = model.ORG_ID;
                modelQ.ENABLE_STATUS = (int)FMEnableStatusEnum.启用;
                model.CHECK_QUESTION_ID = modelQ.ID;
            }
            else if (modelQ.IS_DELETED)
            {
                modelQ.IS_DELETED = false;
                model.CHECK_QUESTION_ID = modelQ.ID;
            }
            T_BS_CHECK_MAIN modelInsert = new T_BS_CHECK_MAIN();
            if (isNeedInsertQuestion)
            {
                isNeedInsertMain = true;
            }
            else
            {
                var CheckMain = GetEntity(e => e.CHECKCONTENT == model.CHECKCONTENT && e.CHECKCONTENT == model.CHECKCONTENT && e.CHECK_QUESTION_ID == model.CHECK_QUESTION_ID);
                if (CheckMain == null)
                    isNeedInsertMain = true;
            }
            if (isNeedInsertMain)
            {
                modelInsert.ID = model.ID;
                modelInsert.CHECKOBJECT = model.CHECKOBJECT;
                modelInsert.CHECK_PROJECT_ID = model.CHECK_PROJECT_ID;
                modelInsert.CHECK_QUESTION_ID = isNeedInsertQuestion ? modelQ.ID : model.CHECK_QUESTION_ID; //如果有添加问题 
                modelInsert.CHECKCONTENT = model.CHECKCONTENT;
                modelInsert.CHECKPROOF = model.CHECKPROOF;
                modelInsert.QUESTION_LEVEL = model.QUESTION_LEVEL;
                modelInsert.SERIOUS_RISK = model.SERIOUS_RISK;
                modelInsert.CHECK_TYPE_ID = model.CHECK_TYPE_ID;
                modelInsert.CHECK_TYPE_LEVEL_ID = model.CHECK_TYPE_LEVEL_ID;
                modelInsert.RISK_AREA_ID = model.RISK_AREA_ID;
                modelInsert.ENABLE_STATUS = (int)FMEnableStatusEnum.启用;
                modelInsert.NUM = 0;
                modelInsert.IS_DELETED = false;
                modelInsert.ORG_ID = model.ORG_ID;
                //modelInsert.ENTITY_ORG_TPYE =model.  ;
                //modelInsert.FORM_ID    =model.  ;
                //modelInsert.FLOW_STATUS=model.  ;
                //modelInsert.FLOW_SEND_STATUS=model.  ;
                //modelInsert.FLOW_ID     =model.  ;
                //modelInsert.CREATE_TIME =model.  ;
                //modelInsert.MODIFY_TIME =model.  ;
                //modelInsert.CREATER_ID  =model.  ;
                //modelInsert.MODIFIER_ID =model.  ;
                modelInsert.CHECK_PROJECT_PROJECT_CATEGORY_ID = model.CHECK_PROJECT_PROJECT_CATEGORY_ID;
                modelInsert.ISRISK = true;
            }
            model.ISINSERT = true;//反正都入库
            model.ORDERTYPE = OrderType.end;
            model.Nav_CheckQuestion = null;
            UnifiedCommit(() =>
            {
                UpdateEntityNoCommit(model);//更新中间信息
                if (isNeedInsertQuestion)
                    UpdateEntityNoCommit(modelQ);//添加问题
                if (isNeedInsertMain)
                    UpdateEntityNoCommit(modelInsert);//隐患入库
            });
            return true;
        }
        /// 
        /// 延期申请  完成   修改状态、最后完成时间   给验收人发送通知
        /// api/BS/BSRiskSubmit/DealEnd
        /// 
        /// 
        ///  
        private bool DealEnd_BS_DelayApply(string id)
        {
            var entity = GetEntity(id, new string[] { "Nav_ListApplyDetail.Nav_SubmitContent.Nav_UserCheck" });
            entity.OPERARTETYPE = (int)OperateType.Check;
            //修改记录信息 状态 最后完成时间
            //给验收人发送通知
            var listContent = entity.Nav_ListApplyDetail;
            List listNotice = new List();
            List listBackAll = new List();
            List listRiskContent = new List();
            List listBack = null;
            List listCheckUserID = new List();
            foreach (var item in listContent)
            {
                if (item.IS_DELETED)
                {
                    continue;
                }
                T_BS_RISK_SUBMIT_CONTENT subContent = item.Nav_SubmitContent;
                //自动生成的 
                if (subContent.RiskContentState == (int)RiskContentState.OKNotBack || subContent.RiskContentState == (int)RiskContentState.ReportedDelay)
                {
                    BaseFilter filter = null;
                    //如果是审批退回
                    //同时修改 退回自动新增的隐患上报
                    //审批退回 自动生成的单 状态为 【已修改落实整改人  ActualDealChange = 32】
                    listBack = this.GetEntities(e => e.PARENTID.HasValue && e.PARENTID.Value == subContent.ID && e.RiskContentState.HasValue && e.RiskContentState == (int)RiskContentState.ActualDealChange && e.ACTUAL_DEAL_USER_ID.HasValue && e.ACTUAL_DEAL_USER_ID.Value == subContent.ACTUAL_DEAL_USER_ID, filter, null).ToList();
                    if (listBack != null && listBack.Count > 0)
                    {
                        foreach (var item2 in listBack)
                        {
                            item2.LastDateUser = subContent.LastDateSystem;
                        }
                        listBackAll.AddRange(listBack);
                    }
                }
                subContent.RiskContentState = (int)RiskContentState.ReportedDelay;
                subContent.LastDateUser = item.LastDateApply;
                listRiskContent.Add(subContent);
                item.CHCEKUSERID = subContent.CHECK_USER_ID;//指定验收人
                if (!listCheckUserID.Contains(subContent.CHECK_USER_ID.Value))
                {
                    var notice = NotificationTaskService.InsertUserNoticeTaskModel("延期整改通知单:" + entity.NAME.Replace("延期申请:", ""), entity.ID, entity.ORG_ID, subContent.CHECK_USER_ID.Value, subContent.Nav_UserCheck.NAME, DateTime.Now, DateTime.Now.AddHours(24), (int)FMNoticeTypeEnum.消息, "BS046_SHOWPRINT");
                    listNotice.Add(notice);
                }
            }
            //修改 model
            UnifiedCommit(() =>
            {
                UpdateEntityNoCommit(entity);//修改状态 
                BantchUpdateEntityNoCommit(listContent);//修改整改落实人
                BantchUpdateEntityNoCommit(listRiskContent);//修改上报详情整改期限、状态
                if (listBackAll != null && listBackAll.Count > 0)
                    BantchUpdateEntityNoCommit(listBackAll);//修改 自动生成的整改单
                //if (notice != null)//发送通知
                //    UpdateEntityNoCommit(notice);
                if (listNotice.Count > 0)//发送通知
                {
                    BantchSaveEntityNoCommit(listNotice);
                }
            });
            return true;
        }
        /// 
        /// 安全检查线下完成后进入审批 审批流回调
        /// 
        /// 
        ///  
        private bool CheckAuditEnd(string id)
        {
            //弃用具体看 CheckAuditEndNwe
            var entity = GetEntity(id, new string[] { "Nav_ListSafeCheckDetail" });
            if (!entity.PLAN_SET_ID.HasValue || !entity.CHECKTIME.HasValue || entity.CHECKTIME.Value.Date == DateTime.Now.Date) //同一天
            {
                entity.ISFINISHINTTIME = true;
            }
            else
            {
                var modelPlanset = GetEntity(entity.PLAN_SET_ID.Value);
                if (modelPlanset == null)
                {
                    entity.ISFINISHINTTIME = true;
                }
                else
                {
                    DateTime dtLast = SafeCheckService.GetEndTime((BSPLANCHECKFREQUENCYEnum)modelPlanset.PLANCHECKFREQUENCY, modelPlanset.CHECKTIME);//最迟时间 
                    if (!entity.ISFINISHINTTIME && DateTime.Now <= dtLast)
                    {
                        entity.ISFINISHINTTIME = true;
                    }
                }
            }
            // 1、审批记录单 判断审批结果 修改安全检查表制定的单审批状态
            T_PF_APPROVE modelApprove = this.GetEntity(e => e.DATA_ID == Guid.Parse(id) && e.APPROVE_CODE == "BS034_SHOWPRINT");
            if (modelApprove.APPROVE_STATUS == 10)
                entity.STATUCHECK = (int)HMAuditStatusEnmu.归档;  //已完成
            else if (modelApprove.APPROVE_STATUS == 20)
                entity.STATUCHECK = (int)HMAuditStatusEnmu.审批驳回;  //已驳回
            //组合库
            List listCheckMain = new List();
            List listCheckMainDep = new List();
            List listCheckDetail = new List();
            List listUpdateMain = new List();
            List checkMainChangeAll = new List();//所有被修改的检查库
            var checkMainChange = entity.Nav_ListSafeCheckDetail.Where(e => e.CHECK_MAIN_ID.HasValue && e.ISMAINCHANGE);
            if (checkMainChange != null && checkMainChange.Any())
            {
                List listMainID = checkMainChange.Select(e => e.CHECK_MAIN_ID.Value).ToList();
                checkMainChangeAll = GetEntities(e => listMainID.Contains(e.ID), null, new string[] { "Nav_ListMainDep" }).ToList();
            }
            List listDepMainCheck = new List();
            T_FM_DEPARTMENT depMainCheck = null;
            T_FM_DEPARTMENT depMade = null;//制表人 所在组织
            //可能和安全隐患对接
            foreach (var item in entity.Nav_ListSafeCheckDetail)
            {
                if (entity.RISKSTATE == 0 && item.CHECKRESULT.HasValue && (item.CHECKRESULT.Value == 20 || item.CHECKRESULT.Value == 30))
                {
                    //检查有问题  待安全隐患上报   20 与描述一致  30 其他
                    entity.RISKSTATE = 10;
                }
                #region   如果 不是检查库 需要添加组合库  同时修改检查信息中的ID
                if ((item.CHECK_MAIN_ID == null || item.CHECK_MAIN_ID == Guid.Empty) && item.CHECKRESULT == 20 && item.QUESTION_LEVEL.HasValue)
                {
                    #region     检查制定 手动添加 记录
                    //添加隐患库
                    //检查问题 手动输入 没有 整改建议与措施 不能入库
                    T_BS_CHECK_MAIN modelAdd = new T_BS_CHECK_MAIN();
                    modelAdd.ID = Guid.NewGuid();
                    modelAdd.ISRISK = true;
                    modelAdd.CHECKOBJECT = entity.CHECKOBJECT.Value;
                    modelAdd.CHECK_PROJECT_ID = item.CHECK_PROJECT_ID;
                    //modelAdd.CHECK_QUESTION_ID = item.CHECK_QUESTION_ID;
                    modelAdd.CHECK_QUESTION_ID = GetEntity(e => e.SAFE_CHECK_DETAIL_ID == item.ID).SAFE_CHECK_QUESTION_ID;
                    modelAdd.CHECKCONTENT = item.CHECKCONTENT;
                    modelAdd.CHECKPROOF = item.CHECKPROOF;
                    modelAdd.QUESTION_LEVEL = item.QUESTION_LEVEL.Value;
                    if (modelAdd.QUESTION_LEVEL == 10)
                        modelAdd.SERIOUS_RISK = 1;
                    else
                        modelAdd.SERIOUS_RISK = 0;
                    modelAdd.CHECK_TYPE_ID = entity.CHECK_TYPE_ID;
                    modelAdd.CHECK_TYPE_LEVEL_ID = entity.CHECK_TYPE_LEVEL_ID;
                    modelAdd.RISK_AREA_ID = item.RISK_AREA_ID;
                    modelAdd.ENABLE_STATUS = 0;// FMEnableStatusEnum.启用;
                    modelAdd.NUM = 0;
                    modelAdd.IS_DELETED = false;
                    modelAdd.ORG_ID = item.ORG_ID;
                    //modelAdd.FORM_ID = item.FORM_ID;
                    modelAdd.CREATE_TIME = DateTime.Now;
                    modelAdd.CREATER_ID = entity.USERID_DOPLAN.Value;
                    //modelAdd.DEPARTMENT_ID = item.DEPARTMENT_ID;
                    depMainCheck = listDepMainCheck.FirstOrDefault(e => e.ID == item.DEPARTMENT_ID);
                    if (depMainCheck == null)
                    {
                        depMainCheck = GetEntity(item.DEPARTMENT_ID.Value);
                        listDepMainCheck.Add(depMainCheck);
                    }
                    //if (item.CREATER_ID == depMainCheck.USER_ID)
                    //{
                    //    if (depMainCheck.DEPARTMENT_TYPE == 2)
                    //    {
                    //        modelAdd.RESPONOBJECT = BSPLANCHECKOBJECTEnum.ClassMonitor;
                    //    }
                    //    else
                    //    {
                    //        modelAdd.RESPONOBJECT = BSPLANCHECKOBJECTEnum.Head;
                    //    }
                    //}
                    //else
                    //{
                    //    modelAdd.RESPONOBJECT = BSPLANCHECKOBJECTEnum.Hon;
                    //}
                    //modelAdd.ENTITY_ORG_TPYE = item.ENTITY_ORG_TPYE;
                    //modelAdd.FLOW_STATUS = item.FLOW_STATUS;
                    //modelAdd.FLOW_SEND_STATUS = item.FLOW_SEND_STATUS;
                    //modelAdd.FLOW_ID = item.FLOW_ID;
                    //modelAdd.MODIFY_TIME = item.MODIFY_TIME;
                    //modelAdd.MODIFIER_ID = item.MODIFIER_ID;
                    modelAdd.CHECK_PROJECT_PROJECT_CATEGORY_ID = item.CHECK_PROJECT_PROJECT_CATEGORY_ID;
                    modelAdd.CHECK_PROJECT_CATEGORY_ID = item.CHECK_PROJECT_CATEGORY_ID;
                    listCheckMain.Add(modelAdd);//不判断去重了,按理有就直接选择了,不会删除自己再手动选
                    //会写到检查信息
                    item.CHECK_MAIN_ID = modelAdd.ID;
                    if (depMade == null)
                    {
                        depMade = GetEntity(entity.USERID_DOPLAN.Value, "Nav_Department").Nav_Department;
                    }
                    //组织范围
                    listCheckMainDep.Add(new T_BS_CHECK_CONTENT_MAIN_DEPARTMENT()
                    {
                        ID = Guid.NewGuid(),
                        MAIN_ID = modelAdd.ID,
                        IS_DELETED = false,
                        ORG_ID = modelAdd.ORG_ID,
                        //ENTITY_ORG_TPYE = ,
                        //FORM_ID = ,
                        //FLOW_STATUS = ,
                        //FLOW_SEND_STATUS = ,
                        //FLOW_ID = ,
                        CREATE_TIME = modelAdd.CREATE_TIME,
                        MODIFY_TIME = modelAdd.CREATE_TIME,
                        CREATER_ID = modelAdd.CREATER_ID,
                        MODIFIER_ID = modelAdd.CREATER_ID,
                        DEPARTMENT_ID = depMade.ID,//制表人 所在组织
                        //RESPONOBJECT = modelAdd.RESPONOBJECT,
                    });
                    listCheckDetail.Add(item);
                    #endregion
                }
                else if (item.ISMAINCHANGE && item.CHECK_MAIN_ID.HasValue && checkMainChangeAll != null && checkMainChangeAll.Count > 0)
                {
                    #region    安全检查 修改  添加隐患库 或者 修改 隐患库安全检查可修改的字段   修改 标志符
                    var main = checkMainChangeAll.FirstOrDefault(e => e.ID == item.CHECK_MAIN_ID.Value);
                    if (main == null)
                        continue;
                    if (main.CHECK_PROJECT_ID != item.CHECK_PROJECT_ID || main.CHECK_PROJECT_PROJECT_CATEGORY_ID != item.CHECK_PROJECT_PROJECT_CATEGORY_ID || main.CHECKCONTENT != item.CHECKCONTENT || main.CHECKPROOF != item.CHECKPROOF || main.RISK_AREA_ID != item.RISK_AREA_ID || (item.QUESTION_LEVEL.HasValue && main.QUESTION_LEVEL != item.QUESTION_LEVEL))
                    {
                        //有修改
                        if (!main.ISRISK)
                        {
                            //安全库 被修改
                            main.ENABLE_STATUS = 1;// FMEnableStatusEnum.禁用;
                            listUpdateMain.Add(main);
                            //隐患库被修改
                            //修改 修改的信息 更新到 库中 删除新增的库信息
                            T_BS_CHECK_MAIN modelMain = new T_BS_CHECK_MAIN();
                            modelMain.ID = Guid.NewGuid();
                            modelMain.CHECKOBJECT = main.CHECKOBJECT;
                            modelMain.NUM = main.NUM;
                            modelMain.CHECK_PROJECT_ID = item.CHECK_PROJECT_ID;
                            modelMain.CHECK_QUESTION_ID = item.CHECK_QUESTION_ID == null ? main.CHECK_QUESTION_ID : item.CHECK_QUESTION_ID;
                            modelMain.CHECKCONTENT = item.CHECKCONTENT;
                            modelMain.CHECKPROOF = item.CHECKPROOF;
                            modelMain.QUESTION_LEVEL = item.QUESTION_LEVEL.HasValue ? item.QUESTION_LEVEL.Value : main.QUESTION_LEVEL;
                            modelMain.SERIOUS_RISK = modelMain.QUESTION_LEVEL == 10 ? 1 : 0;// (int)item.SERIOUS_RISK;
                            modelMain.CHECK_TYPE_ID = entity.CHECK_TYPE_ID;
                            modelMain.CHECK_TYPE_LEVEL_ID = entity.CHECK_TYPE_LEVEL_ID;
                            modelMain.RISK_AREA_ID = item.RISK_AREA_ID;
                            modelMain.ORG_ID = item.ORG_ID;
                            modelMain.ENTITY_ORG_TPYE = item.ENTITY_ORG_TPYE;
                            modelMain.FORM_ID = item.FORM_ID;
                            modelMain.FLOW_STATUS = item.FLOW_STATUS;
                            modelMain.FLOW_SEND_STATUS = item.FLOW_SEND_STATUS;
                            modelMain.FLOW_ID = item.FLOW_ID;
                            modelMain.CREATE_TIME = DateTime.Now;
                            modelMain.MODIFY_TIME = DateTime.Now;
                            modelMain.CREATER_ID = APT.Infrastructure.Api.AppContext.CurrentSession.UserID;
                            modelMain.MODIFIER_ID = APT.Infrastructure.Api.AppContext.CurrentSession.UserID;
                            modelMain.CHECK_PROJECT_PROJECT_CATEGORY_ID = item.CHECK_PROJECT_PROJECT_CATEGORY_ID;
                            modelMain.CHECK_PROJECT_CATEGORY_ID = item.CHECK_PROJECT_CATEGORY_ID;
                            modelMain.ISRISK = true;
                            modelMain.IS_DELETED = false;
                            modelMain.ENABLE_STATUS = 0;// FMEnableStatusEnum.启用;
                            modelMain.CHECK_CONTENTS_ID = main.CHECK_CONTENTS_ID;//改不到检查内容
                            listCheckMain.Add(modelMain);//添加待添加的信息   和  手动添加的一起
                            foreach (var itemDe in main.Nav_ListMainDep)
                            {
                                listCheckMainDep.Add(new T_BS_CHECK_CONTENT_MAIN_DEPARTMENT()
                                {
                                    ID = Guid.NewGuid(),
                                    MAIN_ID = modelMain.ID,
                                    IS_DELETED = false,
                                    ORG_ID = modelMain.ORG_ID,
                                    //ENTITY_ORG_TPYE = ,
                                    //FORM_ID = ,
                                    //FLOW_STATUS = ,
                                    //FLOW_SEND_STATUS = ,
                                    //FLOW_ID = ,
                                    CREATE_TIME = modelMain.CREATE_TIME,
                                    MODIFY_TIME = modelMain.CREATE_TIME,
                                    CREATER_ID = modelMain.CREATER_ID,
                                    MODIFIER_ID = modelMain.CREATER_ID,
                                    DEPARTMENT_ID = itemDe.DEPARTMENT_ID,
                                    RESPONOBJECT = itemDe.RESPONOBJECT,
                                });
                            }
                        }
                        else
                        {
                            //隐患库 修改  安全检查可修改到的信息
                            main.MODIFIER_ID = APT.Infrastructure.Api.AppContext.CurrentSession.UserID;
                            main.MODIFY_TIME = DateTime.Now;
                            main.CHECK_PROJECT_ID = item.CHECK_PROJECT_ID;
                            main.CHECK_PROJECT_PROJECT_CATEGORY_ID = item.CHECK_PROJECT_PROJECT_CATEGORY_ID;
                            main.CHECK_PROJECT_CATEGORY_ID = item.CHECK_PROJECT_CATEGORY_ID;
                            main.CHECK_QUESTION_ID = item.CHECK_QUESTION_ID;
                            main.RISK_AREA_ID = item.RISK_AREA_ID;
                            main.QUESTION_LEVEL = item.QUESTION_LEVEL.HasValue ? item.QUESTION_LEVEL.Value : main.QUESTION_LEVEL;
                            main.SERIOUS_RISK = main.QUESTION_LEVEL == 10 ? 1 : 0;
                            main.CHECKCONTENT = item.CHECKCONTENT;
                            main.CHECKPROOF = item.CHECKPROOF;
                            listUpdateMain.Add(main);
                        }
                    }
                    else
                    {
                        //手动修改 并未实际修改
                        item.ISMAINCHANGE = false;
                        listCheckDetail.Add(item);//实质没有修改
                    }
                    #endregion
                }
                #endregion
            }
            entity.STATECHECK = STATECHECK.Archived;
            //给制表人发送待办
            if (entity.RISKSTATE == 10 && entity.USERID_DOPLAN.HasValue)
            {
                //检查发现问题问题 走隐患上报
                //最后时间是今天
                DateTime dtTimeOut = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd 23:59:59"));
                if (entity.Nav_User == null)
                    entity.Nav_User = GetEntity(entity.USERID_DOPLAN.Value);
                //给 表单制定人 添加待办
                //NotificationTaskService.SendNotificationTask("隐患待上报:" + entity.NAME, modelSub.ID, entity.ORG_ID, entity.USERID_DOPLAN.Value, entity.Nav_User.NAME, DateTime.Now, dtTimeOut, 0, "BS006", () =>
                //  {
                //      UpdateEntityNoCommit(entity);//修改隐患
                //      UpdateEntity(modelSub);//添加隐患上报
                //  });
                NotificationTaskService.SendNotificationTask("隐患待上报:" + entity.NAME.Replace("安全检查:", ""), entity.ID, entity.ORG_ID, entity.USERID_DOPLAN.Value, entity.Nav_User.NAME, DateTime.Now, dtTimeOut, 0, "BS006", () =>
                {
                    UpdateEntityNoCommit(entity);//修改隐患 //UpdateEntity(modelSub);//添加隐患上报
                    if (listCheckMain.Count > 0)//添加组合数据   修改的安全库、隐患库
                        BantchSaveEntityNoCommit(listCheckMain);
                    if (listCheckMainDep.Count > 0)//添加组合数据   修改的安全库、隐患库
                        BantchSaveEntityNoCommit(listCheckMainDep);
                    if (listCheckDetail != null && listCheckDetail.Any())//修改检查明细   MainID   ISMAINCHANGE
                        BantchUpdateEntityNoCommit(listCheckDetail);
                    if (listUpdateMain != null && listUpdateMain.Any())//安全检查库修改不可用
                        BantchUpdateEntityNoCommit(listUpdateMain);
                });
            }
            else
            {
                //检查没问题 直接结束 安全检查
                this.UnifiedCommit(() =>
                {
                    if (entity != null)
                        UpdateEntityNoCommit(entity);   //保存主表
                    if (listCheckMain.Count > 0)//添加组合数据   修改的安全库、隐患库
                        BantchSaveEntityNoCommit(listCheckMain);
                    if (listCheckMainDep.Count > 0)//添加组合数据   修改的安全库、隐患库
                        BantchSaveEntityNoCommit(listCheckMainDep);
                    if (listCheckDetail != null && listCheckDetail.Any())//修改检查明细   MainID   ISMAINCHANGE
                        BantchUpdateEntityNoCommit(listCheckDetail);
                    if (listUpdateMain != null && listUpdateMain.Any())//安全检查库修改不可用
                        BantchUpdateEntityNoCommit(listUpdateMain);
                });
            }
            return true;
        }
        /// 
        /// 审批流回调
        /// 
        /// 
        ///  
        private bool CheckPlanAuditEnd(string id)
        {
            var entity = GetEntity(id);
            // 1、审批记录单 判断审批结果 修改安全检查表制定的单审批状态
            T_PF_APPROVE modelApprove = this.GetEntity(e => e.DATA_ID == Guid.Parse(id) && e.APPROVE_CODE == "BS032_SHOWPRINT");
            entity.APPROVE_ID = modelApprove.ID;
            if (modelApprove.APPROVE_STATUS == 10)
            {
                //已完成
                entity.STATUSPLAN = (int)HMAuditStatusEnmu.归档;
            }
            else if (modelApprove.APPROVE_STATUS == 20)
            {
                //已驳回  修改审核ID信息 和处理状态
                entity.STATUSPLAN = (int)HMAuditStatusEnmu.审批驳回;
                this.UnifiedCommit(() =>
                {
                    if (entity != null)
                        UpdateEntityNoCommit(entity);   //保存主表
                });
                return true;
            }
            var orgId = APT.Infrastructure.Api.AppContext.CurrentSession.OrgId;
            //2、添加安全检查填写表单(配置)  BS034
            //3、给被安排检查的人去添加 代办事项 通知去安检
            //查找所有本次安检的人员
            var CheckUser = this.GetEntities(e => !e.IS_DELETED && e.SAFE_CHECK_ID == entity.ID, null, new string[] { "Nav_User" }).Select(e => e.Nav_User).Distinct(e => e.ID).ToList();
            List listUserId = new List();
            List listUserName = new List();
            for (int i = 0; i < CheckUser.Count; i++)
            {
                listUserId.Add(CheckUser[i].ID);
                listUserName.Add(CheckUser[i].NAME);
            }
            //直接发送检查记录
            //修改为  发送检查通知  检查人 查看后 再收到检查记录表
            entity.CHECKFINISHINTTIME = DateTime.Now;
            if (!entity.CHECKTIME.HasValue || !entity.PLAN_SET_ID.HasValue || entity.CHECKTIME.Value.Date == DateTime.Now.Date)
            {
                entity.ISCHECKFINISHINTTIME = true;
            }
            else
            {
                var plan = GetEntity(entity.PLAN_SET_ID.Value);
                //查询 时间频率对应最后时间
                DateTime dtEnd = SafeCheckService.GetEndTime((BSPLANCHECKFREQUENCYEnum)plan.PLANCHECKFREQUENCY, entity.CHECKTIME.Value);
                if (dtEnd >= DateTime.Now)
                    entity.ISCHECKFINISHINTTIME = true;
                else
                    entity.ISCHECKFINISHINTTIME = false;
            }
            if (listUserId.Count > 0)
            {
                entity.STATUCHECK = (int)HMAuditStatusEnmu.确认中;//给验收人 发送确认通知
                DateTime dtTimeOut = NotificationTaskService.GetTaskEndTime(FMTASKTYPE.BS_SafeCheck_Make_Check, entity.ORG_ID.Value, DateTime.Now, null, entity.CHECKTIME);// entity.LIMITDATETIME
                //最后时间是今天
                //DateTime dtTimeOut = DateTime.Now.Date.AddDays(1).AddSeconds(-1);
                //Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd 23:59:59"));
                ////给 T_FM_NOTIFICATION_TASK 添加实体
                ////只是通知,不需要表单
                //NotificationTaskService.SendNotificationTask(entity.NAME, entity.ID, orgId, listUserId, listUserName, DateTime.Now, dtTimeOut, 0, "BS034", () =>
                //{
                //    UpdateEntityNoCommit(entity);
                //});
                List listUserIDDone = new List();//需要默认处理的待办
                #region     制表确认  默认处理
                if (APT.Infrastructure.Api.AppContext.CurrentSession.UserID.HasValue)
                {
                    listUserIDDone.Add(APT.Infrastructure.Api.AppContext.CurrentSession.UserID.Value);
                }
                if (entity.USERID_DOPLAN.HasValue)
                {
                    if (!listUserIDDone.Contains(entity.USERID_DOPLAN.Value))
                    {
                        listUserIDDone.Add(entity.USERID_DOPLAN.Value);
                    }
                }
                #endregion
                List listUserCheck = null;
                if (entity.USERID_DOPLAN.HasValue && listUserId.Contains(entity.USERID_DOPLAN.Value))
                {
                    #region 旧方法
                    ////如果检查人员 包含 制表人 
                    //listUserCheck = this.GetEntities(e => !e.IS_DELETED && e.SAFE_CHECK_ID == entity.ID && e.USER_ID == entity.USERID_DOPLAN.Value); //如果是主要检查人 修改为已 确认
                    //if (listUserCheck != null && listUserCheck.Any())
                    //{
                    //    foreach (var item in listUserCheck)
                    //    {
                    //        item.SAFECHECKSTATE = (int)SAFECHECKSTATEEnum.viewDoneSign;
                    //        if (item.ISMAINCHECK)
                    //        {
                    //            item.ISCHECK = true;//检查结果确认
                    //            item.CHECKTIME = DateTime.Now;
                    //        }
                    //    }
                    //} 
                    #endregion
                    #region    新方法   主要处理 默认 【制表确认】
                    //如果检查人员 包含 制表人 
                    var listUserAll = this.GetEntities(e => !e.IS_DELETED && e.SAFE_CHECK_ID == entity.ID); //如果是主要检查人 修改为已 确认
                    foreach (var item in listUserAll)
                    {
                        if (item.SAFECHECKSTATE.HasValue && item.SAFECHECKSTATE == 80)//已经检查过了 待办消息默认审批通过
                        {
                            listUserIDDone.Add(item.USER_ID);
                        }
                    }
                    if (listUserAll != null && listUserAll.Any())
                    {
                        foreach (var item in listUserAll)
                        {
                            //if (item.USER_ID == entity.USERID_DOPLAN.Value)
                            if (listUserIDDone.Contains(item.USER_ID))
                            {
                                if (item.SAFECHECKSTATE < (int)SAFECHECKSTATEEnum.viewDoneSign)
                                {
                                    item.SAFECHECKSTATE = (int)SAFECHECKSTATEEnum.viewDoneSign;
                                }
                                //item.SAFECHECKSTATE = (int)SAFECHECKSTATEEnum.viewDoneSign;
                                if (item.ISMAINCHECK)
                                {
                                    item.ISCHECK = true;//检查结果确认
                                    item.CHECKTIME = DateTime.Now;
                                }
                                if (listUserCheck == null)
                                {
                                    listUserCheck = new List();
                                }
                                listUserCheck.Add(item);
                            }
                            //else
                            //{
                            //    //判断处理待办
                            //    if (item.ISCHECK && !listUserIDDone.Contains(item.USER_ID))
                            //    {
                            //        listUserIDDone.Add(item.USER_ID);
                            //    }
                            //}
                        }
                    }
                    #endregion
                }
                //BS034_SHOWPRINT=> BS032_SHOWPRINT
                NotificationTaskService.SendNotificationTask((entity.NAME + "-确认"), entity.ID, orgId, listUserId, listUserName, DateTime.Now, dtTimeOut, 0, "BS032_SHOWPRINT", () =>
                {
                    UpdateEntityNoCommit(entity);
                    if (listUserCheck != null && listUserCheck.Any())
                    {
                        BantchSaveEntityNoCommit(listUserCheck);
                    }
                }, "", listUserIDDone);
            }
            return true;
        }
        #endregion
        #region   FO
        /// 
        /// 回调函数
        /// 
        /// 
        ///  
        private bool BackUpdate_FOCrucialLicenseJobOutsource(string id)
        {
            //var entity = this.GetEntity(id, false, "Nav_OperationStep", "Nav_ApplyUser", "Nav_CrucialLicensePerson");
            var entity = this.GetEntity(id, new string[] { "Nav_OperationStep", "Nav_ApplyUser", "Nav_CrucialLicensePerson" });// wyw 
            entity.IS_PUBLISH = (int)FOPreMeetingStatusEnum.归档;
            //触发技术交底表
            var tech = new T_FO_TECH_DISCLOSURE_FROM();
            var techUsers = new List();
            var notices = new List();
            var techForm = this.GetEntity(t => t.JOB_NAME_ID == entity.ID);
            if (techForm == null)
            {
                //取审批流水码
                var sysFilter = new SystemCodeFilter();
                sysFilter.CodeType = (int)PFCodeRuleType.技术交底表编号;
                sysFilter.Count = 1;
                sysFilter.OrgId = entity.ORG_ID;
                var codes = CodeRuleService.NewGenSerial(sysFilter);
                var codeList = codes.Split(new char[] { ',' });
                //主表
                tech.CODE = codeList[0];
                tech.ORG_ID = entity.ORG_ID;
                tech.OPERATION_STEP_ID = entity.OPERATION_STEP_ID;
                tech.JOB_NAME_OUTSOURCE_ID = entity.ID;
                tech.JOB_LOCATION = entity.JOB_LOCATION;
                tech.DISCLOSURE_PERSON_ID = entity.APPLY_USER_ID;
                tech.IS_AUTO = (int)ISImportantEnum.是;
                tech.IS_OUTSOURCE = true;
                tech.RELATED_ID = entity.RELATED_ID;
                //if (entity.MONITOR_USER_ID != null)
                //{
                //    T_FO_TECH_DISCLOSURE_PERSON person = new T_FO_TECH_DISCLOSURE_PERSON();
                //    person.ORG_ID = entity.ORG_ID;
                //    person.USER_ID = entity.MONITOR_USER_ID;
                //    person.TECH_DISCLOSURE_FROM_ID = tech.ID;
                //    person.CREATER_ID = entity.CREATER_ID;
                //    techUsers.Add(person);
                //}
                if (entity.Nav_CrucialLicensePerson != null && entity.Nav_CrucialLicensePerson.Any())
                {
                    entity.Nav_CrucialLicensePerson.ForEach(t =>
                    {
                        T_FO_TECH_DISCLOSURE_PERSON person = new T_FO_TECH_DISCLOSURE_PERSON();
                        person.ORG_ID = t.ORG_ID;
                        person.RELATED_USER_ID = t.USER_ID;
                        person.TECH_DISCLOSURE_FROM_ID = tech.ID;
                        person.CREATER_ID = t.CREATER_ID;
                        techUsers.Add(person);
                    });
                }
                var user = this.GetEntity(t => t.ENABLE_STATUS == (int)FMEnableStatusEnum.启用 && t.ID == entity.APPLY_USER_ID);
                //发消息
                DateTime dtEnd = NotificationTaskService.GetTaskEndTime(FMTASKTYPE.JobSite, entity.ORG_ID.Value, DateTime.Now, null, null);
                notices.Add(NotificationTaskService.InsertUserNoticeTaskModel("安全技术交底表(外包)", tech.ID, entity.ORG_ID, user.ID, user.NAME, DateTime.Now,
               entity.JOB_DATE.Value, (int)FMNoticeTypeEnum.消息, "FO019"));
            }
            UnifiedCommit(() =>
            {
                if (entity != null)
                    this.UpdateEntityNoCommit(entity);
                if (notices != null && notices.Any())
                    this.BantchSaveEntityNoCommit(notices);
                if (tech != null)
                    this.UpdateEntityNoCommit(tech);
                if (techUsers != null && techUsers.Any())
                    this.BantchSaveEntityNoCommit(techUsers);
            });
            return true;
        }
        /// 
        /// 回调函数
        /// 
        /// 
        ///  
        private bool BackUpdate(string id)
        {
            //var entity = this.GetEntity(id, false, "Nav_OperationStep", "Nav_ApplyUser", "Nav_CrucialLicensePerson");
            var entity = this.GetEntity(id, new string[] { "Nav_OperationStep", "Nav_ApplyUser", "Nav_CrucialLicensePerson" });// wyw 
            entity.IS_PUBLISH = (int)FOPreMeetingStatusEnum.签到中;
            //触发技术交底表
            var tech = new T_FO_TECH_DISCLOSURE_FROM();
            var techUsers = new List();
            var notices = new List();
            var techForm = this.GetEntity(t => t.JOB_NAME_ID == entity.ID);
            if (techForm == null)
            {
                //取审批流水码
                var sysFilter = new SystemCodeFilter();
                sysFilter.CodeType = (int)PFCodeRuleType.技术交底表编号;
                sysFilter.Count = 1;
                sysFilter.OrgId = entity.ORG_ID;
                var codes = CodeRuleService.NewGenSerial(sysFilter);
                var codeList = codes.Split(new char[] { ',' });
                //主表
                tech.CODE = codeList[0];
                tech.ORG_ID = entity.ORG_ID;
                tech.OPERATION_STEP_ID = entity.OPERATION_STEP_ID;
                tech.JOB_NAME_ID = entity.ID;
                tech.JOB_LOCATION = entity.JOB_LOCATION;
                tech.DISCLOSURE_PERSON_ID = entity.APPLY_USER_ID;
                tech.IS_AUTO = (int)ISImportantEnum.是;
                tech.IS_OUTSOURCE = false;
                tech.RELATED_ID = null;
                if (entity.MONITOR_USER_ID != null)
                {
                    T_FO_TECH_DISCLOSURE_PERSON person = new T_FO_TECH_DISCLOSURE_PERSON();
                    person.ORG_ID = entity.ORG_ID;
                    person.USER_ID = entity.MONITOR_USER_ID;
                    person.TECH_DISCLOSURE_FROM_ID = tech.ID;
                    person.CREATER_ID = entity.CREATER_ID;
                    techUsers.Add(person);
                }
                if (entity.Nav_CrucialLicensePerson != null && entity.Nav_CrucialLicensePerson.Any())
                {
                    entity.Nav_CrucialLicensePerson.ForEach(t =>
                    {
                        T_FO_TECH_DISCLOSURE_PERSON person = new T_FO_TECH_DISCLOSURE_PERSON();
                        person.ORG_ID = t.ORG_ID;
                        person.USER_ID = t.USER_ID;
                        person.TECH_DISCLOSURE_FROM_ID = tech.ID;
                        person.CREATER_ID = t.CREATER_ID;
                        techUsers.Add(person);
                    });
                }
                techUsers = techUsers.Distinct(t => t.USER_ID).ToList();
                var userIds = entity.Nav_CrucialLicensePerson.Select(t => (Guid)t.USER_ID).Distinct().ToList();
                //var userIds = techUsers.Where(u=>u.USER_ID != entity.MONITOR_USER_ID).Select(t=>(Guid)t.USER_ID).ToList();
                //userIds.Add((Guid)entity.APPLY_USER_ID);
                //userIds = userIds.Distinct().ToList();
                var UserNames = new List();
                var user = this.GetEntities(t => t.ENABLE_STATUS == (int)FMEnableStatusEnum.启用 && (userIds.Contains(t.ID) || t.ID == entity.APPLY_USER_ID), new BaseFilter(entity.ORG_ID));
                var userFirst = user.FirstOrDefault(t => t.ID == entity.APPLY_USER_ID);
                foreach (var u in userIds)
                {
                    var current = user.FirstOrDefault(t => t.ID == u);
                    UserNames.Add(current?.NAME);
                }
                //DateTime dtEnd = NotificationTaskService.GetTaskEndTime(FMTASKTYPE.JobSite, entity.ORG_ID.Value, DateTime.Now, null, null);
                if (userFirst != null)
                {
                    notices.Add(NotificationTaskService.InsertUserNoticeTaskModel("安全技术交底表(" + entity.JOB_DATE.Value.ToShortDateString().Replace("/", "") + ")", tech.ID, entity.ORG_ID, entity.APPLY_USER_ID.Value, userFirst?.NAME, DateTime.Now,
                    entity.JOB_DATE.Value, (int)FMNoticeTypeEnum.消息, "FO019"));
                }
                if (userIds != null && userIds.Any())
                {
                    notices.AddRange(NotificationTaskService.InsertUserNoticeTaskModels("关键作业/许可作业工作票确认(" + entity.JOB_DATE.Value.ToShortDateString().Replace("/", "") + ")", entity.ID, entity.ORG_ID, userIds, UserNames, DateTime.Now,
                    entity.JOB_DATE.Value, (int)FMNoticeTypeEnum.消息, "FO017_SHOWPRINT"));
                }
            }
            else
            {
                entity.IS_PUBLISH = (int)FOPreMeetingStatusEnum.归档;
                tech = null; techUsers = null; notices = null;
            }
            UnifiedCommit(() =>
            {
                if (entity != null)
                    this.UpdateEntityNoCommit(entity);
                if (notices != null && notices.Any())
                    this.BantchSaveEntityNoCommit(notices);
                if (tech != null)
                    this.UpdateEntityNoCommit(tech);
                if (techUsers != null && techUsers.Any())
                    this.BantchSaveEntityNoCommit(techUsers);
            });
            return true;
        }
        /// 
        /// 关键许可工作票
        /// 
        /// 
        ///  
        private bool BackUpdateNew_FOCrucialLicenseJob(T_PF_APPROVE entityInt, T_PF_APPROVE modelApp, List listAppDetail, T_FM_NOTIFICATION_TASK taskFinish, List listTaskNext, bool isLast = false)
        {
            #region     审批公用
            if (modelApp == null)
            {
                string taskCodeCheck = String.Empty;
                bool result = GetApproject2(entityInt, ref modelApp, ref listAppDetail, ref taskFinish, ref taskCodeCheck, ref isLast, ref listTaskNext);
                if (!result)
                {
                    throw new Exception("审批失败!");
                }
            }
            #endregion
            if (!isLast)
            {
                this.UnifiedCommit(() =>
                {
                    if (modelApp != null)
                        UpdateEntityNoCommit(modelApp);   //保存主表
                    if (listAppDetail.Count > 0)//添加组合数据   修改的安全库、隐患库
                        BantchSaveEntityNoCommit(listAppDetail);
                    if (taskFinish != null)
                        UpdateEntityNoCommit(taskFinish);
                    if (listTaskNext != null && listTaskNext.Count > 0)
                        BantchSaveEntityNoCommit(listTaskNext);
                });
            }
            else
            {
                var entity = this.GetEntity(modelApp.DATA_ID, new string[] { "Nav_OperationStep", "Nav_ApplyUser", "Nav_CrucialLicensePerson" });// wyw 
                entity.IS_PUBLISH = (int)FOPreMeetingStatusEnum.签到中;
                //触发技术交底表
                var tech = new T_FO_TECH_DISCLOSURE_FROM();
                var techUsers = new List();
                var notices = new List();
                var techForm = this.GetEntity(t => t.JOB_NAME_ID == entity.ID);
                if (techForm == null)
                {
                    //取审批流水码
                    var sysFilter = new SystemCodeFilter();
                    sysFilter.CodeType = (int)PFCodeRuleType.技术交底表编号;
                    sysFilter.Count = 1;
                    sysFilter.OrgId = entity.ORG_ID;
                    var codes = CodeRuleService.NewGenSerial(sysFilter);
                    var codeList = codes.Split(new char[] { ',' });
                    //主表
                    tech.CODE = codeList[0];
                    tech.ORG_ID = entity.ORG_ID;
                    tech.OPERATION_STEP_ID = entity.OPERATION_STEP_ID;
                    tech.JOB_NAME_ID = entity.ID;
                    tech.JOB_LOCATION = entity.JOB_LOCATION;
                    tech.DISCLOSURE_PERSON_ID = entity.APPLY_USER_ID;
                    tech.IS_AUTO = (int)ISImportantEnum.是;
                    tech.IS_OUTSOURCE = false;
                    tech.RELATED_ID = null;
                    if (entity.MONITOR_USER_ID != null)
                    {
                        T_FO_TECH_DISCLOSURE_PERSON person = new T_FO_TECH_DISCLOSURE_PERSON();
                        person.ORG_ID = entity.ORG_ID;
                        person.USER_ID = entity.MONITOR_USER_ID;
                        person.TECH_DISCLOSURE_FROM_ID = tech.ID;
                        person.CREATER_ID = entity.CREATER_ID;
                        techUsers.Add(person);
                    }
                    if (entity.Nav_CrucialLicensePerson != null && entity.Nav_CrucialLicensePerson.Any())
                    {
                        entity.Nav_CrucialLicensePerson.ForEach(t =>
                        {
                            T_FO_TECH_DISCLOSURE_PERSON person = new T_FO_TECH_DISCLOSURE_PERSON();
                            person.ORG_ID = t.ORG_ID;
                            person.USER_ID = t.USER_ID;
                            person.TECH_DISCLOSURE_FROM_ID = tech.ID;
                            person.CREATER_ID = t.CREATER_ID;
                            techUsers.Add(person);
                        });
                    }
                    techUsers = techUsers.Distinct(t => t.USER_ID).ToList();
                    var userIds = entity.Nav_CrucialLicensePerson.Select(t => (Guid)t.USER_ID).Distinct().ToList();
                    //var userIds = techUsers.Where(u=>u.USER_ID != entity.MONITOR_USER_ID).Select(t=>(Guid)t.USER_ID).ToList();
                    //userIds.Add((Guid)entity.APPLY_USER_ID);
                    //userIds = userIds.Distinct().ToList();
                    var UserNames = new List();
                    var user = this.GetEntities(t => t.ENABLE_STATUS == (int)FMEnableStatusEnum.启用 && (userIds.Contains(t.ID) || t.ID == entity.APPLY_USER_ID), new BaseFilter(entity.ORG_ID));
                    var userFirst = user.FirstOrDefault(t => t.ID == entity.APPLY_USER_ID);
                    foreach (var u in userIds)
                    {
                        var current = user.FirstOrDefault(t => t.ID == u);
                        UserNames.Add(current?.NAME);
                    }
                    //DateTime dtEnd = NotificationTaskService.GetTaskEndTime(FMTASKTYPE.JobSite, entity.ORG_ID.Value, DateTime.Now, null, null);
                    if (userFirst != null)
                    {
                        notices.Add(NotificationTaskService.InsertUserNoticeTaskModel("安全技术交底表(" + entity.JOB_DATE.Value.ToShortDateString().Replace("/", "") + ")", tech.ID, entity.ORG_ID, entity.APPLY_USER_ID.Value, userFirst?.NAME, DateTime.Now,
                        entity.JOB_DATE.Value, (int)FMNoticeTypeEnum.消息, "FO019"));
                    }
                    if (userIds != null && userIds.Any())
                    {
                        notices.AddRange(NotificationTaskService.InsertUserNoticeTaskModels("关键作业/许可作业工作票确认(" + entity.JOB_DATE.Value.ToShortDateString().Replace("/", "") + ")", entity.ID, entity.ORG_ID, userIds, UserNames, DateTime.Now,
                        entity.JOB_DATE.Value, (int)FMNoticeTypeEnum.消息, "FO017_SHOWPRINT"));
                    }
                }
                else
                {
                    entity.IS_PUBLISH = (int)FOPreMeetingStatusEnum.归档;
                    tech = null; techUsers = null; notices = null;
                }
                UnifiedCommit(() =>
                {
                    if (modelApp != null)
                        UpdateEntityNoCommit(modelApp);   //保存主表
                    if (listAppDetail.Count > 0)//添加组合数据   修改的安全库、隐患库
                        BantchSaveEntityNoCommit(listAppDetail);
                    if (taskFinish != null)
                        UpdateEntityNoCommit(taskFinish);
                    if (listTaskNext != null && listTaskNext.Count > 0)
                        BantchSaveEntityNoCommit(listTaskNext);
                    if (entity != null)
                        this.UpdateEntityNoCommit(entity);
                    if (notices != null && notices.Any())
                        this.BantchSaveEntityNoCommit(notices);
                    if (tech != null)
                        this.UpdateEntityNoCommit(tech);
                    if (techUsers != null && techUsers.Any())
                        this.BantchSaveEntityNoCommit(techUsers);
                });
            }
            return true;
        }
        /// 
        /// 关键许可工作票外包
        /// 
        /// 
        ///  
        private bool BackUpdateNew_FOCrucialLicenseJobOutsource(T_PF_APPROVE entityInt, T_PF_APPROVE modelApp, List listAppDetail, T_FM_NOTIFICATION_TASK taskFinish, List listTaskNext, bool isLast = false)
        {
            #region     审批公用
            if (modelApp == null)
            {
                string taskCodeCheck = String.Empty;
                bool result = GetApproject2(entityInt, ref modelApp, ref listAppDetail, ref taskFinish, ref taskCodeCheck, ref isLast, ref listTaskNext);
                if (!result)
                {
                    throw new Exception("审批失败!");
                }
            }
            #endregion
            if (!isLast)
            {
                this.UnifiedCommit(() =>
                {
                    if (modelApp != null)
                        UpdateEntityNoCommit(modelApp);   //保存主表
                    if (listAppDetail.Count > 0)//添加组合数据   修改的安全库、隐患库
                        BantchSaveEntityNoCommit(listAppDetail);
                    if (taskFinish != null)
                        UpdateEntityNoCommit(taskFinish);
                    if (listTaskNext != null && listTaskNext.Count > 0)
                        BantchSaveEntityNoCommit(listTaskNext);
                });
            }
            else
            {
                var entity = this.GetEntity(modelApp.DATA_ID, new string[] { "Nav_OperationStep", "Nav_ApplyUser", "Nav_CrucialLicensePerson" });// wyw 
                entity.IS_PUBLISH = (int)FOPreMeetingStatusEnum.归档;
                //触发技术交底表
                var tech = new T_FO_TECH_DISCLOSURE_FROM();
                var techUsers = new List();
                var notices = new List();
                var techForm = this.GetEntity(t => t.JOB_NAME_OUTSOURCE_ID == entity.ID);
                if (techForm == null)
                {
                    //取审批流水码
                    var sysFilter = new SystemCodeFilter();
                    sysFilter.CodeType = (int)PFCodeRuleType.技术交底表编号;
                    sysFilter.Count = 1;
                    sysFilter.OrgId = entity.ORG_ID;
                    var codes = CodeRuleService.NewGenSerial(sysFilter);
                    var codeList = codes.Split(new char[] { ',' });
                    //主表
                    tech.CODE = codeList[0];
                    tech.ORG_ID = entity.ORG_ID;
                    tech.OPERATION_STEP_ID = entity.OPERATION_STEP_ID;
                    tech.JOB_NAME_OUTSOURCE_ID = entity.ID;
                    tech.JOB_LOCATION = entity.JOB_LOCATION;
                    tech.DISCLOSURE_PERSON_ID = entity.APPLY_USER_ID;
                    tech.IS_AUTO = (int)ISImportantEnum.是;
                    tech.IS_OUTSOURCE = true;
                    tech.RELATED_ID = entity.RELATED_ID;
                    //if (entity.MONITOR_USER_ID != null)
                    //{
                    //    T_FO_TECH_DISCLOSURE_PERSON person = new T_FO_TECH_DISCLOSURE_PERSON();
                    //    person.ORG_ID = entity.ORG_ID;
                    //    person.USER_ID = entity.MONITOR_USER_ID;
                    //    person.TECH_DISCLOSURE_FROM_ID = tech.ID;
                    //    person.CREATER_ID = entity.CREATER_ID;
                    //    techUsers.Add(person);
                    //}
                    if (entity.Nav_CrucialLicensePerson != null && entity.Nav_CrucialLicensePerson.Any())
                    {
                        entity.Nav_CrucialLicensePerson.ForEach(t =>
                        {
                            T_FO_TECH_DISCLOSURE_PERSON person = new T_FO_TECH_DISCLOSURE_PERSON();
                            person.ORG_ID = t.ORG_ID;
                            person.RELATED_USER_ID = t.USER_ID;
                            person.TECH_DISCLOSURE_FROM_ID = tech.ID;
                            person.CREATER_ID = t.CREATER_ID;
                            techUsers.Add(person);
                        });
                    }
                    //techUsers = techUsers.Distinct(t => t.USER_ID).ToList();
                    //var userIds = techUsers.Where(u => u.USER_ID != entity.MONITOR_USER_ID).Select(t => (Guid)t.USER_ID).ToList();
                    //userIds.Add((Guid)entity.APPLY_USER_ID);
                    var UserNames = new List();
                    var user = this.GetEntity(t => t.ENABLE_STATUS == (int)FMEnableStatusEnum.启用 && t.ID == entity.APPLY_USER_ID);
                    //var userFirst = user.FirstOrDefault(t => t.ID == entity.APPLY_USER_ID);
                    //var identUserIds = userIds.Where(t => t != entity.APPLY_USER_ID).Distinct().ToList();
                    //foreach (var u in identUserIds)
                    //{
                    //    var current = user.FirstOrDefault(t => t.ID == u);
                    //    UserNames.Add(current?.NAME);
                    //}
                    //DateTime dtEnd = NotificationTaskService.GetTaskEndTime(FMTASKTYPE.JobSite, entity.ORG_ID.Value, DateTime.Now, null, null);
                    if (user != null)
                    {
                        notices.Add(NotificationTaskService.InsertUserNoticeTaskModel("安全技术交底表外包(" + entity.JOB_DATE.Value.ToShortDateString().Replace("/", "") + ")", tech.ID, entity.ORG_ID, entity.APPLY_USER_ID.Value, user?.NAME, DateTime.Now,
                        entity.JOB_DATE.Value, (int)FMNoticeTypeEnum.消息, "FO019"));
                    }
                    //if (identUserIds != null && identUserIds.Any())
                    //{
                    //    notices.AddRange(NotificationTaskService.InsertUserNoticeTaskModels("关键作业/许可作业工作票确认(" + entity.JOB_DATE.Value.ToShortDateString().Replace("/", "") + ")", entity.ID, entity.ORG_ID, identUserIds, UserNames, DateTime.Now,
                    //    entity.JOB_DATE.Value, (int)FMNoticeTypeEnum.消息, "FO017_SHOWPRINT"));
                    //}
                }
                else
                {
                    tech = null; techUsers = null; notices = null;
                }
                UnifiedCommit(() =>
                {
                    if (modelApp != null)
                        UpdateEntityNoCommit(modelApp);   //保存主表
                    if (listAppDetail.Count > 0)//添加组合数据   修改的安全库、隐患库
                        BantchSaveEntityNoCommit(listAppDetail);
                    if (taskFinish != null)
                        UpdateEntityNoCommit(taskFinish);
                    if (listTaskNext != null && listTaskNext.Count > 0)
                        BantchSaveEntityNoCommit(listTaskNext);
                    if (entity != null)
                        this.UpdateEntityNoCommit(entity);
                    if (notices != null && notices.Any())
                        this.BantchSaveEntityNoCommit(notices);
                    if (tech != null)
                        this.UpdateEntityNoCommit(tech);
                    if (techUsers != null && techUsers.Any())
                        this.BantchSaveEntityNoCommit(techUsers);
                });
            }
            return true;
        }
        /// 
        /// 一般作业活动记录
        /// 
        /// 
        ///  
        private bool BackUpdateNew_FOJobEventRecord(T_PF_APPROVE entityInt, T_PF_APPROVE modelApp, List listAppDetail, T_FM_NOTIFICATION_TASK taskFinish, List listTaskNext, bool isLast = false)
        {
            #region     审批公用
            if (modelApp == null)
            {
                string taskCodeCheck = String.Empty;
                bool result = GetApproject2(entityInt, ref modelApp, ref listAppDetail, ref taskFinish, ref taskCodeCheck, ref isLast, ref listTaskNext);
                if (!result)
                {
                    throw new Exception("审批失败!");
                }
            }
            #endregion
            if (!isLast)
            {
                this.UnifiedCommit(() =>
                {
                    if (modelApp != null)
                        UpdateEntityNoCommit(modelApp);   //保存主表
                    if (listAppDetail.Count > 0)//添加组合数据   修改的安全库、隐患库
                        BantchSaveEntityNoCommit(listAppDetail);
                    if (taskFinish != null)
                        UpdateEntityNoCommit(taskFinish);
                    if (listTaskNext != null && listTaskNext.Count > 0)
                        BantchSaveEntityNoCommit(listTaskNext);
                });
            }
            else
            {
                var entity = this.GetEntity(modelApp.DATA_ID, "Nav_Details");
                entity.FORM_STATUS = (int)FOTeamActivityState.已归档;
                UnifiedCommit(() =>
                {
                    if (modelApp != null)
                        UpdateEntityNoCommit(modelApp);   //保存主表
                    if (listAppDetail.Count > 0)//添加组合数据   修改的安全库、隐患库
                        BantchSaveEntityNoCommit(listAppDetail);
                    if (taskFinish != null)
                        UpdateEntityNoCommit(taskFinish);
                    if (listTaskNext != null && listTaskNext.Count > 0)
                        BantchSaveEntityNoCommit(listTaskNext);
                    if (entity != null)
                        this.UpdateEntityNoCommit(entity);
                });
            }
            return true;
        }
        #endregion
        #region   HM && PT && PE && PR
        #region   HMR
        private bool BackUpdate_FOJobEventRecord(string id)
        {
            var entity = this.GetEntity(id, "Nav_Details");
            entity.FORM_STATUS = (int)FOTeamActivityState.已归档;
            UnifiedCommit(() =>
            {
                if (entity != null)
                    this.UpdateEntityNoCommit(entity);
            });
            return true;
        }
       
        /// 
        /// 返回所有上级部门节点
        /// 
        /// 
        /// 
        /// 
        public void GetParentDepartmentIds(Guid orgId, List listDepIDInt, ref List departmentIdPs)
        {
            var listDep = GetEntities(e => e.ORG_ID == orgId && !e.IS_DELETED && listDepIDInt.Contains(e.ID));
            if (listDep != null && listDep.Any())
            {
                listDepIDInt = listDep.Where(t => t.PARENT_ID.HasValue).Select(e => e.PARENT_ID.Value).ToList();
                departmentIdPs.AddRange(listDepIDInt);
                GetParentDepartmentIds(orgId, listDepIDInt, ref departmentIdPs);
            }
        }
       
        private bool BackUpdate_SCStandardCreate(string id)
        {
            var content = "";
            T_SC_STANDARD_CREATE oldEntity = null;
            var entity = this.GetEntity(id, "Nav_User");
            if (entity.FILE_STATUS == SCSystemFileStatus.废除中)
            {
                content = "已废除";
                entity.STATUS = SCSystemEditStatus.已废除;
                entity.FILE_STATUS = SCSystemFileStatus.已废除;
                oldEntity = this.GetEntity(t => t.ID != entity.ID && t.CODE == entity.CODE && t.FILE_STATUS == SCSystemFileStatus.有效);
                if (oldEntity != null)
                    oldEntity.FILE_STATUS = SCSystemFileStatus.失效;
            }
            else
            {
                entity.STATUS = SCSystemEditStatus.已归档;
                entity.FILE_STATUS = SCSystemFileStatus.有效;
                if (entity.VERSION == 1)
                {
                    content = "已创建";
                }
                else
                {
                    content = "已修订";
                    oldEntity = this.GetEntity(t => t.ID != entity.ID && t.CODE == entity.CODE && t.FILE_STATUS == SCSystemFileStatus.有效);
                    if (oldEntity != null)
                        oldEntity.FILE_STATUS = SCSystemFileStatus.失效;
                }
            }
            T_FM_NOTIFICATION_TASK sendNotice = NotificationTaskService.InsertUserNoticeTaskModel("“" + entity.NAME + "”" + content + ",请召开相关培训", entity.ID, entity.ORG_ID, entity.USER_ID.Value, entity.Nav_User.NAME, DateTime.Now, DateTime.Now.AddDays(30), (int)FMNoticeTypeEnum.今日提醒, "PF135");
            if (content == "已废除")
            {
                sendNotice = null;
            }
            UnifiedCommit(() =>
            {
                if (entity != null)
                    this.UpdateEntityNoCommit(entity);
                if (oldEntity != null)
                    this.UpdateEntityNoCommit(oldEntity);
                if (sendNotice != null)
                    this.UpdateEntityNoCommit(sendNotice);
            });
            return true;
        }
        
        /// 
        /// 回调函数
        /// 
        /// 
        ///  
        private bool BackUpdate_HMCrucialTaskAnalysis(string id)
        {
            //var entity = this.GetEntity(id, false, "Nav_OperationAnalyze", "Nav_Details", "Nav_Details.Nav_OperationStep", "Nav_Details.Nav_EvaluateRisk");
            var entity = this.GetEntity(id, new string[] { "Nav_OperationAnalyze", "Nav_Details", "Nav_Details.Nav_OperationStep" });
            entity.IS_PUBLISH = FOPreMeetingStatusEnum.归档;
            entity.COMPLETE_DATE = DateTime.Now;
            //写入作业任务库
            List addOperations = new List();
            List safeConfs = new List();
            List safeMeas = new List();
            List dealMeas = new List();
            List posts = new List();
            //List areas = new List();
            List notices = new List();
            List confIds = new List();
            List measIds = new List();
            List dealIds = new List();
            List postIds = new List();
            if (entity.Nav_Details != null && entity.Nav_Details.Any())
            {
                List jobDetails = null;
                var stepIds = entity.Nav_Details.Select(t => t.OPERATION_STEP_ID).Distinct().ToList();
                if (entity.Nav_OperationAnalyze != null && entity.Nav_OperationAnalyze.JOBTASK_IDENTIFY_ID != null)
                {
                    jobDetails = this.GetEntities(t => t.JOBTASK_IDENTIFY_ID == entity.Nav_OperationAnalyze.JOBTASK_IDENTIFY_ID && stepIds.Contains(t.OPERATION_STEP_ID), new BaseFilter(entity.ORG_ID), "Nav_DetailPost").ToList();
                }
                var links = this.GetEntities(t => stepIds.Contains(t.OPERATION_STEP_ID) && t.STATUS == (int)STATUSEnum.启用 && t.IS_RUN == DisableStatusEnum.是, new BaseFilter(entity.ORG_ID), new string[] { "Nav_LinkPost", "Nav_SafeConfirms", "Nav_SafeMeasures", "Nav_DealMeasures" });
                entity.Nav_Details.ForEach(t =>
                {
                    T_HM_OPERATION_LINK operation = new T_HM_OPERATION_LINK();
                    var current = links.FirstOrDefault(x => x.OPERATION_STEP_ID == t.OPERATION_STEP_ID);//OrderByDescending(t => t.CREATE_TIME).
                    if (current != null)
                    {
                        current.CODE = entity.CODE;
                        current.NAME = "关键任务分析表回写";
                        current.OPERATION_STEP_ID = t.OPERATION_STEP_ID;
                        current.TASK_LEVEL = (int)HMTaskLevelEnum.关键任务非许可作业;
                        current.ORG_ID = entity.ORG_ID;
                        current.IS_IMPORTANT = (int)ISImportantEnum.是;
                        current.SafeConfirmsStr = t.SafeConfirmsStr;
                        current.SafeMeasuresStr = t.SafeMeasuresStr;
                        current.DealMeasuresStr = t.DealMeasuresStr;
                        current.STATUS = (int)STATUSEnum.启用;
                        current.CREATER_ID = entity.CREATER_ID;
                        current.MODIFY_TYPE = HMModifyEnum.修改;
                        current.CYCLE_TYPE = t.CYCLE_TYPE;
                        current.AUDIT_LEVEL = (int)t.AUDIT_LEVEL;
                        operation = current;
                        if (current.Nav_SafeConfirms != null && current.Nav_SafeConfirms.Any())
                        {
                            var ids = current.Nav_SafeConfirms.Select(t => t.ID).ToList();
                            confIds.AddRange(ids);
                        }
                        if (current.Nav_SafeMeasures != null && current.Nav_SafeMeasures.Any())
                        {
                            var ids = current.Nav_SafeMeasures.Select(t => t.ID).ToList();
                            measIds.AddRange(ids);
                        }
                        if (current.Nav_DealMeasures != null && current.Nav_DealMeasures.Any())
                        {
                            var ids = current.Nav_DealMeasures.Select(t => t.ID).ToList();
                            dealIds.AddRange(ids);
                        }
                        if (current.Nav_LinkPost != null && current.Nav_LinkPost.Any())
                        {
                            var ids = current.Nav_LinkPost.Select(t => t.ID).ToList();
                            postIds.AddRange(ids);
                        }
                        //if (t.AREA_ID != null && current.Nav_LinkArea != null && current.Nav_LinkArea.Any())
                        //{
                        //    var linkArea = current.Nav_LinkArea.FirstOrDefault(t => t.AREA_ID == t.AREA_ID);
                        //    if (linkArea == null)
                        //    {
                        //        T_HM_OPERATION_LINK_AREA area = new T_HM_OPERATION_LINK_AREA();
                        //        area.ORG_ID = entity.ORG_ID;
                        //        area.OPERATION_LINK_ID = current.ID;
                        //        area.AREA_ID = t.AREA_ID;
                        //        areas.Add(area);
                        //    }
                        //}
                    }
                    else
                    {
                        //主表
                        operation.CODE = entity.CODE;
                        operation.NAME = "关键任务分析表新增";
                        operation.OPERATION_STEP_ID = t.OPERATION_STEP_ID;
                        operation.TASK_LEVEL = (int)HMTaskLevelEnum.关键任务非许可作业;
                        operation.ORG_ID = entity.ORG_ID;
                        operation.IS_IMPORTANT = (int)ISImportantEnum.是;
                        operation.SafeConfirmsStr = t.SafeConfirmsStr;
                        operation.SafeMeasuresStr = t.SafeMeasuresStr;
                        operation.DealMeasuresStr = t.DealMeasuresStr;
                        operation.STATUS = (int)STATUSEnum.启用;
                        operation.CREATER_ID = entity.CREATER_ID;
                        operation.MODIFY_TYPE = HMModifyEnum.新增;
                        operation.CYCLE_TYPE = t.CYCLE_TYPE;
                        operation.AUDIT_LEVEL = (int)t.AUDIT_LEVEL;
                        var mineType = APT.Infrastructure.Api.AppContext.CurrentSession.MineType;
                        if (!string.IsNullOrEmpty(mineType))
                        {
                            operation.MineType = int.Parse(mineType.Split(",")[0]);
                        }
                        //if (t.AREA_ID != null)
                        //{
                        //    T_HM_OPERATION_LINK_AREA area = new T_HM_OPERATION_LINK_AREA();
                        //    area.ORG_ID = entity.ORG_ID;
                        //    area.OPERATION_LINK_ID = operation.ID;
                        //    area.AREA_ID = t.AREA_ID;
                        //    areas.Add(area);
                        //}
                    }
                    addOperations.Add(operation);
                    var newPostIds = jobDetails.FirstOrDefault(t => t.OPERATION_STEP_ID == operation.OPERATION_STEP_ID);
                    if (newPostIds != null && newPostIds.Nav_DetailPost != null && newPostIds.Nav_DetailPost.Any())
                    {
                        foreach (var item in newPostIds.Nav_DetailPost)
                        {
                            T_HM_OPERATION_LINK_POST post = new T_HM_OPERATION_LINK_POST();
                            post.ORG_ID = entity.ORG_ID;
                            post.OPERATION_LINK_ID = operation.ID;
                            post.POST_ID = item.POST_ID;
                            posts.Add(post);
                        }
                    }
                    if (!string.IsNullOrEmpty(t.SafeConfirmsStr))
                    {
                        var conf = t.SafeConfirmsStr.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
                        if (conf.Length > 0)
                        {
                            foreach (var c in conf)
                            {
                                T_HM_OPERATION_TASK_SAFE_CONFIRM safeConf = new T_HM_OPERATION_TASK_SAFE_CONFIRM();
                                safeConf.ORG_ID = entity.ORG_ID;
                                safeConf.OPERATION_LINK_ID = operation.ID;
                                if (c.Contains("、"))
                                {
                                    var co = c.Split(new[] { '、' }, StringSplitOptions.RemoveEmptyEntries);
                                    if (co.Length > 0)
                                    {
                                        safeConf.NAME = co[1];
                                        safeConf.NUM = int.Parse(co[0]);
                                    }
                                    else
                                    {
                                        safeConf.NAME = c;
                                        safeConf.NUM = 1;
                                    }
                                }
                                else
                                {
                                    safeConf.NAME = c;
                                    safeConf.NUM = 1;
                                }
                                safeConfs.Add(safeConf);
                            }
                        }
                    }
                    if (!string.IsNullOrEmpty(t.SafeMeasuresStr))
                    {
                        var conf = t.SafeMeasuresStr.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
                        if (conf.Length > 0)
                        {
                            foreach (var c in conf)
                            {
                                T_HM_OPERATION_TASK_SAFE_MEASURE safeConf = new T_HM_OPERATION_TASK_SAFE_MEASURE();
                                safeConf.ORG_ID = entity.ORG_ID;
                                safeConf.OPERATION_LINK_ID = operation.ID;
                                if (c.Contains("、"))
                                {
                                    var co = c.Split(new[] { '、' }, StringSplitOptions.RemoveEmptyEntries);
                                    if (co.Length > 0)
                                    {
                                        safeConf.NAME = co[1];
                                        safeConf.NUM = int.Parse(co[0]);
                                    }
                                    else
                                    {
                                        safeConf.NAME = c;
                                        safeConf.NUM = 1;
                                    }
                                }
                                else
                                {
                                    safeConf.NAME = c;
                                    safeConf.NUM = 1;
                                }
                                safeMeas.Add(safeConf);
                            }
                        }
                    }
                    if (!string.IsNullOrEmpty(t.DealMeasuresStr))
                    {
                        var conf = t.DealMeasuresStr.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
                        if (conf.Length > 0)
                        {
                            foreach (var c in conf)
                            {
                                T_HM_OPERATION_TASK_DEAL_MEASURE safeConf = new T_HM_OPERATION_TASK_DEAL_MEASURE();
                                safeConf.ORG_ID = entity.ORG_ID;
                                safeConf.OPERATION_LINK_ID = operation.ID;
                                if (c.Contains("、"))
                                {
                                    var co = c.Split(new[] { '、' }, StringSplitOptions.RemoveEmptyEntries);
                                    if (co.Length > 0)
                                    {
                                        safeConf.NAME = co[1];
                                        safeConf.NUM = int.Parse(co[0]);
                                    }
                                    else
                                    {
                                        safeConf.NAME = c;
                                        safeConf.NUM = 1;
                                    }
                                }
                                else
                                {
                                    safeConf.NAME = c;
                                    safeConf.NUM = 1;
                                }
                                dealMeas.Add(safeConf);
                            }
                        }
                    }
                    operation.IS_RUN = DisableStatusEnum.是;
                });
            }
            //自动触发文件发布
            List dataIds = new List();
            T_HM_FILE_PUBLISH publish = null;
            dataIds.Add(entity.ID);
            var license = this.GetEntity(t => t.OPERATION_ANALYZE_ID == entity.OPERATION_ANALYZE_ID);
            if (license != null)
                dataIds.Add(license.ID);
            var ordinary = this.GetEntity(t => t.OPERATION_ANALYZE_ID == entity.OPERATION_ANALYZE_ID);
            if (ordinary != null)
                dataIds.Add(ordinary.ID);
            var approve = this.GetEntities(t => dataIds.Contains(t.DATA_ID), new BaseFilter(entity.ORG_ID));
            if (approve != null && approve.Any())
            {
                bool isEnd = true;
                approve.ForEach(t =>
                {
                    if (t.APPROVE_STATUS != (int)ApproveStatus.Done)
                        isEnd = false;
                });
                if (isEnd)
                {
                    var nextCode = "";
                    var nextCodeInfo = this.GetEntities(t => !t.IS_DELETED, new BaseFilter(entity.ORG_ID)).OrderByDescending(t => t.CREATE_TIME).FirstOrDefault();
                    var year = DateTime.Now.Year;
                    var month = DateTime.Now.Month.PadLeft(2, '0');
                    var day = DateTime.Now.Day.PadLeft(2, '0');
                    if (nextCodeInfo == null)
                    {
                        nextCode = "RWFX" + year + month + day + "00001";
                    }
                    else
                    {
                        //取最后五位序列号
                        var serial = nextCodeInfo.CODE.Substring(nextCodeInfo.CODE.Length - 5);
                        //序列号+1,不足五位补0
                        var num = (int.Parse(serial) + 1).ToString().PadLeft(5, '0');
                        nextCode = "RWFX" + year + month + day + num;
                    }
                    var userId = this.GetEntity(t => t.NAME == "办公室负责人")?.USER_ID;
                    if (userId != null)
                    {
                        //文件发布表
                        publish = new T_HM_FILE_PUBLISH();
                        publish.NAME = "";
                        publish.CODE = nextCode;
                        publish.LICENSE_ANALYSIS_ID = license?.ID;
                        publish.CRUCIAL_TASK_ANALYSIS_ID = entity.ID;
                        publish.ORDINARY_TASK_ANALYSIS_ID = ordinary?.ID;
                        publish.PUBLISH_DATE = DateTime.Now;
                        publish.Nav_Area = null;
                        publish.ORG_ID = entity.ORG_ID;
                        publish.IS_AUTO = ISImportantEnum.是;
                        publish.USER_ID = userId;
                        //消息通知部门负责人
                        var userIds = new List();
                        userIds.Add((Guid)userId);
                        //userIds.Add((Guid)chargeUserId);
                        var UserNames = new List();
                        var user = this.GetEntity(t => t.ENABLE_STATUS == (int)FMEnableStatusEnum.启用 && userIds.Contains(t.ID));
                        UserNames.Add(user?.NAME);
                        //发消息
                        DateTime dtEnd = NotificationTaskService.GetTaskEndTime(FMTASKTYPE.Default, entity.ORG_ID.Value, DateTime.Now, null, null);
                        notices.AddRange(NotificationTaskService.InsertUserNoticeTaskModels("作业任务分析文件发布表", publish.ID, entity.ORG_ID, userIds, UserNames, DateTime.Now,
                        dtEnd, (int)FMNoticeTypeEnum.消息, "HM124"));
                    }
                }
            }
            UnifiedCommit(() =>
            {
                if (entity != null)
                    this.UpdateEntityNoCommit(entity);
                if (addOperations != null && addOperations.Any())
                    this.BantchSaveEntityNoCommit(addOperations);
                if (confIds != null && confIds.Any())
                    this.BantchDeleteEntityNoCommit(confIds);
                if (measIds != null && measIds.Any())
                    this.BantchDeleteEntityNoCommit(measIds);
                if (dealIds != null && dealIds.Any())
                    this.BantchDeleteEntityNoCommit(dealIds);
                if (postIds != null && postIds.Any())
                    this.BantchDeleteEntityNoCommit(postIds);
                if (safeConfs != null && safeConfs.Any())
                    this.BantchSaveEntityNoCommit(safeConfs);
                if (safeMeas != null && safeMeas.Any())
                    this.BantchSaveEntityNoCommit(safeMeas);
                if (dealMeas != null && dealMeas.Any())
                    this.BantchSaveEntityNoCommit(dealMeas);
                if (posts != null && posts.Any())
                    this.BantchSaveEntityNoCommit(posts);
                if (notices != null && notices.Any())
                    this.BantchSaveEntityNoCommit(notices);
                if (publish != null)
                    this.UpdateEntityNoCommit(publish);
            });
            return true;
        }
        /// 
        /// 回调函数
        /// 
        /// 
        ///  
        private bool BackUpdate_HMJobtaskIdentify(string id)
        {
            //var entity = this.GetEntity(id, false, "Nav_Details", "Nav_Details.Nav_OperationStep", "Nav_Details.Nav_DetailRisk");
            var entity = this.GetEntity(id, new string[] { "Nav_IdentifyUser", "Nav_Details", "Nav_Details.Nav_OperationStep", "Nav_Details.Nav_DetailRisk" });
            entity.IS_PUBLISH = FOPreMeetingStatusEnum.归档;
            entity.COMPLETE_DATE = DateTime.Now;
            //自动生成作业任务分析表
            T_HM_OPERATION_TASK_DISTINGUISH_ANALYZE operation = new T_HM_OPERATION_TASK_DISTINGUISH_ANALYZE();
            //取审批流水码
            var sysFilter = new SystemCodeFilter();
            sysFilter.CodeType = (int)PFCodeRuleType.作业任务分析表编号;
            sysFilter.Count = 1;
            sysFilter.OrgId = entity.ORG_ID;
            var codes = CodeRuleService.NewGenSerial(sysFilter);
            var codeList = codes.Split(new char[] { ',' });
            //主表
            operation.CODE = codeList[0];
            operation.COMPLETION_TIME = DateTime.Now;
            operation.DEPARTMENT_ID = entity.DEPARTMENT_ID;
            operation.JOBTASK_IDENTIFY_ID = entity.ID;
            operation.ORG_ID = entity.ORG_ID;
            operation.Nav_AnalyzeDetails = null;
            operation.Nav_AnalyzeFiles = null;
            operation.Nav_Users = null;
            operation.IS_AUTO = ISImportantEnum.是;
            operation.CREATER_ID = entity.CREATER_ID;
            operation.USER_ID = entity.CREATER_ID;
            //明细表
            List analyzeDetails = new List();
            List riskList = new List();
            var details = entity.Nav_Details;
            if (details != null && details.Any())
            {
                details.ForEach(t =>
                {
                    T_HM_OPERATION_TASK_DISTINGUISH_ANALYZE_DETAIL detail = new T_HM_OPERATION_TASK_DISTINGUISH_ANALYZE_DETAIL();
                    detail.AREA_ID = t.AREA_ID;
                    detail.OPERATION_STEP_ID = t.OPERATION_STEP_ID;
                    detail.OPERATION_TASK_DISTINGUISH_ANALYZE_ID = operation.ID;
                    detail.ORG_ID = t.ORG_ID;
                    detail.CREATER_ID = t.CREATER_ID;
                    detail.CYCLE_TYPE = t.CYCLE_TYPE;
                    if (t.Nav_DetailRisk != null && t.Nav_DetailRisk.Any())
                    {
                        t.Nav_DetailRisk.ForEach(x =>
                        {
                            T_HM_OPERATION_TASK_DISTINGUISH_ANALYZE_RISK risk = new T_HM_OPERATION_TASK_DISTINGUISH_ANALYZE_RISK();
                            risk.EVALUATE_RISK_ID = x.EVALUATE_RISK_ID.Value;
                            risk.OPERATION_TASK_DISTINGUISH_ANALYZE_DETAIL_ID = detail.ID;
                            risk.ORG_ID = t.ORG_ID;
                            riskList.Add(risk);
                        });
                    }
                    detail.Nav_DetailRisk = null;// riskList.Distinct(m=>m.EVALUATE_RISK_ID).ToList();
                    analyzeDetails.Add(detail);
                });
            }
            //
            KeywordFilter filter = new KeywordFilter();
            filter.Keyword = entity.CREATER_ID.ToString();
            var detailTemp = FullGet(filter);
            int count = 0;
            if (detailTemp != null && detailTemp.Nav_Details != null)
            {
                count = detailTemp.Nav_Details.Count();
            }
            //发消息通知负责人
            List notices = new List();
            T_HM_RISK_RECORD riskRecord = null;
            List recordUser = new List();
            List recordDetail = new List();
            T_HM_RISK_RECORD_IDENTIFYING recordObj = null;
            var chargeUserId = GetChargeUserId(entity.CREATER_ID);
            if (chargeUserId != null)
            {
                DateTime dtEnd = NotificationTaskService.GetTaskEndTime(FMTASKTYPE.Default, entity.ORG_ID.Value, DateTime.Now, null, null);
                var userIds = new List();
                userIds.Add((Guid)chargeUserId);
                var UserNames = new List();
                var users = this.GetEntities(t => t.ENABLE_STATUS == (int)FMEnableStatusEnum.启用 && userIds.Contains(t.ID), new BaseFilter(entity.ORG_ID));
                foreach (var user in userIds)
                {
                    var current = users.FirstOrDefault(t => t.ID == user);
                    UserNames.Add(current?.NAME);
                }
                //发消息
                notices = NotificationTaskService.InsertUserNoticeTaskModels("作业任务分析表", operation.ID, entity.ORG_ID, userIds, UserNames, DateTime.Now,
                dtEnd, (int)FMNoticeTypeEnum.消息, "HM088");
                if (count != 0 && details.Count() > count)
                {
                    var request = this.GetEntity(t => t.ORG_ID == entity.ORG_ID);
                    var obj = this.GetEntity(t => t.NAME == "作业过程");
                    riskRecord = new T_HM_RISK_RECORD();
                    riskRecord.START_TIME = DateTime.Now;
                    riskRecord.ORG_ID = entity.ORG_ID;
                    riskRecord.STATUS = (int)FOPreMeetingStatusEnum.草稿;
                    riskRecord.LEVEL = FMDepartmentType.部门;
                    riskRecord.REQUEST_ID = request.ID;
                    riskRecord.NOTE_TAKER_ID = chargeUserId;
                    riskRecord.INITIATING_DEPARTMENT = entity.DEPARTMENT_ID;
                    riskRecord.CREATER_ID = entity.CREATER_ID;
                    if (obj != null)
                    {
                        recordObj = new T_HM_RISK_RECORD_IDENTIFYING();
                        recordObj.ORG_ID = entity.ORG_ID;
                        recordObj.RECORD_ID = riskRecord.ID;
                        recordObj.IDENTIFYING_ID = obj.ID;
                    }
                    details.ForEach(t =>
                    {
                        T_HM_RISK_RECORD_DETAIL detail = new T_HM_RISK_RECORD_DETAIL();
                        detail.ORG_ID = entity.ORG_ID;
                        detail.RECORD_ID = riskRecord.ID;
                        detail.AREA_ID = t.AREA_ID;
                        detail.OPERATION_STEP_ID = t.OPERATION_STEP_ID;
                        detail.IDENTIFYING_ID = obj?.ID;
                        recordDetail.Add(detail);
                    });
                    if (entity.Nav_IdentifyUser != null && entity.Nav_IdentifyUser.Any())
                    {
                        entity.Nav_IdentifyUser.ForEach(t =>
                        {
                            recordDetail.ForEach(t1 =>
                            {
                                T_HM_RISK_RECORD_USER user = new T_HM_RISK_RECORD_USER();
                                user.ORG_ID = t.ORG_ID;
                                user.RECORD_ID = riskRecord.ID;
                                user.USER_ID = t.USER_ID.Value;
                                user.AREA_ID = (Guid)t1.AREA_ID;
                                recordUser.Add(user);
                            });
                        });
                    }
                    //如果识别细表有新增数据,则触发风险辨识任务制定表
                    notices.AddRange(NotificationTaskService.InsertUserNoticeTaskModels("危险源/风险辨识记录(作业任务识别触发)", riskRecord.ID, entity.ORG_ID, userIds, UserNames, DateTime.Now,
                    dtEnd, (int)FMNoticeTypeEnum.消息, "HM064"));
                }
            }
            UnifiedCommit(() =>
            {
                if (entity != null)
                    this.UpdateEntityNoCommit(entity);
                if (operation != null)
                    this.UpdateEntityNoCommit(operation);
                if (analyzeDetails != null && analyzeDetails.Any())
                    this.BantchSaveEntityNoCommit(analyzeDetails);
                if (riskList != null && riskList.Any())
                    this.BantchSaveEntityNoCommit(riskList);
                if (notices != null && notices.Any())
                    this.BantchSaveEntityNoCommit(notices);
                if (riskRecord != null)
                    this.UpdateEntityNoCommit(riskRecord);
                if (recordObj != null)
                    this.UpdateEntityNoCommit(recordObj);
                if (recordUser != null && recordUser.Any())
                    this.BantchSaveEntityNoCommit(recordUser);
                if (recordDetail != null && recordDetail.Any())
                    this.BantchSaveEntityNoCommit(recordDetail);
            });
            return true;
        }
        /// 
        /// 获取单条
        /// 
        /// 
        ///  
        private T_HM_JOBTASK_IDENTIFY FullGet(KeywordFilter filter)
        {
            T_HM_JOBTASK_IDENTIFY iDENTIFY = new T_HM_JOBTASK_IDENTIFY();
            List detailList = new List();
            if (string.IsNullOrEmpty(filter.Keyword))
                filter.Keyword = APT.Infrastructure.Api.AppContext.CurrentSession.UserID.ToString();
            //取人员部门对应的部门层级:公司级、部门级、车间级、班组级
            var user = GetEntity(t => t.ID == Guid.Parse(filter.Keyword) && t.ENABLE_STATUS == 0, new string[] { "Nav_Department" });
            var type = user.Nav_Department.DEPARTMENT_TYPE;
            //主表部门自动赋值
            iDENTIFY.ORG_ID = user.ORG_ID;
            iDENTIFY.DEPARTMENT_ID = user.DEPARTMENT_ID;
            List departmentIds = new List() { user.DEPARTMENT_ID.Value };
            DepartmentService.GetDepartmentIds(user.ORG_ID.Value, new List() { user.DEPARTMENT_ID.Value }, ref departmentIds);
            //根据辨识区域和部门层级到风险库获取作业任务、岗位、风险信息typeList.Contains((int)t.LEVEL) && areaIds.Contains((Guid)t.AREA_ID)
            var stepIds = GetEntities(t => departmentIds.Contains(t.DEPARTMENT_LIABLE_ID.Value) && t.OPERATION_STEP_ID != null && t.STATUS == (int)HMOperationStepEnum.有效 && (int)t.LEVEL == type, new BaseFilter(user.ORG_ID)).Select(t => t.OPERATION_STEP_ID).Distinct().ToList();
            var links = GetEntities(t => stepIds.Contains(t.OPERATION_STEP_ID), new BaseFilter(user.ORG_ID), new string[] { "Nav_LinkPost", "Nav_LinkPost.Nav_Post", "Nav_OperationStep" });
            if (links != null && links.Any())
            {
                links.ForEach(t =>
                {
                    List postList = new List();
                    List detailPost = new List(); var postName = "";
                    T_HM_JOBTASK_IDENTIFY_DETAIL detail = new T_HM_JOBTASK_IDENTIFY_DETAIL();
                    //List riskList = new List();
                    detail.ORG_ID = user.ORG_ID;
                    detail.JOBTASK_IDENTIFY_ID = iDENTIFY.ID;
                    //detail.AREA_ID = t.AREA_ID;
                    //detail.Nav_Area = t.Nav_Area;
                    //var link = links.FirstOrDefault(m => m.OPERATION_STEP_ID == t.OPERATION_STEP_ID);
                    if (t.Nav_LinkPost != null && t.Nav_LinkPost.Any())
                    {
                        t.Nav_LinkPost.ForEach(x =>
                        {
                            T_HM_JOBTASK_IDENTIFY_DETAIL_POST post = new T_HM_JOBTASK_IDENTIFY_DETAIL_POST();
                            post.ORG_ID = t.ORG_ID;
                            post.JOBTASK_IDENTIFY_DETAIL_ID = detail.ID;
                            post.POST_ID = x.POST_ID;
                            post.Nav_Post = x.Nav_Post;
                            postName = x.Nav_Post?.NAME;
                            detailPost.Add(postName);
                            postList.Add(post);
                        });
                    }
                    //风险表
                    //var risks = links.Where(m => m.OPERATION_STEP_ID == t.OPERATION_STEP_ID).ToList();
                    //if (risks != null && risks.Any())
                    //{
                    //    risks.ForEach(x =>
                    //    {
                    //        T_HM_JOBTASK_IDENTIFY_DETAIL_RISK risk = new T_HM_JOBTASK_IDENTIFY_DETAIL_RISK();
                    //        risk.ORG_ID = t.ORG_ID;
                    //        risk.JOBTASK_IDENTIFY_DETAIL_ID = detail.ID;
                    //        risk.EVALUATE_RISK_ID = x.ID;
                    //        risk.Nav_EvaluateRisk = x;
                    //        riskList.Add(risk);
                    //    });
                    //}
                    //detail.Nav_DetailRisk = riskList.Distinct(m => m.EVALUATE_RISK_ID).ToList();
                    detail.OPERATION_STEP_ID = t.OPERATION_STEP_ID;
                    detail.Nav_OperationStep = t.Nav_OperationStep;
                    detail.Nav_DetailPost = postList.Distinct(m => m.POST_ID).ToList();
                    detail.DetailPost = string.Join(",", detailPost);
                    detail.OperationStepName = t.Nav_OperationStep?.NAME;
                    detail.CYCLE_TYPE = t.CYCLE_TYPE;
                    detailList.Add(detail);
                });
            }
            iDENTIFY.Nav_Details = detailList.OrderBy(t => t.Nav_OperationStep.NAME).ToList();
            return iDENTIFY;
        }
        /// 
        /// 回调函数
        /// 
        /// 
        ///  
        private bool BackUpdate_HMLicenseAnalysis(string id)
        {
            //var entity = this.GetEntity( id,  false,"Nav_OperationAnalyze", "Nav_Details", "Nav_Details.Nav_OperationStep", "Nav_Details.Nav_DetailRisk");
            var entity = this.GetEntity(id, new string[] { "Nav_OperationAnalyze", "Nav_Details", "Nav_Details.Nav_OperationStep" });
            entity.IS_PUBLISH = FOPreMeetingStatusEnum.归档;
            entity.COMPLETE_DATE = DateTime.Now;
            //写入作业任务库
            List operations = new List();
            List safeConfs = new List();
            List safeMeas = new List();
            List dealMeas = new List();
            List posts = new List();
            List notices = new List();
            List confIds = new List();
            List measIds = new List();
            List dealIds = new List();
            List postIds = new List();
            if (entity.Nav_Details != null && entity.Nav_Details.Any())
            {
                List jobDetails = null;
                var stepIds = entity.Nav_Details.Select(t => t.OPERATION_STEP_ID).Distinct().ToList();
                if (entity.Nav_OperationAnalyze != null && entity.Nav_OperationAnalyze.JOBTASK_IDENTIFY_ID != null)
                {
                    jobDetails = this.GetEntities(t => t.JOBTASK_IDENTIFY_ID == entity.Nav_OperationAnalyze.JOBTASK_IDENTIFY_ID && stepIds.Contains(t.OPERATION_STEP_ID), new BaseFilter(entity.ORG_ID), "Nav_DetailPost").ToList();
                }
                var links = this.GetEntities(t => stepIds.Contains(t.OPERATION_STEP_ID) && t.STATUS == (int)STATUSEnum.启用 && t.IS_RUN == DisableStatusEnum.是, new BaseFilter(entity.ORG_ID), new string[] { "Nav_LinkPost", "Nav_SafeConfirms", "Nav_SafeMeasures", "Nav_DealMeasures" });
                entity.Nav_Details.ForEach(t =>
                {
                    T_HM_OPERATION_LINK operation = new T_HM_OPERATION_LINK();
                    var current = links.FirstOrDefault(x => x.OPERATION_STEP_ID == t.OPERATION_STEP_ID);//OrderByDescending(t => t.CREATE_TIME).
                    if (current != null)
                    {
                        current.CODE = entity.CODE;
                        current.NAME = "许可作业分析表回写";
                        current.OPERATION_STEP_ID = t.OPERATION_STEP_ID;
                        current.TASK_LEVEL = (int)HMTaskLevelEnum.许可作业;
                        current.ORG_ID = entity.ORG_ID;
                        current.IS_IMPORTANT = (int)ISImportantEnum.是;
                        current.SafeConfirmsStr = t.SafeConfirmsStr;
                        current.SafeMeasuresStr = t.SafeMeasuresStr;
                        current.DealMeasuresStr = t.DealMeasuresStr;
                        current.STATUS = (int)STATUSEnum.启用;
                        current.CREATER_ID = entity.CREATER_ID;
                        current.MODIFY_TYPE = HMModifyEnum.修改;
                        current.CYCLE_TYPE = t.CYCLE_TYPE;
                        current.WORK_PERMIT_TYPE_ID = t.WORK_PERMIT_TYPE_ID;
                        current.AUDIT_LEVEL = (int)t.AUDIT_LEVEL;
                        operation = current;
                        if (current.Nav_SafeConfirms != null && current.Nav_SafeConfirms.Any())
                        {
                            var ids = current.Nav_SafeConfirms.Select(t => t.ID).ToList();
                            confIds.AddRange(ids);
                        }
                        if (current.Nav_SafeMeasures != null && current.Nav_SafeMeasures.Any())
                        {
                            var ids = current.Nav_SafeMeasures.Select(t => t.ID).ToList();
                            measIds.AddRange(ids);
                        }
                        if (current.Nav_DealMeasures != null && current.Nav_DealMeasures.Any())
                        {
                            var ids = current.Nav_DealMeasures.Select(t => t.ID).ToList();
                            dealIds.AddRange(ids);
                        }
                        if (current.Nav_LinkPost != null && current.Nav_LinkPost.Any())
                        {
                            var ids = current.Nav_LinkPost.Select(t => t.ID).ToList();
                            postIds.AddRange(ids);
                        }
                        //if (t.AREA_ID != null && current.Nav_LinkArea != null && current.Nav_LinkArea.Any())
                        //{
                        //    var linkArea = current.Nav_LinkArea.FirstOrDefault(t => t.AREA_ID == t.AREA_ID);
                        //    if (linkArea == null)
                        //    {
                        //        T_HM_OPERATION_LINK_AREA area = new T_HM_OPERATION_LINK_AREA();
                        //        area.ORG_ID = entity.ORG_ID;
                        //        area.OPERATION_LINK_ID = current.ID;
                        //        area.AREA_ID = t.AREA_ID;
                        //        areas.Add(area);
                        //    }
                        //}
                    }
                    else
                    {
                        //主表
                        operation.CODE = entity.CODE;
                        operation.NAME = "许可作业分析表新增";
                        operation.OPERATION_STEP_ID = t.OPERATION_STEP_ID;
                        operation.TASK_LEVEL = (int)HMTaskLevelEnum.许可作业;
                        operation.ORG_ID = entity.ORG_ID;
                        operation.IS_IMPORTANT = (int)ISImportantEnum.是;
                        operation.SafeConfirmsStr = t.SafeConfirmsStr;
                        operation.SafeMeasuresStr = t.SafeMeasuresStr;
                        operation.DealMeasuresStr = t.DealMeasuresStr;
                        operation.STATUS = (int)STATUSEnum.启用;
                        operation.CREATER_ID = entity.CREATER_ID;
                        operation.MODIFY_TYPE = HMModifyEnum.新增;
                        operation.CYCLE_TYPE = t.CYCLE_TYPE;
                        operation.WORK_PERMIT_TYPE_ID = t.WORK_PERMIT_TYPE_ID;
                        operation.AUDIT_LEVEL = (int)t.AUDIT_LEVEL;
                        var mineType = APT.Infrastructure.Api.AppContext.CurrentSession.MineType;
                        if (!string.IsNullOrEmpty(mineType))
                        {
                            operation.MineType = int.Parse(mineType.Split(",")[0]);
                        }
                        //if (t.AREA_ID != null)
                        //{
                        //    T_HM_OPERATION_LINK_AREA area = new T_HM_OPERATION_LINK_AREA();
                        //    area.ORG_ID = entity.ORG_ID;
                        //    area.OPERATION_LINK_ID = operation.ID;
                        //    area.AREA_ID = t.AREA_ID;
                        //    areas.Add(area);
                        //}
                    }
                    var newPostIds = jobDetails.FirstOrDefault(t => t.OPERATION_STEP_ID == operation.OPERATION_STEP_ID);
                    if (newPostIds != null && newPostIds.Nav_DetailPost != null && newPostIds.Nav_DetailPost.Any())
                    {
                        foreach (var item in newPostIds.Nav_DetailPost)
                        {
                            T_HM_OPERATION_LINK_POST post = new T_HM_OPERATION_LINK_POST();
                            post.ORG_ID = entity.ORG_ID;
                            post.OPERATION_LINK_ID = operation.ID;
                            post.POST_ID = item.POST_ID;
                            posts.Add(post);
                        }
                    }
                    if (!string.IsNullOrEmpty(t.SafeConfirmsStr))
                    {
                        var conf = t.SafeConfirmsStr.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
                        if (conf.Length > 0)
                        {
                            foreach (var c in conf)
                            {
                                T_HM_OPERATION_TASK_SAFE_CONFIRM safeConf = new T_HM_OPERATION_TASK_SAFE_CONFIRM();
                                safeConf.ORG_ID = entity.ORG_ID;
                                safeConf.OPERATION_LINK_ID = operation.ID;
                                if (c.Contains("、"))
                                {
                                    var co = c.Split(new[] { '、' }, StringSplitOptions.RemoveEmptyEntries);
                                    if (co.Length > 0)
                                    {
                                        safeConf.NAME = co[1];
                                        safeConf.NUM = int.Parse(co[0]);
                                    }
                                    else
                                    {
                                        safeConf.NAME = c;
                                        safeConf.NUM = 1;
                                    }
                                }
                                else
                                {
                                    safeConf.NAME = c;
                                    safeConf.NUM = 1;
                                }
                                safeConfs.Add(safeConf);
                            }
                        }
                    }
                    if (!string.IsNullOrEmpty(t.SafeMeasuresStr))
                    {
                        var conf = t.SafeMeasuresStr.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
                        if (conf.Length > 0)
                        {
                            foreach (var c in conf)
                            {
                                T_HM_OPERATION_TASK_SAFE_MEASURE safeConf = new T_HM_OPERATION_TASK_SAFE_MEASURE();
                                safeConf.ORG_ID = entity.ORG_ID;
                                safeConf.OPERATION_LINK_ID = operation.ID;
                                if (c.Contains("、"))
                                {
                                    var co = c.Split(new[] { '、' }, StringSplitOptions.RemoveEmptyEntries);
                                    if (co.Length > 0)
                                    {
                                        safeConf.NAME = co[1];
                                        safeConf.NUM = int.Parse(co[0]);
                                    }
                                    else
                                    {
                                        safeConf.NAME = c;
                                        safeConf.NUM = 1;
                                    }
                                }
                                else
                                {
                                    safeConf.NAME = c;
                                    safeConf.NUM = 1;
                                }
                                safeMeas.Add(safeConf);
                            }
                        }
                    }
                    if (!string.IsNullOrEmpty(t.DealMeasuresStr))
                    {
                        var conf = t.DealMeasuresStr.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
                        if (conf.Length > 0)
                        {
                            foreach (var c in conf)
                            {
                                T_HM_OPERATION_TASK_DEAL_MEASURE safeConf = new T_HM_OPERATION_TASK_DEAL_MEASURE();
                                safeConf.ORG_ID = entity.ORG_ID;
                                safeConf.OPERATION_LINK_ID = operation.ID;
                                if (c.Contains("、"))
                                {
                                    var co = c.Split(new[] { '、' }, StringSplitOptions.RemoveEmptyEntries);
                                    if (co.Length > 0)
                                    {
                                        safeConf.NAME = co[1];
                                        safeConf.NUM = int.Parse(co[0]);
                                    }
                                    else
                                    {
                                        safeConf.NAME = c;
                                        safeConf.NUM = 1;
                                    }
                                }
                                else
                                {
                                    safeConf.NAME = c;
                                    safeConf.NUM = 1;
                                }
                                dealMeas.Add(safeConf);
                            }
                        }
                    }
                    operation.IS_RUN = DisableStatusEnum.是;
                    operations.Add(operation);
                });
            }
            //自动触发文件发布
            List dataIds = new List();
            T_HM_FILE_PUBLISH publish = null;
            dataIds.Add(entity.ID);
            var crucial = this.GetEntity(t => t.OPERATION_ANALYZE_ID == entity.OPERATION_ANALYZE_ID);
            if (crucial != null)
                dataIds.Add(crucial.ID);
            var ordinary = this.GetEntity(t => t.OPERATION_ANALYZE_ID == entity.OPERATION_ANALYZE_ID);
            if (ordinary != null)
                dataIds.Add(ordinary.ID);
            var approve = this.GetEntities(t => dataIds.Contains(t.DATA_ID), new BaseFilter(entity.ORG_ID));
            if (approve != null && approve.Any())
            {
                bool isEnd = true;
                approve.ForEach(t =>
                {
                    if (t.APPROVE_STATUS != (int)ApproveStatus.Done)
                        isEnd = false;
                });
                if (isEnd)
                {
                    var nextCode = "";
                    var nextCodeInfo = this.GetEntities(t => !t.IS_DELETED, new BaseFilter(entity.ORG_ID)).OrderByDescending(t => t.CREATE_TIME).FirstOrDefault();
                    var year = DateTime.Now.Year;
                    var month = DateTime.Now.Month.PadLeft(2, '0');
                    var day = DateTime.Now.Day.PadLeft(2, '0');
                    if (nextCodeInfo == null)
                    {
                        nextCode = "RWFX" + year + month + day + "00001";
                    }
                    else
                    {
                        //取最后五位序列号
                        var serial = nextCodeInfo.CODE.Substring(nextCodeInfo.CODE.Length - 5);
                        //序列号+1,不足五位补0
                        var num = (int.Parse(serial) + 1).ToString().PadLeft(5, '0');
                        nextCode = "RWFX" + year + month + day + num;
                    }
                    var userId = this.GetEntity(t => t.NAME == "办公室负责人")?.USER_ID;
                    if (userId != null)
                    {
                        //文件发布表
                        publish = new T_HM_FILE_PUBLISH();
                        publish.NAME = "";
                        publish.CODE = nextCode;
                        publish.LICENSE_ANALYSIS_ID = entity.ID;
                        publish.CRUCIAL_TASK_ANALYSIS_ID = crucial?.ID;
                        publish.ORDINARY_TASK_ANALYSIS_ID = ordinary?.ID;
                        publish.PUBLISH_DATE = DateTime.Now;
                        publish.Nav_Area = null;
                        publish.ORG_ID = entity.ORG_ID;
                        publish.IS_AUTO = ISImportantEnum.是;
                        publish.USER_ID = userId;
                        //消息通知辦公室负责人李忠松
                        var userIds = new List();
                        userIds.Add((Guid)userId);
                        //userIds.Add((Guid)chargeUserId);
                        var UserNames = new List();
                        var user = this.GetEntity(t => t.ENABLE_STATUS == (int)FMEnableStatusEnum.启用 && userIds.Contains(t.ID));
                        UserNames.Add(user?.NAME);
                        //发消息
                        DateTime dtEnd = NotificationTaskService.GetTaskEndTime(FMTASKTYPE.Default, entity.ORG_ID.Value, DateTime.Now, null, null);
                        notices.AddRange(NotificationTaskService.InsertUserNoticeTaskModels("作业任务分析文件发布表", publish.ID, entity.ORG_ID, userIds, UserNames, DateTime.Now,
                        dtEnd, (int)FMNoticeTypeEnum.消息, "HM124"));
                    }
                }
            }
            UnifiedCommit(() =>
            {
                if (entity != null)
                    this.UpdateEntityNoCommit(entity);
                if (operations != null && operations.Any())
                    this.BantchSaveEntityNoCommit(operations);
                if (confIds != null && confIds.Any())
                    this.BantchDeleteEntityNoCommit(confIds);
                if (measIds != null && measIds.Any())
                    this.BantchDeleteEntityNoCommit(measIds);
                if (dealIds != null && dealIds.Any())
                    this.BantchDeleteEntityNoCommit(dealIds);
                if (postIds != null && postIds.Any())
                    this.BantchDeleteEntityNoCommit(postIds);
                if (safeConfs != null && safeConfs.Any())
                    this.BantchSaveEntityNoCommit(safeConfs);
                if (safeMeas != null && safeMeas.Any())
                    this.BantchSaveEntityNoCommit(safeMeas);
                if (dealMeas != null && dealMeas.Any())
                    this.BantchSaveEntityNoCommit(dealMeas);
                if (posts != null && posts.Any())
                    this.BantchSaveEntityNoCommit(posts);
                if (notices != null && notices.Any())
                    this.BantchSaveEntityNoCommit(notices);
                if (publish != null)
                    this.UpdateEntityNoCommit(publish);
            });
            return true;
        }
        /// 
        /// 回调函数
        /// 
        /// 
        ///  
        private bool BackUpdate_HMOperationTaskDistinguishAnalyze(string id)
        {
            //var entity = this.GetEntity(id, false, "Nav_AnalyzeDetails", "Nav_AnalyzeDetails.Nav_WorkPermitType", "Nav_AnalyzeDetails.Nav_OperationStep", "Nav_AnalyzeDetails.Nav_EvaluateRisk", "Nav_Users");
            var entity = this.GetEntity(id, new string[] { "Nav_JobtaskIdentify", "Nav_AnalyzeDetails", "Nav_AnalyzeDetails.Nav_WorkPermitType", "Nav_AnalyzeDetails.Nav_OperationStep", "Nav_AnalyzeDetails.Nav_DetailRisk", "Nav_Users" });
            entity.IS_PUBLISH = FOPreMeetingStatusEnum.归档;
            entity.COMPLETION_TIME = DateTime.Now;
            //自动生成许可、非许可的关键任务、一般任务分析表
            T_HM_LICENSE_ANALYSIS license = null;
            List licenseDetails = new List();
            List licenseUsers = new List();
            T_HM_CRUCIAL_TASK_ANALYSIS crucial = null;
            List crucialDetails = new List();
            List crucialUsers = new List();
            T_HM_ORDINARY_TASK_ANALYSIS ordinary = null;
            List