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.FM;
using APT.BaseData.Services.DomainServices;
using APT.BaseData.Services.Services.FM;
using APT.Infrastructure.Core;
using APT.MS.Domain.Entities.BS;
using APT.MS.Domain.Entities.SC.PE;
using APT.MS.Domain.Entities.SK;
using APT.MS.Domain.Enums;
using APT.MS.Domain.Enums.SK;
using APT.Utility;
using Castle.Core.Internal;
using InfluxData.Net.InfluxDb.Models.Responses;
using Microsoft.AspNetCore.Mvc;
using NPOI.SS.Formula.Functions;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;

namespace APT.SK.WebApi.Controllers.Api
{
    public class OperateLogDto
    {
        /// <summary>
        /// 操作类型 安全检查/隐患上报（对应的 DATA_ID 不一样）
        /// </summary>
        [Description("操作类型")]
        public SKLOGTYPE_Enums LOGTYPE { get; set; }

        /// <summary>
        /// 表单ID 
        /// </summary>
        [Description("表单ID")]
        public Guid DATA_ID { get; set; }

        /// <summary>
        /// 表单明细ID
        /// </summary>
        [Description("表单明细ID")]
        public Guid? DATA_ID_SUB { get; set; }

        /// <summary>
        /// 操作节点
        /// </summary>
        [Description("操作节点")]
        public SKOPERATEPOINT_Enums OPERATEPOINT { get; set; }

        /// <summary>
        /// 操作人（需要操作的人） 
        /// </summary>
        [Description("操作人")]
        public Guid USER_ID { get; set; }

        /// <summary>
        /// 操作人
        /// </summary>
        [Description("操作人")]
        public string USRTNAME { get; set; }

        /// <summary>
        /// 排序 比如审批 可能多节点
        /// </summary>
        [Description("排序")]
        public int ORDERNO { get; set; }

        /// <summary>
        /// 操作时间  
        /// </summary>
        [Description("操作时间")]
        public DateTime? OPERTETIME { get; set; }

        [Description("排序时间")]
        public DateTime? ORDERTIME { get; set; }

        /// <summary>
        /// 是否按时
        /// </summary>
        [Description("是否按时")]
        public bool? ISINTTIME { get; set; }
    }
    /// <summary>
    ///  安全检查通知
    /// </summary>
    [Route("api/SK/SKSecurityInspectionNotice")]
    public partial class SecurityInspectionNoticeController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_NOTICE>
    {
        IPFApproveCallBackService ApproveCallBackService { get; set; }
        IFMNotificationTaskService NotificationTaskService { get; set; }
        IPFCodeRuleService CodeRuleService { get; set; }
        IFMFlowPermitService MFlowPermitService { get; set; }
        /// <summary>
        /// 安全检查通知
        /// </summary>
        /// <param name="notificationTaskService"></param>
        /// <param name="approveCallBackService"></param>
        /// <param name="mFlowPermitService"></param>
        /// <param name="codeRuleService"></param>
        public SecurityInspectionNoticeController(IFMNotificationTaskService notificationTaskService, IPFApproveCallBackService approveCallBackService, IFMFlowPermitService mFlowPermitService, IPFCodeRuleService codeRuleService)
        {
            NotificationTaskService = notificationTaskService;
            ApproveCallBackService = approveCallBackService;
            MFlowPermitService = mFlowPermitService;
            CodeRuleService = codeRuleService;
        }
        /// <summary>
        /// 保存
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        [HttpPost, Route("FullUpdate")]
        public JsonActionResult<bool> FullUpdate([FromBody] T_SK_SECURITY_INSPECTION_NOTICE entity)
        {
            return SafeExecute<bool>(() =>
            {
                var userId = APT.Infrastructure.Api.AppContext.CurrentSession.UserID;
                var departId = APT.Infrastructure.Api.AppContext.CurrentSession.DepartmentID;
                if (entity.APPLY_USER_ID == null)
                    entity.APPLY_USER_ID = userId;
                if (entity.APPLY_DEPARTMENT_ID == null)
                    entity.APPLY_DEPARTMENT_ID = departId;
                if (entity.CHECK_TYPE_ID == null)
                    throw new Exception("检查类型不能为空");
                if (entity.CHECK_TIME == null || entity.CHECK_TIME == DateTime.MinValue)
                    throw new Exception("检查时间必须填写");
                entity.ApplyDepartmentName = this.GetEntity<T_FM_DEPARTMENT>(t => t.ID == departId).NAME;
                entity.ApplyPostName = this.GetEntity<T_FM_USER>(t => t.ID == userId, "Nav_Person.Nav_Post")?.Nav_Person?.Nav_Post?.NAME;
                var details = entity.Nav_CheckNoticeDetails;
                entity.Nav_CheckNoticeDetails = null;
                var files = entity.Nav_CheckNoticeFiles;
                entity.Nav_CheckNoticeFiles = null;
                List<Guid> userIds = new List<Guid>();
                List<Guid> deleteUserIds = new List<Guid>();
                List<Guid> deleteBasicIds = new List<Guid>();
                List<Guid> deleteDetailIds = new List<Guid>();
                List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_USER> userList = new List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_USER>();
                List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_BASIC> basicList = new List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_BASIC>();
                if (details != null && details.Any())
                {
                    var evaluationIsExist = this.GetEntity<T_SK_SECURITY_INSPECTION_NOTICE>(t => t.ID == entity.ID, new string[] { "Nav_CheckNoticeDetails", "Nav_CheckNoticeDetails.Nav_CheckNoticeDetailUsers", "Nav_CheckNoticeDetails.Nav_CheckNoticeDetailBasics" });
                    if (evaluationIsExist != null && evaluationIsExist.Nav_CheckNoticeDetails != null && evaluationIsExist.Nav_CheckNoticeDetails.Any())
                    {
                        evaluationIsExist.Nav_CheckNoticeDetails.ForEach(t =>
                        {
                            if (t.Nav_CheckNoticeDetailUsers != null && t.Nav_CheckNoticeDetailUsers.Any())
                            {
                                var tempIds = t.Nav_CheckNoticeDetailUsers.Select(m => m.ID).ToList();
                                deleteUserIds.AddRange(tempIds);
                            }
                            if (t.Nav_CheckNoticeDetailBasics != null && t.Nav_CheckNoticeDetailBasics.Any())
                            {
                                var tempIds = t.Nav_CheckNoticeDetailBasics.Select(m => m.ID).ToList();
                                deleteBasicIds.AddRange(tempIds);
                            }
                            deleteDetailIds.Add(t.ID);
                        });
                    }
                    foreach (var item in details)
                    {
                        if (item.Nav_CheckNoticeDetailUsers != null && item.Nav_CheckNoticeDetailUsers.Any())
                        {
                            item.Nav_CheckNoticeDetailUsers = item.Nav_CheckNoticeDetailUsers.OrderByDescending(t => t.Nav_User?.Nav_ApproveRole?.CODE).ToList();
                            var i = 1;
                            foreach (var item2 in item.Nav_CheckNoticeDetailUsers)
                            {
                                item2.ORG_ID = entity.ORG_ID;
                                item2.SECURITY_INSPECTION_NOTICE_DETAIL_ID = item.ID;
                                item2.Nav_User = null;
                                item2.ISMAINCHECK = i == 1 ? true : false;
                                if (item2.USER_ID != null)
                                {
                                    userIds.Add((Guid)item2.USER_ID);
                                }
                                userList.Add(item2);
                                i++;
                            }
                        }
                        if (item.Nav_CheckNoticeDetailBasics != null && item.Nav_CheckNoticeDetailBasics.Any())
                        {
                            foreach (var item2 in item.Nav_CheckNoticeDetailBasics)
                            {
                                if (item2 != null)
                                {
                                    item2.ORG_ID = entity.ORG_ID;
                                    item2.SECURITY_INSPECTION_NOTICE_DETAIL_ID = item.ID;
                                    item2.Nav_CheckNoticeDetail = null;
                                    item2.Nav_Law = null;
                                    basicList.Add(item2);
                                }
                            }
                        }
                        item.ORG_ID = entity.ORG_ID;
                        item.SECURITY_INSPECTION_NOTICE_ID = entity.ID;
                        item.Nav_CheckNoticeDetailUsers = null;
                        item.Nav_CheckNoticeDetailBasics = null;
                        item.Nav_Contents = null;
                    }
                }
                if (files != null && files.Any())
                {
                    foreach (var item in files)
                    {
                        item.ORG_ID = entity.ORG_ID;
                        item.SECURITY_INSPECTION_NOTICE_ID = entity.ID;
                        item.Nav_ImgFile = null;
                    }
                }
                if (string.IsNullOrEmpty(entity.CHECK_PERSON))
                {
                    var detailUserIds = userList.Where(m => !m.IS_DELETED).Select(t => t.USER_ID).Distinct().ToList();
                    var userNames = this.GetEntities<T_FM_USER>(t => t.ENABLE_STATUS == 0 && detailUserIds.Contains(t.ID), new BaseFilter(entity.ORG_ID)).Select(m => m.NAME).ToList();
                    entity.CHECK_PERSON = string.Join(",", userNames);
                }
                T_FM_NOTIFICATION_TASK task = null;
                List<T_FM_NOTIFICATION_TASK> notices = new List<T_FM_NOTIFICATION_TASK>();
                if (entity.PUBLISH != null && entity.PUBLISH.Equals("SaveAndNotify"))
                {
                    var param = "公司级";
                    var department = this.GetEntity<T_FM_DEPARTMENT>(t => t.ID == entity.APPLY_DEPARTMENT_ID && t.ENABLE_STATUS == 0);
                    if (department != null)
                    {
                        param = Enum.GetName(typeof(SKDepartmentTypeEnum), department.DEPARTMENT_TYPE);
                        if (department.DEPARTMENT_STATUS != 1)
                        {
                            param = "公司级";
                        }
                    }
                    var date = DateTime.Now.Year + DateTime.Now.Month.PadLeft(2, '0') + DateTime.Now.Day.PadLeft(2, '0');
                    entity.STATUS = PFStandardStatus.Approving;
                    //取审批流水码
                    var sysFilter = new SystemCodeFilter();
                    sysFilter.CodeType = (int)PFCodeRuleType.审批流编码;
                    sysFilter.Count = 1;
                    sysFilter.OrgId = entity.ORG_ID;
                    var codes = CodeRuleService.NewGenSerial(sysFilter);
                    var serialCode = codes.Split(new char[] { ',' });
                    MFlowPermitService.InsertApprove(serialCode[0], "SK006", param, entity.ID, "SK006_SHOWPRINT", entity.TaskID, true, () =>
                    {
                        if (task != null)
                            UpdateEntityNoCommit(task);
                        if (entity != null)
                            UpdateEntityNoCommit(entity);
                        if (deleteUserIds != null && deleteUserIds.Any())
                            this.BantchDeleteEntityNoCommit<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_USER>(deleteUserIds);
                        if (deleteBasicIds != null && deleteBasicIds.Any())
                            this.BantchDeleteEntityNoCommit<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_BASIC>(deleteBasicIds);
                        if (deleteDetailIds != null && deleteDetailIds.Any())
                            this.BantchDeleteEntityNoCommit<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL>(deleteDetailIds);
                        if (details != null && details.Any())
                            BantchSaveEntityNoCommit(details);
                        if (userList != null && userList.Any())
                            BantchSaveEntityNoCommit(userList);
                        if (basicList != null && basicList.Any())
                            BantchSaveEntityNoCommit(basicList);
                        if (files != null && files.Any())
                            BantchSaveEntityNoCommit(files);
                        if (notices != null && notices.Any())
                            BantchSaveEntityNoCommit(notices);
                    }, null, null, null, null, null, "SK006_SHOWPRINT", null, entity.DEPARTMENT_TYPE.GetDescription() + "安全检查通知" + date + entity.Nav_CheckType?.NAME + "待审批");
                    return true;
                }
                this.UnifiedCommit(() =>
                {
                    if (task != null)
                        UpdateEntityNoCommit(task);
                    if (entity != null)
                        UpdateEntityNoCommit(entity);
                    if (deleteUserIds != null && deleteUserIds.Any())
                        this.BantchDeleteEntityNoCommit<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_USER>(deleteUserIds);
                    if (deleteBasicIds != null && deleteBasicIds.Any())
                        this.BantchDeleteEntityNoCommit<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_BASIC>(deleteBasicIds);
                    if (deleteDetailIds != null && deleteDetailIds.Any())
                        this.BantchDeleteEntityNoCommit<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL>(deleteDetailIds);
                    if (details != null && details.Any())
                        BantchSaveEntityNoCommit(details);
                    if (userList != null && userList.Any())
                        BantchSaveEntityNoCommit(userList);
                    if (basicList != null && basicList.Any())
                        BantchSaveEntityNoCommit(basicList);
                    if (files != null && files.Any())
                        BantchSaveEntityNoCommit(files);
                    if (notices != null && notices.Any())
                        BantchSaveEntityNoCommit(notices);
                });
                return true;
            });
        }

        /// <summary>
        /// 签字人员获取
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        [HttpPost, Route("GetIdentityUserEdit")]
        public JsonActionResult<T_SK_SECURITY_INSPECTION_NOTICE> GetIdentityUserEdit([FromBody] KeywordFilter filter)
        {
            return SafeExecute(() => {
                var id = filter.FilterGroup.Rules.FirstOrDefault(t => t.Field == "ID").Value.ToString();
                if (string.IsNullOrEmpty(id))
                    this.ThrowError("030017");
                var loginUserId = APT.Infrastructure.Api.AppContext.CurrentSession.UserID;
                filter.IgnoreDataRule = true;
                var result = this.GetEntity<T_SK_SECURITY_INSPECTION_NOTICE>(id, new string[] {"Nav_ApplyUser","Nav_ApplyDepartment","Nav_CheckType",
            "Nav_CheckNoticeDetails","Nav_CheckNoticeDetails.Nav_RiskArea","Nav_CheckNoticeDetails.Nav_Contents","Nav_CheckNoticeDetails.Nav_CheckNoticeDetailBasics.Nav_Law",
                    "Nav_CheckNoticeDetails.Nav_CheckNoticeDetailUsers.Nav_User","Nav_CheckNoticeFiles","Nav_CheckNoticeFiles.Nav_ImgFile","Nav_ProductionUnit"});
                //var taskId = filter.FilterGroup.Rules.FirstOrDefault(t => t.Field == "TASK_ID").Value;
                if (result != null && result.Nav_CheckNoticeDetails != null && result.Nav_CheckNoticeDetails.Any())// && taskId!=null
                {
                    foreach (var detail in result.Nav_CheckNoticeDetails)
                    {
                        detail.Nav_CheckNoticeDetailUsers = detail.Nav_CheckNoticeDetailUsers.OrderByDescending(t => t.ISMAINCHECK).ToList();
                    }
                    result.Nav_CheckNoticeDetails = result.Nav_CheckNoticeDetails.OrderBy(t => t.RISK_AREA_ID).ThenBy(m => m.NUM).ToList();//.Where(c => c.Nav_CheckNoticeDetailUsers != null && c.Nav_CheckNoticeDetailUsers.FirstOrDefault(m => m.USER_ID == loginUserId)?.USER_ID == loginUserId).OrderBy(m=>m.RISK_AREA_ID).ToList();
                }
                return result;
            });
        }
        /// <summary>
        /// 签字人员获取
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        [HttpPost, Route("GetIdentityUserEditApp")]
        public JsonActionResult<T_SK_SECURITY_INSPECTION_NOTICE> GetIdentityUserEditApp([FromBody] KeywordFilter filter)
        {
            return SafeExecute(() => {
                var id = filter.FilterGroup.Rules.FirstOrDefault(t => t.Field == "ID").Value.ToString();
                if (string.IsNullOrEmpty(id))
                    this.ThrowError("030017");
                var loginUserId = APT.Infrastructure.Api.AppContext.CurrentSession.UserID;
                filter.IgnoreDataRule = true;
                var result = this.GetEntity<T_SK_SECURITY_INSPECTION_NOTICE>(id, new string[] {"Nav_ApplyUser","Nav_ApplyDepartment","Nav_CheckType",
            "Nav_CheckNoticeDetails","Nav_CheckNoticeDetails.Nav_RiskArea","Nav_CheckNoticeDetails.Nav_Contents","Nav_CheckNoticeDetails.Nav_CheckNoticeDetailBasics.Nav_Law",
                    "Nav_CheckNoticeDetails.Nav_CheckNoticeDetailUsers.Nav_User","Nav_CheckNoticeFiles","Nav_CheckNoticeFiles.Nav_ImgFile"});
                //var taskId = filter.FilterGroup.Rules.FirstOrDefault(t => t.Field == "TASK_ID").Value;
                if (result != null && result.Nav_CheckNoticeDetails != null && result.Nav_CheckNoticeDetails.Any())// && taskId != null
                {
                    result.CHECK_PERSON = string.IsNullOrEmpty(result.CHECK_PERSON) ? "" : result.CHECK_PERSON;
                    var detailTemps = result.Nav_CheckNoticeDetails.ToList();//.Where(c => c.Nav_CheckNoticeDetailUsers != null && c.Nav_CheckNoticeDetailUsers.FirstOrDefault(m => m.USER_ID == loginUserId)?.USER_ID == loginUserId).ToList();
                    result.Nav_CheckNoticeDetails = detailTemps.GroupBy(t => t.RISK_AREA_ID).Select(g => g.First()).ToList();
                    if (result.Nav_CheckNoticeDetails != null && result.Nav_CheckNoticeDetails.Any())
                    {
                        foreach (var item in result.Nav_CheckNoticeDetails.OrderBy(t => t.RISK_AREA_ID).ThenBy(m => m.NUM))
                        {
                            item.Nav_DetailContents = new List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL>();
                            var userTemps = new List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_USER>();
                            var safeCheck1 = detailTemps.Where(t => t.RISK_AREA_ID == item.RISK_AREA_ID).ToList();
                            if (safeCheck1 != null && safeCheck1.Any())
                            {
                                safeCheck1 = safeCheck1.OrderBy(t => t.RISK_AREA_ID).ThenBy(m => m.NUM).ToList();
                                foreach (var item2 in safeCheck1)
                                {
                                    var lawTemps = new List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_BASIC>();
                                    T_SK_SECURITY_INSPECTION_NOTICE_DETAIL ddd = new T_SK_SECURITY_INSPECTION_NOTICE_DETAIL();
                                    ddd.CHECK_CONTENTS_ID = item2.CHECK_CONTENTS_ID;
                                    ddd.Nav_Contents = item2.Nav_Contents;
                                    ddd.CHECKCONTENT = item2.Nav_Contents != null ? item2.Nav_Contents.CHECKCONTENT : item2.CHECKCONTENT;
                                    ddd.CHECKPROOF = item2.CHECKPROOF;
                                    ddd.CHECKSTANDARD = item2.CHECKSTANDARD;
                                    if (item2.Nav_CheckNoticeDetailBasics != null && item2.Nav_CheckNoticeDetailBasics.Any())
                                    {
                                        foreach (var item3 in item2.Nav_CheckNoticeDetailBasics)
                                        {
                                            T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_BASIC uuu = new T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_BASIC();
                                            uuu.LAW_ID = item3.LAW_ID;
                                            uuu.Nav_Law = item3.Nav_Law;
                                            lawTemps.Add(uuu);
                                        }
                                    }
                                    ddd.Nav_CheckNoticeDetailBasics = lawTemps;
                                    item.Nav_DetailContents.Add(ddd);
                                    if (item2.Nav_CheckNoticeDetailUsers != null && item2.Nav_CheckNoticeDetailUsers.Any())
                                    {
                                        foreach (var item3 in item2.Nav_CheckNoticeDetailUsers.OrderByDescending(m => m.ISMAINCHECK))
                                        {
                                            T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_USER uuu = new T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_USER();
                                            uuu.USER_ID = item3.USER_ID;
                                            uuu.Nav_User = item3.Nav_User;
                                            var isExsist = userTemps.FirstOrDefault(t => t.USER_ID == item3.USER_ID);
                                            if (isExsist == null)
                                            {
                                                userTemps.Add(uuu);
                                            }
                                        }
                                    }

                                }
                            }
                            item.Nav_CheckNoticeDetailUsers = userTemps;
                        }
                    }
                }
                return result;
            });
        }
        /// <summary>
        /// 识别人确认
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        [HttpPost, Route("IdentityUpdate")]
        public JsonActionResult<bool> IdentityUpdate([FromBody] T_SK_SECURITY_INSPECTION_NOTICE entity)
        {
            return SafeExecute(() =>
            {
                T_FM_NOTIFICATION_TASK task = null;
                var record = this.GetEntity<T_SK_SECURITY_INSPECTION_NOTICE>(entity.ID, "Nav_CheckNoticeDetails", "Nav_CheckNoticeDetails.Nav_CheckNoticeDetailUsers.Nav_User");
                var userId = APT.Infrastructure.Api.AppContext.CurrentSession.UserID;
                if (entity.TaskID != Guid.Empty)
                {
                    var currTask = GetEntity<T_FM_NOTIFICATION_TASK>(t => t.ID == entity.TaskID);
                    if (currTask != null)
                    {
                        userId = currTask.USER_ID;
                    }
                }
                var detailIds = record.Nav_CheckNoticeDetails.Select(t => t.ID).ToList();
                var users = this.GetEntities<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_USER>(t => detailIds.Contains(t.SECURITY_INSPECTION_NOTICE_DETAIL_ID) && t.USER_ID == userId, new BaseFilter(record.ORG_ID)).ToList();
                users.ForEach(t =>
                {
                    t.ISCHECK = true;
                    t.CHECKTIME = DateTime.Now;
                });
                var todoCount = this.GetCount<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_USER>(t => detailIds.Contains(t.SECURITY_INSPECTION_NOTICE_DETAIL_ID) && t.USER_ID != userId && t.ISCHECK == false, new BaseFilter(record.ORG_ID));
                if (todoCount == 0)
                {
                    record.STATUS = PFStandardStatus.Archived;
                }
                if (entity.TaskID != Guid.Empty)
                {
                    task = NotificationTaskService.GetTaskFinishModel(entity.TaskID);
                    task.SOURCE_FORMCODE = "SK006_SHOWPRINT";
                }
                UnifiedCommit(() =>
                {
                    if (record != null)
                        this.UpdateEntityNoCommit(record);
                    if (users != null && users.Any())
                        this.BantchSaveEntityNoCommit(users);
                    if (task != null)
                        this.UpdateEntityNoCommit(task);
                });
                return true;
            });
        }

        /// <summary>
        /// 获得单条实体数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("SKGet")]
        public JsonActionResult<T_SK_SECURITY_INSPECTION_NOTICE> SKGet([FromBody] KeywordFilter filter)
        {
            return SafeExecute(() =>
            {
                var id = filter.FilterGroup.Rules.FirstOrDefault(t => t.Field == "ID").Value.ToString();
                if (string.IsNullOrEmpty(id))
                    this.ThrowError("060010");
                filter.IgnoreDataRule = true;
                var result = this.GetEntity<T_SK_SECURITY_INSPECTION_NOTICE>(id, new string[] { "Nav_ApplyUser", "Nav_ApplyDepartment","Nav_CheckType",
           "Nav_CheckNoticeFiles.Nav_ImgFile","Nav_ProductionUnit"});
                if (result != null)
                {
                    var details = this.GetEntities<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL>(t => t.SECURITY_INSPECTION_NOTICE_ID == result.ID, new BaseFilter(filter.OrgId), "Nav_RiskArea", "Nav_Contents", "Nav_CheckNoticeDetailBasics.Nav_Law");
                    if (details.Any())
                    {
                        var detailIds = details.Select(t => t.ID).ToList();
                        var users = this.GetEntities<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_USER>(t => detailIds.Contains(t.SECURITY_INSPECTION_NOTICE_DETAIL_ID), new BaseFilter(filter.OrgId), "Nav_User");
                        foreach (var detail in details)
                        {
                            var userTemps = users.Where(t => t.SECURITY_INSPECTION_NOTICE_DETAIL_ID == detail.ID).ToList();
                            detail.Nav_CheckNoticeDetailUsers = userTemps.OrderByDescending(t => t.ISMAINCHECK).ToList();
                        }
                    }
                    result.Nav_CheckNoticeDetails = details.OrderBy(t => t.RISK_AREA_ID).ThenBy(m => m.NUM).ToList();
                    if (result.STATUS == PFStandardStatus.Rejected)
                    {
                        result.CONTEXT = ApproveCallBackService.RejectContent(result.ID);
                    }
                }
                return result;
            });
        }

        /// <summary>
        /// 根据检查类型，检查层级，当前人所在生产单元及其岗位自动带出所有区域下的检查内容
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        [HttpPost, Route("GetCheckContentPCs")]
        public JsonActionResult<List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL>> GetCheckContentPCs([FromBody] KeywordFilter filter)
        {

            var result = new JsonActionResult<List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL>>();
            var dataList = new List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL>();
            if (!string.IsNullOrEmpty(filter.Parameter1) && !string.IsNullOrEmpty(filter.Parameter2) && !string.IsNullOrEmpty(filter.Parameter3) && !string.IsNullOrEmpty(filter.Parameter4))
            {
                var loginUserId = APT.Infrastructure.Api.AppContext.CurrentSession.UserID;
                var departId = APT.Infrastructure.Api.AppContext.CurrentSession.DepartmentID;
                //var personId = this.GetEntity<T_FM_USER>(t => t.ID == loginUserId && t.ENABLE_STATUS == 0)?.PERSON_ID;
                //if (personId == null)
                //    throw new Exception("用户数据异常，请联系管理员排查");
                //var postId = this.GetEntity<T_FM_PERSON>(t => t.ID == personId)?.POST_ID;
                //if (postId == null)
                //    throw new Exception("请先维护登陆人岗位");
                var departType = SKDepartmentTypeEnum.部门级;
                if (filter.Parameter3 == "0")
                {
                    departType = SKDepartmentTypeEnum.部门级;
                }
                else if (filter.Parameter3 == "1")
                {
                    departType = SKDepartmentTypeEnum.车间级;
                }
                else if (filter.Parameter3 == "2")
                {
                    departType = SKDepartmentTypeEnum.班组级;
                }
                else if (filter.Parameter3 == "3")
                {
                    departType = SKDepartmentTypeEnum.公司级;
                }
                else if (filter.Parameter3 == "4")
                {
                    departType = SKDepartmentTypeEnum.班组级;
                }
                else
                {
                    throw new Exception("检查层级错误");
                }
                var cycle = SKPLANCHECKFREQUENCYEnum.Date;
                if (filter.Parameter4 == "20")
                {
                    cycle = SKPLANCHECKFREQUENCYEnum.Week;
                }
                else if (filter.Parameter4 == "30")
                {
                    cycle = SKPLANCHECKFREQUENCYEnum.Month;
                }
                else if (filter.Parameter4 == "40")
                {
                    cycle = SKPLANCHECKFREQUENCYEnum.Quarter;
                }
                else if (filter.Parameter4 == "50")
                {
                    cycle = SKPLANCHECKFREQUENCYEnum.HalfYear;
                }
                else if (filter.Parameter4 == "60")
                {
                    cycle = SKPLANCHECKFREQUENCYEnum.Year;
                }
                else
                {
                    throw new Exception("检查周期错误");
                }
                var libs = this.GetEntities<T_SK_ENTERPRISE_LIBRARY>(t => t.PRODUCTION_UNIT_ID == Guid.Parse(filter.Parameter1), new BaseFilter(filter.OrgId),"Nav_Area").ToList();
                var libIds = libs.Select(m=>m.ID).ToList();
                var details = this.GetEntities<T_SK_ENTERPRISE_LIBRARY_DETAIL>(t => libIds.Contains(t.ENTERPRISE_LIBRARY_ID), new BaseFilter(filter.OrgId)).ToList();
                var detailIds = details.Select(m => m.ID).ToList();
                var contents = this.GetEntities<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT>(t => detailIds.Contains(t.ENTERPRISE_LIBRARY_DETAIL_ID), new BaseFilter(filter.OrgId), "Nav_Contents").ToList();
                var contentIds = contents.Select(m=>m.ID).ToList();
                var departs = this.GetEntities<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART>(t => contentIds.Contains(t.ENTERPRISE_LIBRARY_DETAIL_CONTENT_ID) &&  t.DEPARTMENT_ID == departId && t.CHECK_TYPE_ID == Guid.Parse(filter.Parameter2) && t.CHECK_TYPE == departType && t.CHECK_CYCLE == cycle, new BaseFilter(filter.OrgId));
                var contentDepIds = departs.Select(t => t.ENTERPRISE_LIBRARY_DETAIL_CONTENT_ID).ToList();
                var libraryContents = contents.Where(t => contentDepIds.Contains(t.ID)).ToList();
                if (libraryContents != null && libraryContents.Any())
                {
                    foreach (var item in libraryContents)
                    {
                        var detailFist = details.FirstOrDefault(t => t.ID == item.ENTERPRISE_LIBRARY_DETAIL_ID);
                        var libFirst= libs.FirstOrDefault(t => t.ID == detailFist?.ENTERPRISE_LIBRARY_ID);
                        T_SK_SECURITY_INSPECTION_NOTICE_DETAIL detail = new T_SK_SECURITY_INSPECTION_NOTICE_DETAIL();
                        detail.ORG_ID = filter.OrgId;
                        detail.RISK_AREA_ID = libFirst?.AREA_ID;
                        detail.Nav_RiskArea = libFirst?.Nav_Area;
                        detail.CHECK_CONTENTS_ID = item.CHECK_CONTENTS_ID;
                        detail.Nav_Contents = item.Nav_Contents;
                        detail.CHECKCONTENT = item.CHECK_CONTENT;
                        detail.CHECKPROOF = item.CHECK_BASIC;
                        detail.CHECKSTANDARD = item.CHECK_STANDARD;
                        detail.Nav_CheckNoticeDetailUsers = null;
                        dataList.Add(detail);
                    }
                    if (dataList != null && dataList.Any())
                    {
                        result.Data = dataList.OrderBy(t => t.RISK_AREA_ID).ToList();
                    }
                }
            }
            return result;
        }
        /// <summary>
        /// 根据检查类型，检查层级，当前人所在生产单元及其岗位自动带出所有区域下的检查内容
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        [HttpPost, Route("GetCheckContents")]
        public JsonActionResult<List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL>> GetCheckContents([FromBody] KeywordFilter filter)
        {

            var result = new JsonActionResult<List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL>>();
            var dataList = new List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL>();
            if (!string.IsNullOrEmpty(filter.Parameter1) && !string.IsNullOrEmpty(filter.Parameter2) && !string.IsNullOrEmpty(filter.Parameter3) && !string.IsNullOrEmpty(filter.Parameter4))
            {
                var loginUserId = APT.Infrastructure.Api.AppContext.CurrentSession.UserID;
                var departId = APT.Infrastructure.Api.AppContext.CurrentSession.DepartmentID;
                //var personId = this.GetEntity<T_FM_USER>(t => t.ID == loginUserId && t.ENABLE_STATUS == 0)?.PERSON_ID;
                //if (personId == null)
                //    throw new Exception("用户数据异常，请联系管理员排查");
                //var postId = this.GetEntity<T_FM_PERSON>(t => t.ID == personId)?.POST_ID;
                //if (postId == null)
                //    throw new Exception("请先维护登陆人岗位");
                //var mineType = SKProductionUnit.Mine;
                //if (filter.Parameter1 == "30")
                //{
                //    mineType = SKProductionUnit.Mine;
                //}
                //else if (filter.Parameter1 == "10")
                //{
                //    mineType = SKProductionUnit.MineChoose;
                //}
                //else if (filter.Parameter1 == "20")
                //{
                //    mineType = SKProductionUnit.Minelast;
                //}
                //else if (filter.Parameter1 == "0")
                //{
                //    mineType = SKProductionUnit.All;
                //}
                //else if (filter.Parameter1 == "40")
                //{
                //    mineType = SKProductionUnit.MineUnderGround;
                //}
                //else if (filter.Parameter1 == "31")
                //{
                //    mineType = SKProductionUnit.Department;
                //}
                //else if (filter.Parameter1 == "32")
                //{
                //    mineType = SKProductionUnit.Nonmetallic;
                //}
                //else
                //{
                //    throw new Exception("生产单元错误");
                //}
                var departType = SKDepartmentTypeEnum.部门级;
                if (filter.Parameter3 == "0")
                {
                    departType = SKDepartmentTypeEnum.部门级;
                }
                else if (filter.Parameter3 == "1")
                {
                    departType = SKDepartmentTypeEnum.车间级;
                }
                else if (filter.Parameter3 == "2")
                {
                    departType = SKDepartmentTypeEnum.班组级;
                }
                else if (filter.Parameter3 == "3")
                {
                    departType = SKDepartmentTypeEnum.公司级;
                }
                else if (filter.Parameter3 == "4")
                {
                    departType = SKDepartmentTypeEnum.班组级;
                }
                else
                {
                    throw new Exception("检查层级错误");
                }
                var cycle = SKPLANCHECKFREQUENCYEnum.Date;
                if (filter.Parameter4 == "20")
                {
                    cycle = SKPLANCHECKFREQUENCYEnum.Week;
                }
                else if (filter.Parameter4 == "30")
                {
                    cycle = SKPLANCHECKFREQUENCYEnum.Month;
                }
                else if (filter.Parameter4 == "40")
                {
                    cycle = SKPLANCHECKFREQUENCYEnum.Quarter;
                }
                else if (filter.Parameter4 == "50")
                {
                    cycle = SKPLANCHECKFREQUENCYEnum.HalfYear;
                }
                else if (filter.Parameter4 == "60")
                {
                    cycle = SKPLANCHECKFREQUENCYEnum.Year;
                }
                else
                {
                    throw new Exception("检查周期错误");
                }
                var libs = this.GetEntities<T_SK_ENTERPRISE_LIBRARY>(t => t.PRODUCTION_UNIT_ID == Guid.Parse(filter.Parameter1), new BaseFilter(filter.OrgId), "Nav_Area").ToList();
                var libIds = libs.Select(m => m.ID).ToList();
                var details = this.GetEntities<T_SK_ENTERPRISE_LIBRARY_DETAIL>(t => libIds.Contains(t.ENTERPRISE_LIBRARY_ID), new BaseFilter(filter.OrgId)).ToList();
                var detailIds = details.Select(m => m.ID).ToList();
                var libContents = this.GetEntities<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT>(t => detailIds.Contains(t.ENTERPRISE_LIBRARY_DETAIL_ID), new BaseFilter(filter.OrgId), "Nav_Contents").ToList();
                var contentIds = libContents.Select(m => m.ID).ToList();
                var departs = this.GetEntities<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART>(t => contentIds.Contains(t.ENTERPRISE_LIBRARY_DETAIL_CONTENT_ID) && t.DEPARTMENT_ID == departId && t.CHECK_TYPE_ID == Guid.Parse(filter.Parameter2) && t.CHECK_TYPE == departType && t.CHECK_CYCLE == cycle, new BaseFilter(filter.OrgId));
                var contentDepIds = departs.Select(t => t.ENTERPRISE_LIBRARY_DETAIL_CONTENT_ID).ToList();
                var libraryContents = libContents.Where(t => contentDepIds.Contains(t.ID)).ToList();
                if (libraryContents != null && libraryContents.Any())
                {
                    foreach (var item in libraryContents)
                    {
                        T_SK_SECURITY_INSPECTION_NOTICE_DETAIL detail = new T_SK_SECURITY_INSPECTION_NOTICE_DETAIL();
                        detail.ORG_ID = filter.OrgId;
                        detail.RISK_AREA_ID = item.Nav_LibraryDetail?.Nav_Library?.AREA_ID;
                        detail.Nav_RiskArea = item.Nav_LibraryDetail?.Nav_Library?.Nav_Area;
                        detail.CHECK_CONTENTS_ID = item.CHECK_CONTENTS_ID;
                        detail.Nav_Contents = item.Nav_Contents;
                        detail.CHECKCONTENT = item.CHECK_CONTENT;
                        detail.CHECKPROOF = item.CHECK_BASIC;
                        detail.CHECKSTANDARD = item.CHECK_STANDARD;
                        detail.Nav_CheckNoticeDetailUsers = null;
                        dataList.Add(detail);
                    }
                    if (dataList != null && dataList.Any())
                    {
                        var newList = new List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL>();
                        var tempIds = dataList.Select(x => x.RISK_AREA_ID).Distinct().ToList();
                        foreach (var temp in tempIds)
                        {
                            var mmm = dataList.FirstOrDefault(t => t.RISK_AREA_ID == temp);
                            T_SK_SECURITY_INSPECTION_NOTICE_DETAIL detail = new T_SK_SECURITY_INSPECTION_NOTICE_DETAIL();
                            detail.ORG_ID = filter.OrgId;
                            detail.RISK_AREA_ID = temp;
                            detail.Nav_RiskArea = mmm?.Nav_RiskArea;
                            detail.Nav_CheckNoticeDetailUsers = null;
                            var ttt = dataList.Where(t => t.RISK_AREA_ID == temp).ToList();
                            if (ttt.Any())
                            {
                                List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL> contents = new List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL>();
                                foreach (var hh in ttt)
                                {
                                    T_SK_SECURITY_INSPECTION_NOTICE_DETAIL content = new T_SK_SECURITY_INSPECTION_NOTICE_DETAIL();
                                    content.ORG_ID = filter.OrgId;
                                    content.CHECK_CONTENTS_ID = hh.CHECK_CONTENTS_ID;
                                    content.CHECKCONTENT = hh.CHECKCONTENT;
                                    content.CHECKPROOF = hh.CHECKPROOF;
                                    content.CHECKSTANDARD = hh.CHECKSTANDARD;
                                    contents.Add(content);
                                }
                                detail.Nav_DetailContents = contents;
                            }
                            newList.Add(detail);
                        }
                        result.Data = newList.OrderBy(t => t.RISK_AREA_ID).ToList();
                    }
                }
            }
            return result;
        }

        /// <summary>
        /// 回调函数
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        [HttpPost, Route("BackUpdateNew")]
        public JsonActionResult<bool> BackUpdateNew([FromBody] T_PF_APPROVE entity)
        {
            return SafeExecute(() =>
            {
                return ApproveCallBackService.CallBackNew("SK/SKSecurityInspectionNotice/BackUpdateNew", entity);
            });
        }
        /// <summary>
        /// 驳回
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost, Route("RejectUpdate")]
        public JsonActionResult<bool> RejectUpdate([FromBody] T_PF_APPROVE model)
        {
            return SafeExecute(() =>
            {
                //公共 获取审批流信息
                T_PF_APPROVE modelApp = null;
                List<T_PF_APPROVE_DETAIL> listAppDetail = null;
                T_FM_NOTIFICATION_TASK taskFinish = null;
                string Msg = string.Empty;
                bool ResultGetInfo = ApproveCallBackService.GetApproject(model, ref modelApp, ref listAppDetail, ref taskFinish, ref Msg);
                if (!ResultGetInfo)
                    throw new Exception("驳回失败！");
                if (modelApp == null || listAppDetail == null)
                    throw new Exception("获取驳回信息失败！");
                var entity = this.GetEntity<T_SK_SECURITY_INSPECTION_NOTICE>(model.DATA_ID, new string[] { "Nav_ApplyUser" });
                entity.STATUS = PFStandardStatus.Rejected;
                T_FM_NOTIFICATION_TASK notice = new T_FM_NOTIFICATION_TASK();
                if (entity.APPLY_USER_ID != null)
                {
                    //发消息
                    notice = NotificationTaskService.InsertUserNoticeTaskModel("安全检查通知表被驳回", entity.ID, entity.ORG_ID, (Guid)entity.APPLY_USER_ID, entity.Nav_ApplyUser?.NAME, DateTime.Now,
               DateTime.Now.AddHours(24), (int)FMNoticeTypeEnum.消息, "SK006");
                }
                UnifiedCommit(() =>
                {
                    if (entity != null)
                        this.UpdateEntityNoCommit(entity);
                    if (notice != null)
                        this.UpdateEntityNoCommit(notice);
                    if (modelApp != null)
                        UpdateEntityNoCommit(modelApp);
                    if (listAppDetail != null && listAppDetail.Count > 0)
                        BantchUpdateEntityNoCommit(listAppDetail);
                    if (taskFinish != null)
                        UpdateEntityNoCommit(taskFinish);
                });
                return true;
                //return ApproveCallBackService.CallReject("HM/HMLicenseAnalysis/RejectUpdate", id);
            });
        }

        /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("SKOrderEntities")]
        public JsonActionResult<IEnumerable<List<OperateLogDto>>> SKOrderEntities([FromBody] KeywordFilter filter)
        {
            return SafeExecute<IEnumerable<List<OperateLogDto>>>(() =>
            {
                if (string.IsNullOrEmpty(filter.Keyword))
                {
                    return new List<List<OperateLogDto>>();
                }
                else
                {
                    Guid Keyword = new Guid(filter.Keyword);
                    Guid? NoticeID = null;
                    Guid? RecordID = null;
                    Guid? RecordSummaryID = null;
                    Guid? ReportID = null;
                    Guid? RectifyNoticeID = null;
                    Guid? RectifyRecordID = null;
                    Guid? ConfirmID = null;
                    List<Guid> sourceIds = new List<Guid>();
                    var check = GetEntity<T_SK_SECURITY_INSPECTION_NOTICE>(Keyword);
                    T_SK_SECURITY_INSPECTION_RECORD record = null;
                    T_SK_HIDDEN_DANGER_HAND_REPORT risk = null;
                    if (check != null)
                    {
                        NoticeID = check.ID;
                        sourceIds.Add(check.ID);
                        var recordTemp = GetEntity<T_SK_SECURITY_INSPECTION_RECORD>(e => e.SECURITY_INSPECTION_NOTICE_ID != null && e.SECURITY_INSPECTION_NOTICE_ID == NoticeID.Value);
                        if (recordTemp != null)
                        {
                            RecordID = recordTemp.ID;
                            sourceIds.Add(recordTemp.ID);
                            var recordSummaryTemp = GetEntity<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY>(e => e.SECURITY_INSPECTION_RECORD_ID != null && e.SECURITY_INSPECTION_RECORD_ID == recordTemp.ID);
                            if (recordSummaryTemp != null)
                            {
                                RecordSummaryID = recordSummaryTemp.ID;
                                sourceIds.Add(recordSummaryTemp.ID);
                                var hiddenReport = GetEntity<T_SK_HIDDEN_DANGER_REPORT>(e => e.SECURITY_INSPECTION_RECORD_SUMMARY_ID != null && e.SECURITY_INSPECTION_RECORD_SUMMARY_ID == recordSummaryTemp.ID);
                                if (hiddenReport != null)
                                {
                                    ReportID = hiddenReport.ID;
                                    sourceIds.Add(hiddenReport.ID);
                                    var rectifyNotice = GetEntity<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE>(e => e.HIDDEN_DANGER_REPORT_ID != null && e.HIDDEN_DANGER_REPORT_ID == hiddenReport.ID);
                                    if (rectifyNotice != null)
                                    {
                                        RectifyNoticeID = rectifyNotice.ID;
                                        sourceIds.Add(rectifyNotice.ID);
                                        var rectifyRecord = GetEntity<T_SK_HIDDEN_DANGER_RECTIFY_RECORD>(e => e.HIDDEN_DANGER_RECTIFY_NOTICE_ID != null && e.HIDDEN_DANGER_RECTIFY_NOTICE_ID == rectifyNotice.ID);
                                        if (rectifyRecord != null)
                                        {
                                            RectifyRecordID = rectifyRecord.ID;
                                            sourceIds.Add(rectifyRecord.ID);
                                        }
                                        else
                                        {
                                            rectifyRecord = GetEntity<T_SK_HIDDEN_DANGER_RECTIFY_RECORD>(e => e.HIDDEN_DANGER_REPORT_ID != null && e.HIDDEN_DANGER_REPORT_ID == hiddenReport.ID);
                                            if (rectifyRecord != null)
                                            {
                                                RectifyRecordID = rectifyRecord.ID;
                                                sourceIds.Add(rectifyRecord.ID);
                                            }
                                        }
                                    }
                                    else
                                    {
                                        var rectifyRecord = GetEntity<T_SK_HIDDEN_DANGER_RECTIFY_RECORD>(e => e.HIDDEN_DANGER_REPORT_ID != null && e.HIDDEN_DANGER_REPORT_ID == hiddenReport.ID);
                                        if (rectifyRecord != null)
                                        {
                                            RectifyRecordID = rectifyRecord.ID;
                                            sourceIds.Add(rectifyRecord.ID);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        record = GetEntity<T_SK_SECURITY_INSPECTION_RECORD>(Keyword);
                        if (record != null)
                        {
                            RecordID = record.ID;
                            sourceIds.Add(record.ID);
                            var recordSummaryTemp = GetEntity<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY>(e => e.SECURITY_INSPECTION_RECORD_ID != null && e.SECURITY_INSPECTION_RECORD_ID == record.ID);
                            if (recordSummaryTemp != null)
                            {
                                RecordSummaryID = recordSummaryTemp.ID;
                                sourceIds.Add(recordSummaryTemp.ID);
                                var hiddenReport = GetEntity<T_SK_HIDDEN_DANGER_REPORT>(e => e.SECURITY_INSPECTION_RECORD_SUMMARY_ID != null && e.SECURITY_INSPECTION_RECORD_SUMMARY_ID == recordSummaryTemp.ID);
                                if (hiddenReport != null)
                                {
                                    ReportID = hiddenReport.ID;
                                    sourceIds.Add(hiddenReport.ID);
                                    var rectifyNotice = GetEntity<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE>(e => e.HIDDEN_DANGER_REPORT_ID != null && e.HIDDEN_DANGER_REPORT_ID == hiddenReport.ID);
                                    if (rectifyNotice != null)
                                    {
                                        RectifyNoticeID = rectifyNotice.ID;
                                        sourceIds.Add(rectifyNotice.ID);
                                        var rectifyRecord = GetEntity<T_SK_HIDDEN_DANGER_RECTIFY_RECORD>(e => e.HIDDEN_DANGER_RECTIFY_NOTICE_ID != null && e.HIDDEN_DANGER_RECTIFY_NOTICE_ID == rectifyNotice.ID);
                                        if (rectifyRecord != null)
                                        {
                                            RectifyRecordID = rectifyRecord.ID;
                                            sourceIds.Add(rectifyRecord.ID);
                                        }
                                        else
                                        {
                                            rectifyRecord = GetEntity<T_SK_HIDDEN_DANGER_RECTIFY_RECORD>(e => e.HIDDEN_DANGER_REPORT_ID != null && e.HIDDEN_DANGER_REPORT_ID == hiddenReport.ID);
                                            if (rectifyRecord != null)
                                            {
                                                RectifyRecordID = rectifyRecord.ID;
                                                sourceIds.Add(rectifyRecord.ID);
                                            }
                                        }
                                    }
                                    else
                                    {
                                        var rectifyRecord = GetEntity<T_SK_HIDDEN_DANGER_RECTIFY_RECORD>(e => e.HIDDEN_DANGER_REPORT_ID != null && e.HIDDEN_DANGER_REPORT_ID == hiddenReport.ID);
                                        if (rectifyRecord != null)
                                        {
                                            RectifyRecordID = rectifyRecord.ID;
                                            sourceIds.Add(rectifyRecord.ID);
                                        }
                                    }
                                }
                            }
                        }
                        else
                        {
                            risk = GetEntity<T_SK_HIDDEN_DANGER_HAND_REPORT>(Keyword);
                            if (risk != null)
                            {
                                ReportID = risk.ID;
                                sourceIds.Add(risk.ID);
                                var confirm = GetEntity<T_SK_HIDDEN_DANGER_CONFIRM>(e => e.HIDDEN_DANGER_HAND_REPORT_ID != null && e.HIDDEN_DANGER_HAND_REPORT_ID == risk.ID);
                                if (confirm != null)
                                {
                                    ConfirmID = confirm.ID;
                                    sourceIds.Add(confirm.ID);
                                    var rectifyNotice = GetEntity<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE>(e => e.HIDDEN_DANGER_CONFIRM_ID != null && e.HIDDEN_DANGER_CONFIRM_ID == confirm.ID);
                                    if (rectifyNotice != null)
                                    {
                                        RectifyNoticeID = rectifyNotice.ID;
                                        sourceIds.Add(rectifyNotice.ID);
                                        var rectifyRecord = GetEntity<T_SK_HIDDEN_DANGER_RECTIFY_RECORD>(e => e.HIDDEN_DANGER_RECTIFY_NOTICE_ID != null && e.HIDDEN_DANGER_RECTIFY_NOTICE_ID == rectifyNotice.ID);
                                        if (rectifyRecord != null)
                                        {
                                            RectifyRecordID = rectifyRecord.ID;
                                            sourceIds.Add(rectifyRecord.ID);
                                        }
                                    }
                                    else
                                    {
                                        var rectifyRecord = GetEntity<T_SK_HIDDEN_DANGER_RECTIFY_RECORD>(e => e.HIDDEN_DANGER_CONFIRM_ID != null && e.HIDDEN_DANGER_CONFIRM_ID == confirm.ID);
                                        if (rectifyRecord != null)
                                        {
                                            RectifyRecordID = rectifyRecord.ID;
                                            sourceIds.Add(rectifyRecord.ID);
                                        }
                                    }
                                }
                            }
                        }
                    }

                    List<List<OperateLogDto>> result = new List<List<OperateLogDto>>();
                    if (NoticeID == null && RecordID == null && ReportID == null)
                    {
                        return result;
                    }
                    var approves = new List<T_PF_APPROVE>();
                    var approveIds = new List<Guid>();
                    if (sourceIds != null && sourceIds.Any())
                    {
                        approves = GetEntities<T_PF_APPROVE>(e => sourceIds.Contains(e.DATA_ID), null, null).ToList();
                        approveIds = approves.Select(m => m.ID).ToList();
                    }
                    var approveDetails = new List<T_PF_APPROVE_DETAIL>();
                    if (approveIds != null && approveIds.Any())
                    {
                        approveDetails = GetEntities<T_PF_APPROVE_DETAIL>(e => approveIds.Contains(e.APPROVE_ID), null, null).ToList();
                    }
                    var tasks = GetEntities<T_FM_NOTIFICATION_TASK>(e => e.SOURCE_DATA_ID != null && (sourceIds.Contains(e.SOURCE_DATA_ID.Value) || approveIds.Contains(e.SOURCE_DATA_ID.Value)), null, null).OrderBy(t => t.CREATE_TIME).ToList();
                    List<OperateLogDto> resultCheck1 = new List<OperateLogDto>();//检查任务
                    List<OperateLogDto> resultCheck2 = new List<OperateLogDto>();//检查记录
                    List<OperateLogDto> resultCheck3 = new List<OperateLogDto>();//检查记录汇总
                    List<OperateLogDto> resultRisk1 = new List<OperateLogDto>();//隐患上报
                    List<OperateLogDto> resultRisk2 = new List<OperateLogDto>();//隐患确认单
                    List<OperateLogDto> resultRiskDeal = new List<OperateLogDto>();//隐患整改通知
                    List<OperateLogDto> resultRiskEnd = new List<OperateLogDto>();//隐患整改记录
                    var users = GetEntities<T_FM_USER>(e => e.ENABLE_STATUS == 0, null, null);
                    #region 安全检查通知
                    if (NoticeID != null)
                    {
                        var tempIds = approves.Where(t => t.DATA_ID == NoticeID).OrderBy(m => m.CREATE_TIME).Select(x => x.ID).ToList();
                        var temp1 = tasks.Where(t => t.SOURCE_DATA_ID == NoticeID || tempIds.Contains(t.SOURCE_DATA_ID.Value)).OrderBy(t => t.CREATE_TIME).ToList();
                        if (temp1.Any())
                        {
                            foreach (var item in temp1)
                            {
                                OperateLogDto start = new OperateLogDto();
                                start.LOGTYPE = SKLOGTYPE_Enums.SafeCheck;
                                start.DATA_ID = NoticeID.Value;
                                if (tempIds.Contains(item.SOURCE_DATA_ID.Value))
                                {
                                    if (item.NOTICE_TITLE.Contains("驳回"))
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.NoticeReject;
                                    }
                                    else
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.NoticeAudit;
                                    }
                                }
                                else
                                {
                                    if (item.NOTICE_TITLE.Contains("确认"))
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.NoticeCheck;
                                    }
                                    else
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.GotNotice;
                                    }
                                }
                                if (item.NOTICE_STATUS == 4)
                                { start.OPERATEPOINT = SKOPERATEPOINT_Enums.CloseNotice; }
                                start.USER_ID = item.USER_ID;
                                start.USRTNAME = item.USER_NAME;
                                start.OPERTETIME = item.TASK_DT;
                                start.ORDERTIME = item.CREATE_TIME;
                                start.ISINTTIME = (item.NOTICE_STATUS == 4 || item.NOTICE_STATUS == 2) ? false : item.NOTICE_STATUS == 1 ? true : DateTime.Now > item.TASK_ENDDT ? false : true;
                                resultCheck1.Add(start);
                            }
                        }
                        var taskApprove = tasks.FirstOrDefault(t => tempIds.Contains(t.SOURCE_DATA_ID.Value));
                        if (tempIds.Any() && taskApprove == null)
                        {
                            var approveTemp = approves.FirstOrDefault(t => t.DATA_ID == NoticeID);
                            if (approveTemp != null)
                            {
                                var approveDetailTemp = approveDetails.FirstOrDefault(t => t.APPROVE_ID == approveTemp.ID);
                                if (approveDetailTemp != null)
                                {
                                    OperateLogDto start = new OperateLogDto();
                                    start.LOGTYPE = SKLOGTYPE_Enums.SafeCheck;
                                    start.DATA_ID = NoticeID.Value;
                                    start.OPERATEPOINT = SKOPERATEPOINT_Enums.NoticeAudit;
                                    start.USER_ID = approveDetailTemp.APPROVE_USER_ID.Value;
                                    start.USRTNAME = users.FirstOrDefault(t => t.ID == approveDetailTemp.APPROVE_USER_ID)?.NAME;
                                    start.OPERTETIME = approveDetailTemp.NODE_APPROVE_TIME;
                                    start.ORDERTIME = approveDetailTemp.CREATE_TIME;
                                    start.ISINTTIME = true;
                                    resultCheck1.Add(start);
                                }
                            }
                        }
                        resultCheck1 = resultCheck1.OrderBy(e => e.ORDERTIME).ThenBy(m => m.OPERTETIME).ThenBy(n => n.OPERATEPOINT).ToList();
                        if (resultCheck1.Any())
                        {
                            result.Add(resultCheck1);
                        }
                    }
                    else
                    {
                        result.Add(resultCheck1);
                    }
                    #endregion
                    #region 安全检查记录
                    if (RecordID != null)
                    {
                        var tempIds = approves.Where(t => t.DATA_ID == RecordID).OrderBy(m => m.CREATE_TIME).Select(x => x.ID).ToList();
                        var temp1 = tasks.Where(t => t.SOURCE_DATA_ID == RecordID || tempIds.Contains(t.SOURCE_DATA_ID.Value)).OrderBy(t => t.CREATE_TIME).ToList();
                        if (temp1.Any())
                        {
                            foreach (var item in temp1)
                            {
                                OperateLogDto start = new OperateLogDto();
                                start.LOGTYPE = SKLOGTYPE_Enums.SafeRecord;
                                start.DATA_ID = RecordID.Value;
                                if (tempIds.Contains(item.SOURCE_DATA_ID.Value))
                                {
                                    if (item.NOTICE_TITLE.Contains("驳回"))
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.RecordReject;
                                    }
                                    else
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.RecordAudit;
                                    }
                                }
                                else
                                {
                                    if (item.NOTICE_TITLE.Contains("确认"))
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.RecordCheck;
                                    }
                                    else
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.GotRecord;
                                    }
                                }
                                if (item.NOTICE_STATUS == 4)
                                { start.OPERATEPOINT = SKOPERATEPOINT_Enums.CloseNotice; }
                                start.USER_ID = item.USER_ID;
                                start.USRTNAME = item.USER_NAME;
                                start.OPERTETIME = item.TASK_DT;
                                start.ORDERTIME = item.CREATE_TIME;
                                start.ISINTTIME = (item.NOTICE_STATUS == 4 || item.NOTICE_STATUS == 2) ? false : item.NOTICE_STATUS == 1 ? true : DateTime.Now > item.TASK_ENDDT ? false : true;
                                resultCheck2.Add(start);
                            }
                        }
                        var taskApprove = tasks.FirstOrDefault(t => tempIds.Contains(t.SOURCE_DATA_ID.Value));
                        if (tempIds.Any() && taskApprove == null)
                        {
                            var approveTemp = approves.FirstOrDefault(t => t.DATA_ID == RecordID);
                            if (approveTemp != null)
                            {
                                var approveDetailTemp = approveDetails.FirstOrDefault(t => t.APPROVE_ID == approveTemp.ID);
                                if (approveDetailTemp != null)
                                {
                                    OperateLogDto start = new OperateLogDto();
                                    start.LOGTYPE = SKLOGTYPE_Enums.SafeRecord;
                                    start.DATA_ID = RecordID.Value;
                                    start.OPERATEPOINT = SKOPERATEPOINT_Enums.NoticeAudit;
                                    start.USER_ID = approveDetailTemp.APPROVE_USER_ID.Value;
                                    start.USRTNAME = users.FirstOrDefault(t => t.ID == approveDetailTemp.APPROVE_USER_ID)?.NAME;
                                    start.OPERTETIME = approveDetailTemp.NODE_APPROVE_TIME;
                                    start.ORDERTIME = approveDetailTemp.CREATE_TIME;
                                    start.ISINTTIME = true;
                                    resultCheck2.Add(start);
                                }
                            }
                        }
                        resultCheck2 = resultCheck2.OrderBy(e => e.ORDERTIME).ThenBy(m => m.OPERTETIME).ThenBy(n => n.OPERATEPOINT).ToList();
                        if (resultCheck2.Any())
                        {
                            result.Add(resultCheck2);
                        }
                    }
                    else
                    {
                        result.Add(resultCheck2);
                    }
                    #endregion
                    #region 安全检查记录汇总
                    if (RecordSummaryID != null)
                    {
                        var tempIds = approves.Where(t => t.DATA_ID == RecordSummaryID).OrderBy(m => m.CREATE_TIME).Select(x => x.ID).ToList();
                        var temp1 = tasks.Where(t => t.SOURCE_DATA_ID == RecordSummaryID || tempIds.Contains(t.SOURCE_DATA_ID.Value)).OrderBy(t => t.CREATE_TIME).ToList();
                        if (temp1.Any())
                        {
                            foreach (var item in temp1)
                            {
                                OperateLogDto start = new OperateLogDto();
                                start.LOGTYPE = SKLOGTYPE_Enums.SafeRecord;
                                start.DATA_ID = RecordSummaryID.Value;
                                if (tempIds.Contains(item.SOURCE_DATA_ID.Value))
                                {
                                    if (item.NOTICE_TITLE.Contains("驳回"))
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.RecordSummaryReject;
                                    }
                                    else
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.RecordSummaryAudit;
                                    }
                                }
                                else
                                {
                                    if (item.NOTICE_TITLE.Contains("确认"))
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.RecordSummaryCheck;
                                    }
                                    else
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.GotRecordSummary;
                                    }
                                }
                                start.USER_ID = item.USER_ID;
                                start.USRTNAME = item.USER_NAME;
                                start.OPERTETIME = item.TASK_DT;
                                start.ORDERTIME = item.CREATE_TIME;
                                start.ISINTTIME = (item.NOTICE_STATUS == 4 || item.NOTICE_STATUS == 2) ? false : item.NOTICE_STATUS == 1 ? true : DateTime.Now > item.TASK_ENDDT ? false : true;
                                resultCheck3.Add(start);
                            }
                        }
                        var taskApprove = tasks.FirstOrDefault(t => tempIds.Contains(t.SOURCE_DATA_ID.Value));
                        if (tempIds.Any() && taskApprove == null)
                        {
                            var approveTemp = approves.FirstOrDefault(t => t.DATA_ID == RecordSummaryID);
                            if (approveTemp != null)
                            {
                                var approveDetailTemp = approveDetails.FirstOrDefault(t => t.APPROVE_ID == approveTemp.ID);
                                if (approveDetailTemp != null)
                                {
                                    OperateLogDto start = new OperateLogDto();
                                    start.LOGTYPE = SKLOGTYPE_Enums.SafeRecord;
                                    start.DATA_ID = RecordSummaryID.Value;
                                    start.OPERATEPOINT = SKOPERATEPOINT_Enums.NoticeAudit;
                                    start.USER_ID = approveDetailTemp.APPROVE_USER_ID.Value;
                                    start.USRTNAME = users.FirstOrDefault(t => t.ID == approveDetailTemp.APPROVE_USER_ID)?.NAME;
                                    start.OPERTETIME = approveDetailTemp.NODE_APPROVE_TIME;
                                    start.ORDERTIME = approveDetailTemp.CREATE_TIME;
                                    start.ISINTTIME = true;
                                    resultCheck3.Add(start);
                                }
                            }
                        }
                        resultCheck3 = resultCheck3.OrderBy(e => e.ORDERTIME).ThenBy(m => m.OPERTETIME).ThenBy(n => n.OPERATEPOINT).ToList();
                        if (resultCheck3.Any())
                        {
                            result.Add(resultCheck3);
                        }
                    }
                    else
                    {
                        result.Add(resultCheck3);
                    }
                    #endregion

                    #region 隐患上报
                    if (ReportID != null)
                    {
                        var tempIds = approves.Where(t => t.DATA_ID == ReportID).OrderBy(m => m.CREATE_TIME).Select(x => x.ID).ToList();
                        var temp1 = tasks.Where(t => t.SOURCE_DATA_ID == ReportID || tempIds.Contains(t.SOURCE_DATA_ID.Value)).OrderBy(t => t.CREATE_TIME).ToList();
                        if (temp1.Any())
                        {
                            foreach (var item in temp1)
                            {
                                OperateLogDto start = new OperateLogDto();
                                start.LOGTYPE = SKLOGTYPE_Enums.RiskSubmit;
                                start.DATA_ID = ReportID.Value;
                                if (tempIds.Contains(item.SOURCE_DATA_ID.Value))
                                {
                                    if (item.NOTICE_TITLE.Contains("驳回"))
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.HiddenReject;
                                    }
                                    else
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.HiddenAudit;
                                    }
                                }
                                else
                                {
                                    if (item.NOTICE_TITLE.Contains("确认"))
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.HiddenCheck;
                                    }
                                    else
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.GotHidden;
                                    }
                                }
                                start.USER_ID = item.USER_ID;
                                start.USRTNAME = item.USER_NAME;
                                start.OPERTETIME = item.TASK_DT;
                                start.ORDERTIME = item.CREATE_TIME;
                                start.ISINTTIME = (item.NOTICE_STATUS == 4 || item.NOTICE_STATUS == 2) ? false : item.NOTICE_STATUS == 1 ? true : DateTime.Now > item.TASK_ENDDT ? false : true;
                                resultRisk1.Add(start);
                            }
                        }
                        var taskApprove = tasks.FirstOrDefault(t => tempIds.Contains(t.SOURCE_DATA_ID.Value));
                        if (tempIds.Any() && taskApprove == null)
                        {
                            var approveTemp = approves.FirstOrDefault(t => t.DATA_ID == ReportID);
                            if (approveTemp != null)
                            {
                                var approveDetailTemp = approveDetails.FirstOrDefault(t => t.APPROVE_ID == approveTemp.ID);
                                if (approveDetailTemp != null)
                                {
                                    OperateLogDto start = new OperateLogDto();
                                    start.LOGTYPE = SKLOGTYPE_Enums.RiskSubmit;
                                    start.DATA_ID = ReportID.Value;
                                    start.OPERATEPOINT = SKOPERATEPOINT_Enums.NoticeAudit;
                                    start.USER_ID = approveDetailTemp.APPROVE_USER_ID.Value;
                                    start.USRTNAME = users.FirstOrDefault(t => t.ID == approveDetailTemp.APPROVE_USER_ID)?.NAME;
                                    start.OPERTETIME = approveDetailTemp.NODE_APPROVE_TIME;
                                    start.ORDERTIME = approveDetailTemp.CREATE_TIME;
                                    start.ISINTTIME = true;
                                    resultRisk1.Add(start);
                                }
                            }
                        }
                        resultRisk1 = resultRisk1.OrderBy(e => e.ORDERTIME).ThenBy(m => m.OPERTETIME).ThenBy(n => n.OPERATEPOINT).ToList();
                        if (resultRisk1.Any())
                        {
                            result.Add(resultRisk1);
                        }
                    }
                    else
                    {
                        result.Add(resultRisk1);
                    }
                    #endregion

                    #region 隐患确认单
                    if (ConfirmID != null)
                    {
                        var tempIds = approves.Where(t => t.DATA_ID == ConfirmID).OrderBy(m => m.CREATE_TIME).Select(x => x.ID).ToList();
                        var temp1 = tasks.Where(t => t.SOURCE_DATA_ID == ConfirmID || tempIds.Contains(t.SOURCE_DATA_ID.Value)).OrderBy(t => t.CREATE_TIME).ToList();
                        if (temp1.Any())
                        {
                            foreach (var item in temp1)
                            {
                                OperateLogDto start = new OperateLogDto();
                                start.LOGTYPE = SKLOGTYPE_Enums.RiskSubmit;
                                start.DATA_ID = ConfirmID.Value;
                                if (tempIds.Contains(item.SOURCE_DATA_ID.Value))
                                {
                                    if (item.NOTICE_TITLE.Contains("驳回"))
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.ConfirmReject;
                                    }
                                    else
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.ConfirmAudit;
                                    }
                                }
                                else
                                {
                                    if (item.NOTICE_TITLE.Contains("确认"))
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.ConfirmCheck;
                                    }
                                    else
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.GotConfirm;
                                    }
                                }
                                start.USER_ID = item.USER_ID;
                                start.USRTNAME = item.USER_NAME;
                                start.OPERTETIME = item.TASK_DT;
                                start.ORDERTIME = item.CREATE_TIME;
                                start.ISINTTIME = (item.NOTICE_STATUS == 4 || item.NOTICE_STATUS == 2) ? false : item.NOTICE_STATUS == 1 ? true : DateTime.Now > item.TASK_ENDDT ? false : true;
                                resultRisk2.Add(start);
                            }
                        }
                        var taskApprove = tasks.FirstOrDefault(t => tempIds.Contains(t.SOURCE_DATA_ID.Value));
                        if (tempIds.Any() && taskApprove == null)
                        {
                            var approveTemp = approves.FirstOrDefault(t => t.DATA_ID == ConfirmID);
                            if (approveTemp != null)
                            {
                                var approveDetailTemp = approveDetails.FirstOrDefault(t => t.APPROVE_ID == approveTemp.ID);
                                if (approveDetailTemp != null)
                                {
                                    OperateLogDto start = new OperateLogDto();
                                    start.LOGTYPE = SKLOGTYPE_Enums.RiskSubmit;
                                    start.DATA_ID = ConfirmID.Value;
                                    start.OPERATEPOINT = SKOPERATEPOINT_Enums.NoticeAudit;
                                    start.USER_ID = approveDetailTemp.APPROVE_USER_ID.Value;
                                    start.USRTNAME = users.FirstOrDefault(t => t.ID == approveDetailTemp.APPROVE_USER_ID)?.NAME;
                                    start.OPERTETIME = approveDetailTemp.NODE_APPROVE_TIME;
                                    start.ORDERTIME = approveDetailTemp.CREATE_TIME;
                                    start.ISINTTIME = true;
                                    resultRisk2.Add(start);
                                }
                            }
                        }
                        resultRisk2 = resultRisk2.OrderBy(e => e.ORDERTIME).ThenBy(m => m.OPERTETIME).ThenBy(n => n.OPERATEPOINT).ToList();
                        if (resultRisk2.Any())
                        {
                            result.Add(resultRisk2);
                        }
                    }
                    else
                    {
                        result.Add(resultRisk2);
                    }
                    #endregion

                    #region 隐患整改通知
                    if (RectifyNoticeID != null)
                    {
                        var tempIds = approves.Where(t => t.DATA_ID == RectifyNoticeID).OrderBy(m => m.CREATE_TIME).Select(x => x.ID).ToList();
                        var temp1 = tasks.Where(t => t.SOURCE_DATA_ID == RectifyNoticeID || tempIds.Contains(t.SOURCE_DATA_ID.Value)).OrderBy(t => t.CREATE_TIME).ToList();
                        if (temp1.Any())
                        {
                            foreach (var item in temp1)
                            {
                                OperateLogDto start = new OperateLogDto();
                                start.LOGTYPE = SKLOGTYPE_Enums.RiskSubmit;
                                start.DATA_ID = RectifyNoticeID.Value;
                                if (tempIds.Contains(item.SOURCE_DATA_ID.Value))
                                {
                                    if (item.NOTICE_TITLE.Contains("驳回"))
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.RecifyReject;
                                    }
                                    else
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.RecifyAudit;
                                    }
                                }
                                else
                                {
                                    if (item.NOTICE_TITLE.Contains("确认"))
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.RecifyCheck;
                                    }
                                    else if (item.NOTICE_TITLE.Contains("驳回"))
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.RecifyRejectR;
                                    }
                                    else
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.GotRecify;
                                    }
                                }
                                start.USER_ID = item.USER_ID;
                                start.USRTNAME = item.USER_NAME;
                                start.OPERTETIME = item.TASK_DT;
                                start.ORDERTIME = item.CREATE_TIME;
                                start.ISINTTIME = (item.NOTICE_STATUS == 4 || item.NOTICE_STATUS == 2) ? false : item.NOTICE_STATUS == 1 ? true : DateTime.Now > item.TASK_ENDDT ? false : true;
                                resultRiskDeal.Add(start);
                            }
                        }
                        var taskApprove = tasks.FirstOrDefault(t => tempIds.Contains(t.SOURCE_DATA_ID.Value));
                        if (tempIds.Any() && taskApprove == null)
                        {
                            var approveTemp = approves.FirstOrDefault(t => t.DATA_ID == RectifyNoticeID);
                            if (approveTemp != null)
                            {
                                var approveDetailTemp = approveDetails.FirstOrDefault(t => t.APPROVE_ID == approveTemp.ID);
                                if (approveDetailTemp != null)
                                {
                                    OperateLogDto start = new OperateLogDto();
                                    start.LOGTYPE = SKLOGTYPE_Enums.RiskSubmit;
                                    start.DATA_ID = RectifyNoticeID.Value;
                                    start.OPERATEPOINT = SKOPERATEPOINT_Enums.RecifyAudit;
                                    start.USER_ID = approveDetailTemp.APPROVE_USER_ID.Value;
                                    start.USRTNAME = users.FirstOrDefault(t => t.ID == approveDetailTemp.APPROVE_USER_ID)?.NAME;
                                    start.OPERTETIME = approveDetailTemp.NODE_APPROVE_TIME;
                                    start.ORDERTIME = approveDetailTemp.CREATE_TIME;
                                    start.ISINTTIME = true;
                                    resultRiskDeal.Add(start);
                                }
                            }
                        }
                        resultRiskDeal = resultRiskDeal.OrderBy(e => e.ORDERTIME).ThenBy(m => m.OPERTETIME).ThenBy(n => n.OPERATEPOINT).ToList();
                        if (resultRiskDeal.Any())
                        {
                            result.Add(resultRiskDeal);
                        }
                    }
                    else
                    {
                        result.Add(resultRiskDeal);
                    }
                    #endregion

                    #region 隐患整改记录
                    if (RectifyRecordID != null)
                    {
                        var tempIds = approves.Where(t => t.DATA_ID == RectifyRecordID).OrderBy(m => m.CREATE_TIME).Select(x => x.ID).ToList();
                        var temp1 = tasks.Where(t => t.SOURCE_DATA_ID == RectifyRecordID || tempIds.Contains(t.SOURCE_DATA_ID.Value)).OrderBy(t => t.CREATE_TIME).ToList();
                        if (temp1.Any())
                        {
                            foreach (var item in temp1)
                            {
                                OperateLogDto start = new OperateLogDto();
                                start.LOGTYPE = SKLOGTYPE_Enums.RiskSubmit;
                                start.DATA_ID = RectifyRecordID.Value;
                                if (tempIds.Contains(item.SOURCE_DATA_ID.Value))
                                {
                                    if (item.NOTICE_TITLE.Contains("驳回"))
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.RecifyRecordAuditR;
                                    }
                                    else
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.RecifyRecordAudit;
                                    }
                                }
                                else
                                {
                                    if (item.NOTICE_TITLE.Contains("验收"))
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.RecifyRecordCheck;
                                    }
                                    else if (item.NOTICE_TITLE.Contains("驳回"))
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.RecifyRecordReject;
                                    }
                                    else
                                    {
                                        start.OPERATEPOINT = SKOPERATEPOINT_Enums.GotRecifyRecord;
                                    }
                                }
                                start.USER_ID = item.USER_ID;
                                start.USRTNAME = item.USER_NAME;
                                start.OPERTETIME = item.TASK_DT;
                                start.ORDERTIME = item.CREATE_TIME;
                                start.ISINTTIME = (item.NOTICE_STATUS == 4 || item.NOTICE_STATUS == 2) ? false : item.NOTICE_STATUS == 1 ? true : DateTime.Now > item.TASK_ENDDT ? false : true;
                                resultRiskEnd.Add(start);
                            }
                        }
                        var taskApprove = tasks.FirstOrDefault(t => tempIds.Contains(t.SOURCE_DATA_ID.Value));
                        if (tempIds.Any() && taskApprove == null)
                        {
                            var approveTemp = approves.FirstOrDefault(t => t.DATA_ID == RectifyRecordID);
                            if (approveTemp != null)
                            {
                                var approveDetailTemp = approveDetails.FirstOrDefault(t => t.APPROVE_ID == approveTemp.ID);
                                if (approveDetailTemp != null)
                                {
                                    OperateLogDto start = new OperateLogDto();
                                    start.LOGTYPE = SKLOGTYPE_Enums.RiskSubmit;
                                    start.DATA_ID = RectifyRecordID.Value;
                                    start.OPERATEPOINT = SKOPERATEPOINT_Enums.RecifyRecordAudit;
                                    start.USER_ID = approveDetailTemp.APPROVE_USER_ID.Value;
                                    start.USRTNAME = users.FirstOrDefault(t => t.ID == approveDetailTemp.APPROVE_USER_ID)?.NAME;
                                    start.OPERTETIME = approveDetailTemp.NODE_APPROVE_TIME;
                                    start.ORDERTIME = approveDetailTemp.CREATE_TIME;
                                    start.ISINTTIME = true;
                                    resultRiskEnd.Add(start);
                                }
                            }
                        }
                        resultRiskEnd = resultRiskEnd.OrderBy(e => e.ORDERTIME).ThenBy(m => m.OPERTETIME).ThenBy(n => n.OPERATEPOINT).ToList();
                        if (resultRiskEnd.Any())
                        {
                            result.Add(resultRiskEnd);
                        }
                    }
                    else
                    {
                        result.Add(resultRiskEnd);
                    }
                    #endregion
                    return result;
                }
            });
        }
    }
}