SGGL_JT/SUBQHSE/BLL/ZHGL/DataSync/MainSevice.cs

using Model;
using Model.Enums;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace BLL
{

    public class MainSevice
    {
        /// <summary>
        /// 在建项目集合
        /// </summary>
        private List<string> _beUnderConstructionList;
        private HSSEData_HSSE _hsseData;
        private CQMSData_CQMS _cqmsData;
        private HJGLData_HJGL _hjglData;
        private string _unitId;
        private int _unitType;

        public MainSevice(string userid)
        {
            var userModel = UserService.GetUserByUserId(userid);
            int unitType = CommonService.GetUnitTypeByUserId(userid);
            var projectList = ProjectService.GetProjectWorkList().Where(x => (x.ProjectAttribute == "GONGCHENG" || x.ProjectAttribute == null)).Select(x => new { x.ProjectId, x.UnitId }).ToList();
            _unitId = userModel.UnitId;
            _unitType = unitType;
            if (unitType == 0)
            {
                _beUnderConstructionList = projectList.Select(x => x.ProjectId).ToList();
                _unitId = CommonService.GetThisUnitId();
            }
            else if (unitType == 1)
            {
                _beUnderConstructionList = projectList.Where(x => x.UnitId == userModel.UnitId).Select(x => x.ProjectId).ToList();
            }
            else if (unitType == 2)
            {
                _beUnderConstructionList = new List<string>() { "0" };
            }

        }
        public MainSevice(string userid, string projectId)
        {
            var userModel = UserService.GetUserByUserId(userid);
            int unitType = 3;
            _unitId = userModel.UnitId?? "";
            _unitType = unitType;
            _beUnderConstructionList = new List<string>() { projectId };
        }

        /// <summary>
        /// 安全数据
        /// </summary>
        /// <returns></returns>
        public async Task<HSSEData_HSSE> GetHsseDataAsync()
        {
            try
            {
                // 并行执行异步方法
                var totalEnergyConsumptionTask = ChemicalReportItemService.GetLatstTimeTotalEnergyConsumption();
                var incomeComprehensiveEnergyConsumptionTask = ChemicalReportItemService.GetLatstTimeIncomeComprehensiveEnergyConsumption();
                var newWaterConsumptionTask = ChemicalReportItemService.GetLatstTimeNewWaterConsumption();
                var securityRiskOutputListTask = HSSEData_HSSEService.GetSecurityRiskOutputsAsync()
                    .ContinueWith(t => t.Result.Where(x => _beUnderConstructionList.Contains(x.ProjectId)));
                var largeEngineeringOutputsTask = HSSEData_HSSEService.GetLargeEngineeringOutputsAsync()
                    .ContinueWith(t => t.Result.Where(x => _beUnderConstructionList.Contains(x.ProjectId)));
                var safetyInjectionEngineerTask = HSSEData_HSSEService.GetSafetyInjectionEngineerAsync();
                var certificateATask = HSSEData_HSSEService.GetCertificateAAsync();
                var certificateBTask = HSSEData_HSSEService.GetCertificateBAsync();
                var certificateCTask = HSSEData_HSSEService.GetCertificateCAsync();
                var beUnderConstructionTask = HSSEData_HSSEService.GetBeUnderConstructionAsync();
                var shutdownTask = HSSEData_HSSEService.GetShutdownAsync();
                var joinConstructionPersonTask = HSSEData_HSSEService.GetJoinConstructionPersonAsync();
                var majorProjectsUnderConstructionTask = HSSEData_HSSEService.GetMajorProjectsUnderConstructionAsync();
                var totalWorkingHourTask = HSSEData_HSSEService.GetTotalWorkingHourAsync();
                var lostWorkingHourTask = HSSEData_HSSEService.GetLostWorkingHourAsync();
                var safeWorkingHourTask = HSSEData_HSSEService.GetSafeWorkingHourAsync();
                var safeTrainTask = HSSEData_HSSEService.GetSafeTrainAsync();
                var specialTrainTask = HSSEData_HSSEService.GetSpecialTrainAsync();
                var specialOperationTrainTask = HSSEData_HSSEService.GetSpecialOperationTrainAsync();
                var hseTechnicalTask = HSSEData_HSSEService.GetHseTechnicalAsync();
                var headOfficeInspectorGeneralTask = HSSEData_HSSEService.GetHeadOfficeInspectorGeneralAsync();
                var headOfficeFullTimeTask = HSSEData_HSSEService.GetHeadOfficeFullTimeAsync();
                var branchInspectorGeneralTask = HSSEData_HSSEService.GetBranchInspectorGeneralAsync();
                var branchFullTimeTask = HSSEData_HSSEService.GetBranchFullTimeAsync();
                var projectInspectorGeneralTask = HSSEData_HSSEService.GetProjectInspectorGeneralAsync();
                var projectFullTimeTask = HSSEData_HSSEService.GetProjectFullTimeAsync();
                var projectSafetyMonitorTask = HSSEData_HSSEService.GetProjectSafetyMonitorAsync();
                var safetyCommitteeMeetingTask = HSSEData_HSSEService.GetSafetyCommitteeMeetingAsync();
                var enterpriseTopicsMeetingTask = HSSEData_HSSEService.GetEnterpriseTopicsMeetingAsync();
                var projectSafetyLeadingGroupMeetingTask = HSSEData_HSSEService.GetProjectSafetyLeadingGroupMeetingAsync();
                var projectSafetyMeetingTask = HSSEData_HSSEService.GetProjectSafetyMeetingAsync();
                var companyLeadShiftCheckTask = HSSEData_HSSEService.GetCompanyLeadShiftCheckAsync();
                var companyComprehensiveCheckTask = HSSEData_HSSEService.GetCompanyComprehensiveCheckAsync();
                var companySpecialCheckTask = HSSEData_HSSEService.GetCompanySpecialCheckAsync();
                var projectLeadShiftCheckTask = HSSEData_HSSEService.GetProjectLeadShiftCheckAsync();
                var projectSpecialCheckTask = HSSEData_HSSEService.GetProjectSpecialCheckAsync();
                var projectMajorCheckTask = HSSEData_HSSEService.GetProjectMajorCheckAsync();
                var nearMissTask = HSSEData_HSSEService.GetNearMissAsync();
                var recordableEventTask = HSSEData_HSSEService.GetRecordableEventAsync();
                var generalAccidentTask = HSSEData_HSSEService.GetGeneralAccidentAsync();
                var majorAccidentTask = HSSEData_HSSEService.GetMajorAccidentAsync();
                var seriousAccidentTask = HSSEData_HSSEService.GetSeriousAccidentAsync();
                var specialSeriousAccidentTask = HSSEData_HSSEService.GetSpecialSeriousAccidentAsync();
                var companyComprehensivePlanTask = HSSEData_HSSEService.GetCompanyComprehensivePlanAsync();
                var companySpecialPlanTask = HSSEData_HSSEService.GetCompanySpecialPlanAsync();
                var companyOnSiteDisposalPlanTask = HSSEData_HSSEService.GetCompanyOnSiteDisposalPlanAsync();
                var companyDrillTask = HSSEData_HSSEService.GetCompanyDrillAsync();
                var projectComprehensivePlanTask = HSSEData_HSSEService.GetProjectComprehensivePlanAsync();
                var projectSpecialPlanTask = HSSEData_HSSEService.GetProjectSpecialPlanAsync();
                var projectOnSiteDisposalPlanTask = HSSEData_HSSEService.GetProjectOnSiteDisposalPlanAsync();
                var projectDrillTask = HSSEData_HSSEService.GetProjectDrillAsync();
                var costExtractTask = HSSEData_HSSEService.GetCostExtractAsync();
                var costUseTask = HSSEData_HSSEService.GetCostUseAsync();
                var useEquipmentTask = HSSEData_HSSEService.GetUseEquipmentAsync();
                var specialEquipmentTask = HSSEData_HSSEService.GetSpecialEquipmentAsync();
                var licensesTask = HSSEData_HSSEService.GetLicensesAsync();
                var licensesCloseTask = HSSEData_HSSEService.GetLicensesCloseAsync();
                var generalHiddenRectificationOutputsTask = HSSEData_HSSEService.GetGeneralHiddenRectificationOutputsAsync();
                var majorHiddenRectificationOutputsTask = HSSEData_HSSEService.GetMajorHiddenRectificationOutputsAsync();

                // 等待所有异步方法执行完成
                await Task.WhenAll(
                    securityRiskOutputListTask,
                    largeEngineeringOutputsTask,
                    safetyInjectionEngineerTask,
                    certificateATask,
                    certificateBTask,
                    certificateCTask,
                    beUnderConstructionTask,
                    shutdownTask,
                    joinConstructionPersonTask,
                    majorProjectsUnderConstructionTask,
                    totalWorkingHourTask,
                    lostWorkingHourTask,
                    safeWorkingHourTask,
                    safeTrainTask,
                    specialTrainTask,
                    specialOperationTrainTask, hseTechnicalTask,
                    headOfficeInspectorGeneralTask,
                    headOfficeFullTimeTask,
                    branchInspectorGeneralTask,
                    branchFullTimeTask,
                    projectInspectorGeneralTask,
                    projectFullTimeTask,
                    projectSafetyMonitorTask,
                    safetyCommitteeMeetingTask,
                    enterpriseTopicsMeetingTask,
                    projectSafetyLeadingGroupMeetingTask,
                    projectSafetyMeetingTask,
                    companyLeadShiftCheckTask,
                    companyComprehensiveCheckTask,
                    companySpecialCheckTask,
                    projectLeadShiftCheckTask,
                    projectSpecialCheckTask,
                    projectMajorCheckTask,
                    nearMissTask,
                    recordableEventTask,
                    generalAccidentTask,
                    majorAccidentTask,
                    seriousAccidentTask,
                    specialSeriousAccidentTask,
                    companyComprehensivePlanTask,
                    companySpecialPlanTask,
                    companyOnSiteDisposalPlanTask,
                    companyDrillTask,
                    projectComprehensivePlanTask,
                    projectSpecialPlanTask,
                    projectOnSiteDisposalPlanTask,
                    projectDrillTask,
                    costExtractTask,
                    costUseTask,
                    useEquipmentTask,
                    specialEquipmentTask,
                    licensesTask,
                    licensesCloseTask,
                    generalHiddenRectificationOutputsTask,
                    majorHiddenRectificationOutputsTask
                );


                // 统一获取异步方法的返回值
                var totalEnergyConsumption = totalEnergyConsumptionTask;
                var incomeComprehensiveEnergyConsumption = incomeComprehensiveEnergyConsumptionTask;
                var newWaterConsumption = newWaterConsumptionTask;
                var safetyInjectionEngineerList = await safetyInjectionEngineerTask;
                var certificateAList = await certificateATask;
                var certificateBList = await certificateBTask;
                var certificateCList = await certificateCTask;
                var beUnderConstructionList = await beUnderConstructionTask;
                var shutdownList = await shutdownTask;
                var joinConstructionPersonList = await joinConstructionPersonTask;
                var majorProjectsUnderConstructionList = await majorProjectsUnderConstructionTask;
                var totalWorkingHour = await totalWorkingHourTask;
                var lostWorkingHour = await lostWorkingHourTask;
                var safeWorkingHour = await safeWorkingHourTask;
                var safeTrainList = await safeTrainTask;
                var specialTrainList = await specialTrainTask;
                var specialOperationTrainList = await specialOperationTrainTask;
                var hseTechnicalList = await hseTechnicalTask;
                var headOfficeInspectorGeneralList = await headOfficeInspectorGeneralTask;
                var headOfficeFullTimeList = await headOfficeFullTimeTask;
                var branchInspectorGeneralList = await branchInspectorGeneralTask;
                var branchFullTimeList = await branchFullTimeTask;
                var projectInspectorGeneralList = await projectInspectorGeneralTask;
                var projectFullTimeList = await projectFullTimeTask;
                var projectSafetyMonitorList = await projectSafetyMonitorTask;
                var safetyCommitteeMeetingList = await safetyCommitteeMeetingTask;
                var enterpriseTopicsMeetingList = await enterpriseTopicsMeetingTask;
                var projectSafetyLeadingGroupMeetingList = await projectSafetyLeadingGroupMeetingTask;
                var projectSafetyMeetingList = await projectSafetyMeetingTask;
                var companyLeadShiftCheckList = await companyLeadShiftCheckTask;
                var companyComprehensiveCheckList = await companyComprehensiveCheckTask;
                var companySpecialCheckList = await companySpecialCheckTask;
                var projectLeadShiftCheckList = await projectLeadShiftCheckTask;
                var projectSpecialCheckList = await projectSpecialCheckTask;
                var projectMajorCheckList = await projectMajorCheckTask;
                var nearMissList = await nearMissTask;
                var recordableEventList = await recordableEventTask;
                var generalAccidentList = await generalAccidentTask;
                var majorAccidentList = await majorAccidentTask;
                var seriousAccidentList = await seriousAccidentTask;
                var specialSeriousAccidentList = await specialSeriousAccidentTask;
                var companyComprehensivePlanList = await companyComprehensivePlanTask;
                var companySpecialPlanList = await companySpecialPlanTask;
                var companyOnSiteDisposalPlanList = await companyOnSiteDisposalPlanTask;
                var companyDrillList = await companyDrillTask;
                var projectComprehensivePlanList = await projectComprehensivePlanTask;
                var projectSpecialPlanList = await projectSpecialPlanTask;
                var projectOnSiteDisposalPlanList = await projectOnSiteDisposalPlanTask;
                var projectDrillList = await projectDrillTask;
                var costExtractList = await costExtractTask;
                var costUseList = await costUseTask;
                var useEquipmentList = await useEquipmentTask;
                var specialEquipmentList = await specialEquipmentTask;
                var licensesList = await licensesTask;
                var licensesCloseList = await licensesCloseTask;
                var generalHiddenRectificationOutputsList = await generalHiddenRectificationOutputsTask;
                var majorHiddenRectificationOutputsList = await majorHiddenRectificationOutputsTask;

                // 构造结果对象
                var table = new HSSEData_HSSE();
                table.JoinConstructionPersonNum = joinConstructionPersonList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.MajorProjectsUnderConstructionNum = majorProjectsUnderConstructionList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.TotalWorkingHour = totalWorkingHour;
                table.LostWorkingHour = lostWorkingHour;
                table.SafeWorkingHour = safeWorkingHour;
                table.SafeTrainNum = safeTrainList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).Sum(x => x.TrainPersonNum);
                table.SpecialTrainNum = specialTrainList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).Sum(x => x.TrainPersonNum);
                table.SpecialOperationTrainNum = specialOperationTrainList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).Sum(x => x.TrainPersonNum);
                table.HseTechnicalNum = hseTechnicalList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.EnvironmentalTrainNum = 0;
                table.TotalEnergyConsumption = totalEnergyConsumption;
                table.IncomeComprehensiveEnergyConsumption = incomeComprehensiveEnergyConsumption;
                table.NewWaterConsumption = newWaterConsumption;
                table.HeadOfficeInspectorGeneralNum = headOfficeInspectorGeneralList.Count();
                table.HeadOfficeFullTimeNum = headOfficeFullTimeList.Count;
                table.BranchInspectorGeneralNum = branchInspectorGeneralList.Count;
                table.BranchFullTimeNum = branchFullTimeList.Count;
                table.ProjectInspectorGeneralNum = projectInspectorGeneralList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.ProjectFullTimeNum = projectFullTimeList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.ProjectSafetyMonitorNum = projectSafetyMonitorList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.ProjectSafetyLeadingGroupMeetingNum = projectSafetyLeadingGroupMeetingList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.ProjectSafetyMeetingNum = projectSafetyMeetingList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.CompanyLeadShiftCheckNum = companyLeadShiftCheckList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.CompanyComprehensiveCheckNum = companyComprehensiveCheckList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.CompanySpecialCheckNum = companySpecialCheckList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.ProjectLeadShiftCheckNum = projectLeadShiftCheckList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.ProjectSpecialCheckNum = projectSpecialCheckList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.ProjectMajorCheckNum = projectMajorCheckList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.NearMissNum = nearMissList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.RecordableEventNum = recordableEventList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.GeneralAccidentNum = generalAccidentList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.MajorAccidentNum = majorAccidentList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.SeriousAccidentNum = seriousAccidentList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.SpecialSeriousAccidentNum = specialSeriousAccidentList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.CompanyComprehensivePlanNum = companyComprehensivePlanList.Count(x => x.UnitId == _unitId);
                table.CompanySpecialPlanNum = companySpecialPlanList.Count(x => x.UnitId == _unitId);
                table.CompanyOnSiteDisposalPlan = companyOnSiteDisposalPlanList.Count(x => x.UnitId == _unitId);
                table.CompanyDrillNum = companyDrillList.Count(x => x.UnitId.Contains(_unitId));
                table.CompanyDrillPersonNum = companyDrillList.Where(x => x.UnitId.Contains(_unitId)).Sum(x => x.JointPersonNum);
                table.ProjectComprehensivePlanNum = projectComprehensivePlanList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.ProjectSpecialPlanNum = projectSpecialPlanList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.ProjectOnSiteDisposalPlan = projectOnSiteDisposalPlanList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.ProjectDrillNum = projectDrillList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.ProjectDrillPersonNum = projectDrillList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).Sum(x => x.JointPersonNum);
                table.CostExtract = Convert.ToInt32(costExtractList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).Sum(x => x.SUMCost));
                table.CostUse = Convert.ToInt32(costUseList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).Sum(x => x.SUMCost));
                table.UseEquipmentNum = useEquipmentList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.SpecialEquipmentNum = specialEquipmentList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.LicensesNum = licensesList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.LicensesCloseNum = licensesCloseList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                table.GeneralClosedNum = generalHiddenRectificationOutputsList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).Sum(x => x.RecNum);
                table.GeneralNotClosedNum = generalHiddenRectificationOutputsList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).Sum(x => x.NoRecNum);
                table.MajorClosedNum = majorHiddenRectificationOutputsList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).Sum(x => x.RecNum);
                table.MajorNotClosedNum = majorHiddenRectificationOutputsList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).Sum(x => x.NoRecNum);
                table.LowRiskNum = securityRiskOutputListTask.Result.Sum(x => x.LowRiskNum);
                table.GeneralRiskNum = securityRiskOutputListTask.Result.Sum(x => x.GeneralRiskNum);
                table.MediumRiskNum = securityRiskOutputListTask.Result.Sum(x => x.MediumRiskNum);
                table.HighRiskNum = securityRiskOutputListTask.Result.Sum(x => x.HighRiskNum);
                table.CompletedNum = largeEngineeringOutputsTask.Result.Sum(x => x.CompletedNum);
                table.TrainPersonNum = largeEngineeringOutputsTask.Result.Sum(x => x.TrainPersonNum);
                table.OperativesNum = largeEngineeringOutputsTask.Result.Sum(x => x.OperativesNum);
                table.ConstructionNum = largeEngineeringOutputsTask.Result.Sum(x => x.ConstructionNum);
                table.FinishedNum = largeEngineeringOutputsTask.Result.Sum(x => x.FinishedNum);
                table.ArgumentNum = largeEngineeringOutputsTask.Result.Sum(x => x.ArgumentNum);
                table.SuperCompletedNum = largeEngineeringOutputsTask.Result.Sum(x => x.SuperCompletedNum);
                table.SuperTrainPersonNum = largeEngineeringOutputsTask.Result.Sum(x => x.SuperTrainPersonNum);
                table.SuperOperativesNum = largeEngineeringOutputsTask.Result.Sum(x => x.SuperOperativesNum);
                table.SuperConstructionNum = largeEngineeringOutputsTask.Result.Sum(x => x.SuperConstructionNum);
                table.SuperFinishedNum = largeEngineeringOutputsTask.Result.Sum(x => x.SuperFinishedNum);
                table.SuperArgumentNum = largeEngineeringOutputsTask.Result.Sum(x => x.SuperArgumentNum);


                if (_unitType == 0)
                {
                    table.BeUnderConstructionNum = beUnderConstructionList.Count();
                    table.ShutdownNum = shutdownList.Count();
                    table.SafetyInjectionEngineer = safetyInjectionEngineerList.Count();
                    table.EnterpriseTopicsMeetingNum = enterpriseTopicsMeetingList.Count();
                    table.CertificateANum = certificateAList.Count();
                    table.CertificateBNum = certificateBList.Count();
                    table.CertificateCNum = certificateCList.Count();
                    table.SafetyCommitteeMeetingNum = safetyCommitteeMeetingList.Count();
                }
                else if (_unitType == 1)
                {
                    table.BeUnderConstructionNum = beUnderConstructionList.Count(x => x.UnitId == _unitId);
                    table.ShutdownNum = shutdownList.Count(x => x.UnitId == _unitId);
                    table.SafetyCommitteeMeetingNum = safetyCommitteeMeetingList.Count(x => x.UnitId == _unitId);
                    table.SafetyInjectionEngineer = safetyInjectionEngineerList.Count(x => _beUnderConstructionList.Contains(x.ProjectId) || x.UnitId == _unitId);
                    table.EnterpriseTopicsMeetingNum = safetyInjectionEngineerList.Count(x => _beUnderConstructionList.Contains(x.ProjectId) || x.UnitId == _unitId);
                    table.CertificateANum = certificateAList.Count(x => _beUnderConstructionList.Contains(x.ProjectId) || x.UnitId == _unitId);
                    table.CertificateBNum = certificateBList.Count(x => _beUnderConstructionList.Contains(x.ProjectId) || x.UnitId == _unitId);
                    table.CertificateCNum = certificateCList.Count(x => _beUnderConstructionList.Contains(x.ProjectId) || x.UnitId == _unitId);
                }
                else if (_unitType == 3)
                {
                    table.BeUnderConstructionNum = beUnderConstructionList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                    table.ShutdownNum = shutdownList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                    table.SafetyCommitteeMeetingNum = safetyCommitteeMeetingList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                    table.SafetyInjectionEngineer = safetyInjectionEngineerList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                    table.EnterpriseTopicsMeetingNum = safetyInjectionEngineerList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                    table.CertificateANum = certificateAList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                    table.CertificateBNum = certificateBList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                    table.CertificateCNum = certificateCList.Count(x => _beUnderConstructionList.Contains(x.ProjectId));
                }

                _hsseData = table;
                return _hsseData;
            }
            catch (Exception ex)
            {

                throw;
            }
        }

        public List<HSSEDataHiddenDangerDetailItem> GetDataHiddenDangerDetailItems()
        {
            var db = Funs.DB;
            var list = from x in db.HSSE_Hazard_HazardRegister
                       where _beUnderConstructionList.Contains(x.ProjectId)
                       select x;
            var data = (from x in list
                        join y in db.HSSE_Hazard_HazardRegisterTypes on x.RegisterTypesId equals y.RegisterTypesId
                        group x by new
                        { x.ProjectId, x.RegisterTypesId, y.RegisterTypesName }
                into g
                        select new
                        {
                            UnitId = _unitId,
                            ProjectId = g.Key.ProjectId,
                            TypeName = g.Key.RegisterTypesName,
                            TotalNum = g.Count(),
                            NeedRectifyNum = g.Count(x => x.States == "1"),
                        }).ToList();

            var result = (from x in data
                          group x by x.TypeName into g
                          select new Model.HSSEDataHiddenDangerDetailItem
                          {
                              Id = SQLHelper.GetNewID(),
                              TypeName = g.Key,
                              NeedRectifyNum = g.Sum(p => p.NeedRectifyNum),
                              TotalNum = g.Sum(p => p.TotalNum)
                          }).ToList();
            return result;
        }

        /// <summary>
        /// 质量数据
        /// </summary>
        /// <returns></returns>
        public async Task<CQMSData_CQMS> GetCqmsDataAsync()
        {
            try
            {
                // 并行执行异步方法
                var companyPersonNumTask = CQMSDataService.GetCompanyPersonNumAsync(); //获取企业总部人数
                var branchPersonNumTask = CQMSDataService.GetBranchPersonNumAsync(); //获取分支机构人数
                var projectPersonNumTask = CQMSDataService.GetProjectPersonNumAsync(); //获取项目专职人数
                var trainPersonNumTask = CQMSDataService.GetTrainPersonNumAsync(); //获取质量培训人次数
                var technicalDisclosePersonTask = CQMSDataService.GetTechnicalDisclosePersonNumAsync(); //获取技术交底人次数
                var qualityAssuranceNumTask = CQMSDataService.GetQualityAssuranceNumAsync(); //获取特设质保体系数量
                var comprehensiveConTechnologyDisclosureTask = CQMSDataService.GetComprehensiveConTechnologyDisclosureAsync(); //获取施工技术交底
                var comprehensiveReviewDrawingsTask = CQMSDataService.GetComprehensiveReviewDrawingsAsync(); //获取图纸会审

                var inspectionEquipmentTask = CQMSDataService.GetComprehensive_InspectionEquipmentAsync(); //获取设备报验
                var inspectionPersonTask = CQMSDataService.GetComprehensive_InspectionPersonAsync(); //获取人员报验
                var inspectionMachineTask = CQMSDataService.GetComprehensive_InspectionMachineAsync(); //获取机具报验
                var useNumTask = CQMSDataService.GetUseNumAsync(); //获取在用计量器具数
                var okNumTask = CQMSDataService.GetOkNumAsync(); //获取校准合格数

                var singleProjectNumTask = CQMSDataService.GetSingleProjectNumAsync(); //获取单项工程个数
                var unitProjectNumTask = CQMSDataService.GetUnitProjectNumAsync(); //获取单位工程个数
                var subProjectNuTask = CQMSDataService.GetSubProjectNumAsync(); //获取分部工程个数
                var subdivisionalWorksNuTask = CQMSDataService.GetSubdivisionalWorksNumAsync(); //获取分项工程个数
                var inspectionLotNumTask = CQMSDataService.GetInspectionLotNumAsync(); //获取检验批个数
                var constructSolutionTask = CQMSDataService.GetConstructSolutionAsync(); //施工方案数量
                var cqmsProblemTask = CQMSDataService.GetCQMSProblemAsync(); //获取企业级、项目级质量问题

                //质量验收数据
                var keyProcessNumTask = CQMSDataService.GetKeyProcessNumAsync(); //获取关键工序验收数
                var keyProcessOKNumTask = CQMSDataService.GetKeyProcessOkNumAsync(); //获取关键工序验收合格数
                var specialProcessNumTask = CQMSDataService.GetSpecialProcessNumAsync(); //获取特殊过程验收数
                var specialProcessOKNumTask = CQMSDataService.GetSpecialProcessOkNumAsync(); //获取特殊过程验收合格数
                var concealedWorksNumTask = CQMSDataService.GetConcealedWorksNumAsync(); //获取隐蔽工程验收数
                var concealedWorksOKNumTask = CQMSDataService.GetConcealedWorksOkNumAsync(); //获取隐蔽工程验收合格数

                var unitProjectAcceptNumTask = CQMSDataService.GetUnitProjectAcceptNumAsync(); //获取单位工程验收数
                var unitProjectAcceptOKNumTask = CQMSDataService.GetUnitProjectAcceptOKNumAsync(); //获取单位工程验收合格数
                var subProjectAcceptNumTask = CQMSDataService.GetSubProjectAcceptNumAsync(); //获取分部工程验收数
                var subProjectAcceptOKNumTask = CQMSDataService.GetSubProjectAcceptOKNumAsync(); //获取分部工程验收合格数
                var subdivisionalWorksAcceptNumTask = CQMSDataService.GetSubdivisionalWorksAcceptNumAsync(); //获取分项工程验收数
                var subdivisionalWorksAcceptOKNumTask = CQMSDataService.GetSubdivisionalWorksAcceptOKNumAsync(); //获取分项工程验收合格数

                // 等待所有异步方法执行完成
                await Task.WhenAll(
                    companyPersonNumTask, branchPersonNumTask, projectPersonNumTask,
                    trainPersonNumTask, technicalDisclosePersonTask, qualityAssuranceNumTask,
                    comprehensiveConTechnologyDisclosureTask, comprehensiveReviewDrawingsTask,
                    inspectionEquipmentTask, inspectionPersonTask, inspectionMachineTask,
                    useNumTask, okNumTask,
                    singleProjectNumTask, unitProjectNumTask, subProjectNuTask, subdivisionalWorksNuTask, inspectionLotNumTask,
                    constructSolutionTask,
                    cqmsProblemTask,
                    keyProcessNumTask, keyProcessOKNumTask, specialProcessNumTask, specialProcessOKNumTask, concealedWorksNumTask, concealedWorksOKNumTask,
                    unitProjectAcceptNumTask, unitProjectAcceptOKNumTask, subProjectAcceptNumTask, subProjectAcceptOKNumTask, subdivisionalWorksAcceptNumTask, subdivisionalWorksAcceptOKNumTask
                );

                // 统一获取异步方法的返回值
                var companyPersonNum = await companyPersonNumTask;
                var branchPersonNum = await branchPersonNumTask;
                var projectPersonNumList = await projectPersonNumTask;
                var trainPersonNumList = await trainPersonNumTask;
                var technicalDisclosePersonList = await technicalDisclosePersonTask;
                var qualityAssuranceNum = await qualityAssuranceNumTask;
                var comprehensiveConTechnologyDisclosureList = await comprehensiveConTechnologyDisclosureTask;
                var comprehensiveReviewDrawingsList = await comprehensiveReviewDrawingsTask;

                var inspectionEquipmentList = await inspectionEquipmentTask;
                var inspectionPersonList = await inspectionPersonTask;
                var inspectionMachineList = await inspectionMachineTask;
                var useNum = await useNumTask;
                var okNum = await okNumTask;
                var singleProjectNum = await singleProjectNumTask;
                var unitProjectNum = await unitProjectNumTask;
                var subProjectNum = await subProjectNuTask;
                var subdivisionalWorksNum = await subdivisionalWorksNuTask;
                var inspectionLotNum = await inspectionLotNumTask;

                var constructSolutionList = await constructSolutionTask;
                var cqmsProblemList = await cqmsProblemTask;

                var keyProcessNum = await keyProcessNumTask;
                var keyProcessOKNum = await keyProcessOKNumTask;
                var specialProcessNum = await specialProcessNumTask;
                var specialProcessOKNum = await specialProcessOKNumTask;
                var concealedWorksNum = await concealedWorksNumTask;
                var concealedWorksOKNum = await concealedWorksOKNumTask;

                var unitProjectAcceptNum = await unitProjectAcceptNumTask;
                var unitProjectAcceptOKNum = await unitProjectAcceptOKNumTask;
                var subProjectAcceptNum = await subProjectAcceptNumTask;
                var subProjectAcceptOKNum = await subProjectAcceptOKNumTask;
                var subdivisionalWorksAcceptNum = await subdivisionalWorksAcceptNumTask;
                var subdivisionalWorksAcceptOKNum = await subdivisionalWorksAcceptOKNumTask;

                if (_unitType == 1 || _unitType == 3)
                {
                    projectPersonNumList = projectPersonNumList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    trainPersonNumList = trainPersonNumList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    technicalDisclosePersonList = technicalDisclosePersonList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    comprehensiveConTechnologyDisclosureList = comprehensiveConTechnologyDisclosureList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    comprehensiveReviewDrawingsList = comprehensiveReviewDrawingsList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    qualityAssuranceNum = qualityAssuranceNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    inspectionEquipmentList = inspectionEquipmentList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    inspectionPersonList = inspectionPersonList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    inspectionMachineList = inspectionMachineList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    useNum = useNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    okNum = okNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    singleProjectNum = singleProjectNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    unitProjectNum = unitProjectNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    subProjectNum = subProjectNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    subdivisionalWorksNum = subdivisionalWorksNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    inspectionLotNum = inspectionLotNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    constructSolutionList = constructSolutionList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    cqmsProblemList = cqmsProblemList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    keyProcessNum = keyProcessNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    keyProcessOKNum = keyProcessOKNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    specialProcessNum = specialProcessNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    specialProcessOKNum = specialProcessOKNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    concealedWorksNum = concealedWorksNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    concealedWorksOKNum = concealedWorksOKNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    unitProjectAcceptNum = unitProjectAcceptNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    unitProjectAcceptOKNum = unitProjectAcceptOKNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    subProjectAcceptNum = subProjectAcceptNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    subProjectAcceptOKNum = subProjectAcceptOKNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    subdivisionalWorksAcceptNum = subdivisionalWorksAcceptNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    subdivisionalWorksAcceptOKNum = subdivisionalWorksAcceptOKNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                }
                // 构造结果对象
                var table = new CQMSData_CQMS
                {
                    CompanyPersonNum = companyPersonNum,//
                    BranchPersonNum = branchPersonNum,//
                    ProjectPersonNum = projectPersonNumList.Count(),
                    TrainPersonNum = trainPersonNumList.Count(),
                    TechnicalDisclosePersonNum = technicalDisclosePersonList.Sum(x => x.TrainPersonNum),
                    ComprehensiveConTechnologyDisclosureNum = comprehensiveConTechnologyDisclosureList.Count(),
                    ComprehensiveConTechnologyDisclosurePersonNum = comprehensiveConTechnologyDisclosureList.Sum(x => x.TrainPersonNum),
                    ComprehensiveReviewDrawingsNum = comprehensiveReviewDrawingsList.Count(),
                    EquipmentInspectionNum = inspectionEquipmentList.Count(),
                    EquipmentInspectionQualifiedNum = inspectionEquipmentList.Where(x => x.SamplingResult == "1").Count(),
                    PersonInspectionNum = inspectionPersonList.Count(),
                    PersonInspectionQualifiedNum = inspectionPersonList.Where(x => x.IsOnSite.HasValue && x.IsOnSite == true).Count(),
                    MachineInspectionNum = inspectionMachineList.Count(),
                    MachineInspectionQualifiedNum = inspectionMachineList.Where(x => x.IsCheckOK.HasValue && x.IsCheckOK == true).Count(),
                    MaterialInspectionNum = 0,
                    MaterialInspectionQualifiedNum = 0,
                    UseNum = useNum.Count(),
                    OKNum = okNum.Count(),
                    SingleProjectNum = singleProjectNum.Count(),
                    UnitProjectNum = unitProjectNum.Count(),
                    SubProjectNum = subProjectNum.Count(),
                    SubdivisionalWorksNum = subdivisionalWorksNum.Count(),
                    InspectionLotNum = inspectionLotNum.Sum(x=>x.Sum),

                    ConstructSolutionNum = constructSolutionList.Count(),
                    ConstructSolutionProjectApproveNum = constructSolutionList.Where(x => x.State == "1").Count(),
                    ConstructSolutionUnitApproveNum = 0,//
                    SpecialEquipmentQualityAssuranceSystemNum = qualityAssuranceNum.Count(),
                    DesignDetailsNum = technicalDisclosePersonList.Sum(x => x.TrainPersonNum),

                    ProblemNum = cqmsProblemList.Count(),
                    ProblemCompletedNum = cqmsProblemList.Where(x => x.State == "7").Count(),
                    ProblemNotCompletedNum = cqmsProblemList.Where(x => x.State != "7").Count(),

                    KeyProcessNum = keyProcessNum.Count(),
                    KeyProcessOKNum = keyProcessOKNum.Count(),
                    SpecialProcessNum = specialProcessNum.Count(),
                    SpecialProcessOKNum = specialProcessOKNum.Count(),
                    ConcealedWorksNum = concealedWorksNum.Count(),
                    ConcealedWorksOKNum = concealedWorksOKNum.Count(),
                    UnitProjectAcceptNum = unitProjectAcceptNum.Count(),
                    UnitProjectAcceptOKNum = unitProjectAcceptOKNum.Count(),
                    SubProjectAcceptNum = subProjectAcceptNum.Count(),
                    SubProjectAcceptOKNum = subProjectAcceptOKNum.Count(),
                    SubdivisionalWorksAcceptNum = subdivisionalWorksAcceptNum.Count(),
                    SubdivisionalWorksAcceptOKNum = subdivisionalWorksAcceptOKNum.Count()
                };

                _cqmsData = table;
                return _cqmsData;
            }
            catch (Exception ex)
            {
                throw;
            }
        }

        /// <summary>
        /// 焊接数据
        /// </summary>
        /// <returns></returns>
        public async Task<HJGLData_HJGL> GetHjglDataAsync()
        {
            try
            {
                // 并行执行异步方法
                var welderNumTask = HJGLData_HJGLService.GetWelderNumAsync(); //获取焊工总数
                var dineInfoListTask = HJGLData_HJGLService.GetDineInfoAsync(); //获达因数信息
                var chCheckItemListTask = HJGLData_HJGLService.GetCHCheckItemAsync(); //获取焊接检查信息

                // 等待所有异步方法执行完成
                await Task.WhenAll(
                    welderNumTask,
                    dineInfoListTask,
                    chCheckItemListTask
                );

                // 统一获取异步方法的返回值
                var welderNum = await welderNumTask;
                var dineInfoList = await dineInfoListTask;
                var chCheckItemList = await chCheckItemListTask;

                if (_unitType == 1 || _unitType == 3)
                {
                    welderNum = welderNum.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    dineInfoList = dineInfoList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                    chCheckItemList = chCheckItemList.Where(x => _beUnderConstructionList.Contains(x.ProjectId)).ToList();
                }

                // 构造结果对象
                var table = new HJGLData_HJGL
                {
                    WelderNum = welderNum.Count(),
                    TotalDineNum = Convert.ToInt32(dineInfoList.Sum(x => x.Size)),
                    CompleteDineNum = Convert.ToInt32(dineInfoList.Sum(x => x.DoneDin)),
                    TotalFilmNum = Convert.ToInt32(chCheckItemList.Sum(x => x.CHT_TotalFilm)),
                    OKFilmNum = Convert.ToInt32(chCheckItemList.Sum(x => x.CHT_PassFilm))
                };
                _hjglData = table;
                return _hjglData;
            }
            catch (Exception ex)
            {
                throw;
            }
        }

        /// <summary>
        /// 焊接缺陷分析
        /// </summary>
        /// <returns></returns>
        public List<AnalysisData> GetDefectAnalysis()
        {
            var db = Funs.DB;
            var list = (from item in db.CH_CheckItem
                        join check in db.CH_Check on item.CHT_CheckID equals check.CHT_CheckID
                        where _beUnderConstructionList.Contains(check.ProjectId)
                        group item by item.DefectType into g
                        select new AnalysisData
                        {
                            name = Enum.GetName(typeof(DefectTypeEnums), g.Key),
                            value = g.Count()
                        }).ToList();
            return list;
        }
    }
}