using FineUIPro;
using Model;
using Newtonsoft.Json;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace BLL
{
    public static class CQMSDataService
    {
        public static SGGLDB db = Funs.DB;
        public static List<string> BeUnderConstructionList = BaseDataService.BeUnderConstructionList;

        #region 获取列表

        /// <summary>
        /// 记录数
        /// </summary>
        public static int count { get; set; }

        public static List<CQMSData_CQMS> GetCQMSData_CQMSByModle(CQMSData_CQMS table)
        {
            var db = Funs.DB;
            var q = from x in db.CQMSData_CQMS
                    where
                        (string.IsNullOrEmpty(table.Id) || x.Id.Contains(table.Id)) &&
                        (string.IsNullOrEmpty(table.UnitId) || x.UnitId.Contains(table.UnitId)) &&
                        (string.IsNullOrEmpty(table.CollCropCode) || x.CollCropCode.Contains(table.CollCropCode)) &&
                        (string.IsNullOrEmpty(table.UnitName) || x.UnitName.Contains(table.UnitName))
                    orderby x.ReportDate descending
                    select x
                ;

            return q.ToList();
        }

        /// 获取分页列表
        /// </summary>
        /// <param name="PageIndex">页码</param>
        /// <param name="PageSize">每页数量</param>
        /// <returns></returns>
        public static IEnumerable getListData(CQMSData_CQMS table, Grid Grid1)
        {
            var q = GetCQMSData_CQMSByModle(table);
            count = q.Count();
            if (count == 0) return null;
            //  q=  q.Take(Grid1.PageSize * Grid1.PageIndex).Skip(Grid1.PageSize * (Grid1.PageIndex)).ToList();
            // q = SortConditionHelper.SortingAndPaging(q, Grid1.SortField, Grid1.SortDirection, Grid1.PageIndex, Grid1.PageSize);
            return from x in q
                   select new
                   {
                       x.Id,
                       x.UnitId,
                       x.CollCropCode,
                       x.UnitName,
                       x.ReportDate,
                       x.TrainPersonNum,
                       x.TechnicalDisclosePersonNum,
                       x.UseNum,
                       x.OKNum,
                       x.CompanyPersonNum,
                       x.BranchPersonNum,
                       x.ProjectPersonNum,
                       x.ProblemNum,
                       x.ProblemCompletedNum,
                       x.ProblemNotCompletedNum,
                       x.SNum,
                       x.ANum,
                       x.BNum,
                       x.CNum,
                       x.KeyProcessNum,
                       x.KeyProcessOKNum,
                       x.SpecialProcessNum,
                       x.SpecialProcessOKNum,
                       x.ConcealedWorksNum,
                       x.ConcealedWorksOKNum,
                       x.UnitProjectOnesNum,
                       x.UnitProjectOnesOKNum,
                       x.MaterialInRecheckNum,
                       x.MaterialInRecheckOKNum,
                       x.SingleProjectNum,
                       x.UnitProjectNum,
                       x.SubProjectNum,
                       x.SubdivisionalWorksNum,
                       x.InspectionLotNum,
                       x.State,
                       x.CreateDate,
                       x.CreateMan
                   };
        }

        #endregion 获取列表

        #region 新增、编辑、删除

        public static void AddCQMSData_CQMS(CQMSData_CQMS newtable)
        {
            using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
            {
                var table = new CQMSData_CQMS
                {
                    Id = newtable.Id,
                    UnitId = newtable.UnitId,
                    CollCropCode = newtable.CollCropCode,
                    UnitName = newtable.UnitName,
                    ReportDate = newtable.ReportDate,
                    TrainPersonNum = newtable.TrainPersonNum,
                    TechnicalDisclosePersonNum = newtable.TechnicalDisclosePersonNum,
                    ComprehensiveConTechnologyDisclosureNum = newtable.ComprehensiveConTechnologyDisclosureNum,
                    ComprehensiveConTechnologyDisclosurePersonNum = newtable.ComprehensiveConTechnologyDisclosurePersonNum,
                    ComprehensiveReviewDrawingsNum = newtable.ComprehensiveReviewDrawingsNum,
                    UseNum = newtable.UseNum,
                    OKNum = newtable.OKNum,
                    CompanyPersonNum = newtable.CompanyPersonNum,
                    BranchPersonNum = newtable.BranchPersonNum,
                    ProjectPersonNum = newtable.ProjectPersonNum,
                    ProjectSubPersonNum = newtable.ProjectSubPersonNum,
                    ProblemNum = newtable.ProblemNum,
                    ProblemCompletedNum = newtable.ProblemCompletedNum,
                    ProblemNotCompletedNum = newtable.ProblemNotCompletedNum,
                    SNum = newtable.SNum,
                    ANum = newtable.ANum,
                    BNum = newtable.BNum,
                    CNum = newtable.CNum,
                    KeyProcessNum = newtable.KeyProcessNum,
                    KeyProcessOKNum = newtable.KeyProcessOKNum,
                    SpecialProcessNum = newtable.SpecialProcessNum,
                    SpecialProcessOKNum = newtable.SpecialProcessOKNum,
                    ConcealedWorksNum = newtable.ConcealedWorksNum,
                    ConcealedWorksOKNum = newtable.ConcealedWorksOKNum,
                    UnitProjectOnesNum = newtable.UnitProjectOnesNum,
                    UnitProjectOnesOKNum = newtable.UnitProjectOnesOKNum,
                    MaterialInRecheckNum = newtable.MaterialInRecheckNum,
                    MaterialInRecheckOKNum = newtable.MaterialInRecheckOKNum,
                    SingleProjectNum = newtable.SingleProjectNum,
                    UnitProjectNum = newtable.UnitProjectNum,
                    SubProjectNum = newtable.SubProjectNum,
                    SubdivisionalWorksNum = newtable.SubdivisionalWorksNum,
                    InspectionLotNum = newtable.InspectionLotNum,
                    EquipmentInspectionNum = newtable.EquipmentInspectionNum,
                    EquipmentInspectionQualifiedNum = newtable.EquipmentInspectionQualifiedNum,
                    MachineInspectionNum = newtable.MachineInspectionNum,
                    MachineInspectionQualifiedNum = newtable.MachineInspectionQualifiedNum,
                    PersonInspectionNum = newtable.PersonInspectionNum,
                    PersonInspectionQualifiedNum = newtable.PersonInspectionQualifiedNum,
                    MaterialInspectionNum = newtable.MaterialInspectionNum,
                    MaterialInspectionQualifiedNum = newtable.MaterialInspectionQualifiedNum,
                    ConstructSolutionNum = newtable.ConstructSolutionNum,
                    ConstructSolutionProjectApproveNum = newtable.ConstructSolutionProjectApproveNum,
                    ConstructSolutionUnitApproveNum = newtable.ConstructSolutionUnitApproveNum,
                    SpecialEquipmentQualityAssuranceSystemNum = newtable.SpecialEquipmentQualityAssuranceSystemNum,
                    DesignDetailsNum = newtable.DesignDetailsNum,
                    UnitProjectAcceptNum = newtable.UnitProjectAcceptNum,
                    UnitProjectAcceptOKNum = newtable.UnitProjectAcceptOKNum,
                    SubProjectAcceptNum = newtable.SubProjectAcceptNum,
                    SubProjectAcceptOKNum = newtable.SubProjectAcceptOKNum,
                    SubdivisionalWorksAcceptNum = newtable.SubdivisionalWorksAcceptNum,
                    SubdivisionalWorksAcceptOKNum = newtable.SubdivisionalWorksAcceptOKNum,
                    InspectionMachineNum = newtable.InspectionMachineNum,
                    InspectionMachineQualifiedNum = newtable.InspectionMachineQualifiedNum,
                    State = newtable.State,
                    CreateDate = newtable.CreateDate,
                    CreateMan = newtable.CreateMan
                };
                db.CQMSData_CQMS.InsertOnSubmit(table);
                db.SubmitChanges();

            }
        }

        public static void UpdateCQMSData_CQMS(CQMSData_CQMS newtable)
        {
            using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
            {
                var table = db.CQMSData_CQMS.FirstOrDefault(x => x.Id == newtable.Id);
                if (table != null)
                {
                    table.Id = newtable.Id;
                    table.UnitId = newtable.UnitId;
                    table.CollCropCode = newtable.CollCropCode;
                    table.UnitName = newtable.UnitName;
                    table.ReportDate = newtable.ReportDate;
                    table.TrainPersonNum = newtable.TrainPersonNum;
                    table.TechnicalDisclosePersonNum = newtable.TechnicalDisclosePersonNum;
                    table.ComprehensiveConTechnologyDisclosureNum = newtable.ComprehensiveConTechnologyDisclosureNum;
                    table.ComprehensiveConTechnologyDisclosurePersonNum = newtable.ComprehensiveConTechnologyDisclosurePersonNum;
                    table.ComprehensiveReviewDrawingsNum = newtable.ComprehensiveReviewDrawingsNum;
                    table.UseNum = newtable.UseNum;
                    table.OKNum = newtable.OKNum;
                    table.CompanyPersonNum = newtable.CompanyPersonNum;
                    table.BranchPersonNum = newtable.BranchPersonNum;
                    table.ProjectPersonNum = newtable.ProjectPersonNum;
                    table.ProjectSubPersonNum = newtable.ProjectSubPersonNum;
                    table.ProblemNum = newtable.ProblemNum;
                    table.ProblemCompletedNum = newtable.ProblemCompletedNum;
                    table.ProblemNotCompletedNum = newtable.ProblemNotCompletedNum;
                    table.UnitCheckNum = newtable.UnitCheckNum;
                    table.UnitCheckClosedNum = newtable.UnitCheckClosedNum;
                    table.UnitCheckNotClosedNum = newtable.UnitCheckNotClosedNum;
                    table.BranchCheckNum = newtable.BranchCheckNum;
                    table.BranchCheckClosedNum = newtable.BranchCheckClosedNum;
                    table.BranchCheckNotClosedNum = newtable.BranchCheckNotClosedNum;
                    table.SNum = newtable.SNum;
                    table.ANum = newtable.ANum;
                    table.BNum = newtable.BNum;
                    table.CNum = newtable.CNum;
                    table.KeyProcessNum = newtable.KeyProcessNum;
                    table.KeyProcessOKNum = newtable.KeyProcessOKNum;
                    table.SpecialProcessNum = newtable.SpecialProcessNum;
                    table.SpecialProcessOKNum = newtable.SpecialProcessOKNum;
                    table.ConcealedWorksNum = newtable.ConcealedWorksNum;
                    table.ConcealedWorksOKNum = newtable.ConcealedWorksOKNum;
                    table.UnitProjectOnesNum = newtable.UnitProjectOnesNum;
                    table.UnitProjectOnesOKNum = newtable.UnitProjectOnesOKNum;
                    table.MaterialInRecheckNum = newtable.MaterialInRecheckNum;
                    table.MaterialInRecheckOKNum = newtable.MaterialInRecheckOKNum;
                    table.SingleProjectNum = newtable.SingleProjectNum;
                    table.UnitProjectNum = newtable.UnitProjectNum;
                    table.SubProjectNum = newtable.SubProjectNum;
                    table.SubdivisionalWorksNum = newtable.SubdivisionalWorksNum;
                    table.InspectionLotNum = newtable.InspectionLotNum;
                    table.EquipmentInspectionNum = newtable.EquipmentInspectionNum;
                    table.EquipmentInspectionQualifiedNum = newtable.EquipmentInspectionQualifiedNum;
                    table.MachineInspectionNum = newtable.MachineInspectionNum;
                    table.MachineInspectionQualifiedNum = newtable.MachineInspectionQualifiedNum;
                    table.PersonInspectionNum = newtable.PersonInspectionNum;
                    table.PersonInspectionQualifiedNum = newtable.PersonInspectionQualifiedNum;
                    table.MaterialInspectionNum = newtable.MaterialInspectionNum;
                    table.MaterialInspectionQualifiedNum = newtable.MaterialInspectionQualifiedNum;
                    table.ConstructSolutionNum = newtable.ConstructSolutionNum;
                    table.ConstructSolutionProjectApproveNum = newtable.ConstructSolutionProjectApproveNum;
                    table.ConstructSolutionUnitApproveNum = newtable.ConstructSolutionUnitApproveNum;
                    table.SpecialEquipmentQualityAssuranceSystemNum = newtable.SpecialEquipmentQualityAssuranceSystemNum;
                    table.DesignDetailsNum = newtable.DesignDetailsNum;
                    table.UnitProjectAcceptNum = newtable.UnitProjectAcceptNum;
                    table.UnitProjectAcceptOKNum = newtable.UnitProjectAcceptOKNum;
                    table.SubProjectAcceptNum = newtable.SubProjectAcceptNum;
                    table.SubProjectAcceptOKNum = newtable.SubProjectAcceptOKNum;
                    table.SubdivisionalWorksAcceptNum = newtable.SubdivisionalWorksAcceptNum;
                    table.SubdivisionalWorksAcceptOKNum = newtable.SubdivisionalWorksAcceptOKNum;
                    table.InspectionMachineNum = newtable.InspectionMachineNum;
                    table.InspectionMachineQualifiedNum = newtable.InspectionMachineQualifiedNum;
                    table.State = newtable.State;
                    table.CreateMan = newtable.CreateMan;
                    table.CreateDate = newtable.CreateDate;
                    db.SubmitChanges();
                }

            }

        }
        public static void DeleteCQMSData_CQMSById(string id)
        {
            using (Model.SGGLDB db = new Model.SGGLDB(Funs.ConnString))
            {
                var table = db.CQMSData_CQMS.FirstOrDefault(x => x.Id == id);
                if (table != null)
                {
                    db.CQMSData_CQMS.DeleteOnSubmit(table);
                    db.SubmitChanges();
                }
            }
        }

        #endregion

        public static CQMSData_CQMS GetCQMSData_CQMSById(string id)
        {
            var db = Funs.DB;
            return db.CQMSData_CQMS.FirstOrDefault(x => x.Id == id);
        }

        public static CQMSData GetItemById(string id)
        {
            var model = GetCQMSData_CQMSById(id);
            var data = new CQMSData();
            var item = new CqmsDataItem();
            if (model != null)
            {
                item.Id = model.Id;
                item.ReportDate = model.ReportDate.Value.ToShortDateString();
                item.UnitId = model.UnitId;
                item.CollCropCode = model.CollCropCode;
                item.TrainPersonNum = model.TrainPersonNum;
                item.TechnicalDisclosePersonNum = model.TechnicalDisclosePersonNum;
                item.UseNum = model.UseNum;
                item.OKNum = model.OKNum;
                item.CompanyPersonNum = model.CompanyPersonNum;
                item.BranchPersonNum = model.BranchPersonNum;
                item.ProjectPersonNum = model.ProjectPersonNum;
                item.ProblemNum = model.ProblemNum;
                item.ProblemCompletedNum = model.ProblemCompletedNum;
                item.ProblemNotCompletedNum = model.ProblemNotCompletedNum;
                item.ProblemRate = "";
                item.SNum = model.SNum;
                item.ANum = model.ANum;
                item.BNum = model.BNum;
                item.CNum = model.CNum;
                item.KeyProcessNum = model.KeyProcessNum;
                item.KeyProcessOKNum = model.KeyProcessOKNum;
                item.KeyProcessRate = "";
                item.SpecialProcessNum = model.SpecialProcessNum;
                item.SpecialProcessOKNum = model.SpecialProcessOKNum;
                item.SpecialProcessRate = "";
                item.ConcealedWorksNum = model.ConcealedWorksNum;
                item.ConcealedWorksOKNum = model.ConcealedWorksOKNum;
                item.ConcealedWorksRate = "";
                item.UnitProjectOnesNum = model.UnitProjectOnesNum;
                item.UnitProjectOnesOKNum = model.UnitProjectOnesOKNum;
                item.UnitProjectOnesRate = "";
                item.MaterialInRecheckNum = model.MaterialInRecheckNum;
                item.MaterialInRecheckOKNum = model.MaterialInRecheckOKNum;
                item.MaterialInRecheckRate = "";
                item.SingleProjectNum = model.SingleProjectNum;
                item.UnitProjectNum = model.UnitProjectNum;
                item.SubProjectNum = model.SubProjectNum;
                item.SubdivisionalWorksNum = model.SubdivisionalWorksNum;
                item.InspectionLotNum = model.InspectionLotNum;
                item.EquipmentInspectionNum = model.EquipmentInspectionNum;
                item.EquipmentInspectionQualifiedNum = model.EquipmentInspectionQualifiedNum;
                item.MachineInspectionNum = model.MachineInspectionNum;
                item.MachineInspectionQualifiedNum = model.MachineInspectionQualifiedNum;
                item.PersonInspectionNum = model.PersonInspectionNum;
                item.PersonInspectionQualifiedNum = model.PersonInspectionQualifiedNum;
                item.MaterialInspectionNum = model.MaterialInspectionNum;
                item.MaterialInspectionQualifiedNum = model.MaterialInspectionQualifiedNum;
                item.ConstructSolutionNum = model.ConstructSolutionNum;
                item.ConstructSolutionProjectApproveNum = model.ConstructSolutionProjectApproveNum;
                item.ConstructSolutionUnitApproveNum = model.ConstructSolutionUnitApproveNum;
                item.SpecialEquipmentQualityAssuranceSystemNum = model.SpecialEquipmentQualityAssuranceSystemNum;
                item.DesignDetailsNum = model.DesignDetailsNum;
                item.UnitProjectAcceptNum = model.UnitProjectAcceptNum;
                item.UnitProjectAcceptOKNum = model.UnitProjectAcceptOKNum;
                item.SubProjectAcceptNum = model.SubProjectAcceptNum;
                item.SubProjectAcceptOKNum = model.SubProjectAcceptOKNum;
                item.SubdivisionalWorksAcceptNum = model.SubdivisionalWorksAcceptNum;
                item.SubdivisionalWorksAcceptOKNum = model.SubdivisionalWorksAcceptOKNum;
            }

            var cqmsDataItems = new List<CqmsDataItem>();
            cqmsDataItems.Add(item);
            data.CQMSDataItems = cqmsDataItems;
            return data;
        }

        public static async Task<CQMSData> GetTodayCQMSData_CQMS()
        {
            //    var data = new CQMSData();
            //    data = StatisticalData();

            //    return data;

            var modelTask = StatisitcalDataAsync();
            var model = await modelTask;
            CQMSData data = model;
            return data;
        }

        public static CQMSData_CQMS GetTodayData()
        {
            var q = (from x in Funs.DB.CQMSData_CQMS
                     where x.ReportDate < DateTime.Now.AddDays(1).Date && x.ReportDate >= DateTime.Now.Date
                     select x).FirstOrDefault();
            return q;
        }
        public static CQMSData_CQMS GetSubUnitCqmsDataByDate(string Unitid, DateTime? reportdate)
        {

            var result = new Model.CQMSData_CQMS();
            if (reportdate == null)
            {
                return result;
            }
            var projectlist = BLL.ProjectService.GetProjectWorkList();
            var base_Unit = UnitService.GetUnitByUnitId(Unitid);
            var ProjectData = (from x in Funs.DB.Project_CQMSData_CQMS
                               where x.ReportDate == reportdate && projectlist.Select(e => e.ProjectId).Contains(x.ProjectId)
                               select x).ToList();
            result = new CQMSData_CQMS
            {
                UnitId = Unitid,
                CollCropCode = base_Unit.CollCropCode,
                UnitName = base_Unit.UnitName,
                ReportDate = DateTime.Now.Date,
                TrainPersonNum = ProjectData.Sum(x => x.TrainPersonNum),
                TechnicalDisclosePersonNum = ProjectData.Sum(x => x.TechnicalDisclosePersonNum),
                ComprehensiveConTechnologyDisclosureNum = ProjectData.Sum(x => x.ComprehensiveConTechnologyDisclosureNum),
                ComprehensiveConTechnologyDisclosurePersonNum = ProjectData.Sum(x => x.ComprehensiveConTechnologyDisclosurePersonNum),
                ComprehensiveReviewDrawingsNum = ProjectData.Sum(x => x.ComprehensiveReviewDrawingsNum),
                UseNum = ProjectData.Sum(x => x.UseNum),
                OKNum = ProjectData.Sum(x => x.OKNum),
                CompanyPersonNum = GetCompanyPersonNum(),
                BranchPersonNum = GetBranchPersonNum(),
                ProjectPersonNum = ProjectData.Sum(x => x.ProjectPersonNum),
                ProblemNum = ProjectData.Sum(x => x.ProblemNum),
                ProblemCompletedNum = ProjectData.Sum(x => x.ProblemCompletedNum),
                ProblemNotCompletedNum = ProjectData.Sum(x => x.ProblemNotCompletedNum),
                SNum = ProjectData.Sum(x => x.SNum),
                ANum = ProjectData.Sum(x => x.ANum),
                BNum = ProjectData.Sum(x => x.BNum),
                CNum = ProjectData.Sum(x => x.CNum),
                KeyProcessNum = ProjectData.Sum(x => x.KeyProcessNum),
                KeyProcessOKNum = ProjectData.Sum(x => x.KeyProcessOKNum),
                SpecialProcessNum = ProjectData.Sum(x => x.SpecialProcessNum),
                SpecialProcessOKNum = ProjectData.Sum(x => x.SpecialProcessOKNum),
                ConcealedWorksNum = ProjectData.Sum(x => x.ConcealedWorksNum),
                ConcealedWorksOKNum = ProjectData.Sum(x => x.ConcealedWorksOKNum),
                UnitProjectOnesNum = ProjectData.Sum(x => x.UnitProjectOnesNum),
                UnitProjectOnesOKNum = ProjectData.Sum(x => x.UnitProjectOnesOKNum),
                MaterialInRecheckNum = ProjectData.Sum(x => x.MaterialInRecheckNum),
                MaterialInRecheckOKNum = ProjectData.Sum(x => x.MaterialInRecheckOKNum),
                SingleProjectNum = ProjectData.Sum(x => x.SingleProjectNum),
                UnitProjectNum = ProjectData.Sum(x => x.UnitProjectNum),
                SubProjectNum = ProjectData.Sum(x => x.SubProjectNum),
                SubdivisionalWorksNum = ProjectData.Sum(x => x.SubdivisionalWorksNum),
                InspectionLotNum = ProjectData.Sum(x => x.InspectionLotNum),
                InspectionMachineNum = ProjectData.Sum(x => x.InspectionMachineNum),
                InspectionMachineQualifiedNum = ProjectData.Sum(x => x.InspectionMachineQualifiedNum),
                SpecialEquipmentQualityAssuranceSystemNum = ProjectData.Sum(x => x.SpecialEquipmentQualityAssuranceSystemNum),
                CreateMan = Const.sysglyId,
                CreateDate = DateTime.Now
            };
            return result;

        }
        public static void UpdateTodyData_State()
        {
            var q = GetTodayData();
            if (q != null)
            {
                q.State = Const.CNCEC_State_1;
                UpdateCQMSData_CQMS(q);
            }
        }

        public static bool IsReportByDate(DateTime dateTime)
        {
            var result = false;
            var q = (from x in Funs.DB.CQMSData_CQMS
                     where x.ReportDate >= dateTime.Date && x.ReportDate < dateTime.Date.AddDays(1).Date
                     select x).ToList();
            if (q.Count > 0) result = true;
            return result;
        }

        /// <summary>
        /// 判断当天是否已统计
        /// </summary>
        /// <returns></returns>
        public static bool IsReportByToday()
        {
            var result = false;
            var q = (from x in Funs.DB.CQMSData_CQMS
                     where x.ReportDate < DateTime.Now.AddDays(1).Date && x.ReportDate >= DateTime.Now.Date
                     select x).ToList();
            if (q.Count > 0) result = true;
            return result;
        }

        public static ReturnData PushCncec(string id)
        {
            var baseurl = "/api/CQMSData/SaveCQMSData";
            var item = GetItemById(id);
            var str = JsonConvert.SerializeObject(item);
            var responeData = ServerService.PushCNCEC(str, baseurl);
            return responeData;
        }

        public static CQMSData StatisticalData()
        {
            var thisUnitId = string.Empty;
            var thisUnit = CommonService.GetIsThisUnit();
            if (thisUnit != null) thisUnitId = thisUnit.UnitId;
            var base_Unit = UnitService.GetUnitByUnitId(thisUnitId);
            Project_CQMSDataService.StatisticalAllProjectData();

            var ProjectData = (from x in Funs.DB.Project_CQMSData_CQMS
                               where x.ReportDate < DateTime.Now.AddDays(1).Date && x.ReportDate >= DateTime.Now.Date
                               select x).ToList();
            var table = new CQMSData_CQMS
            {
                UnitId = thisUnitId,
                CollCropCode = base_Unit.CollCropCode,
                UnitName = base_Unit.UnitName,
                ReportDate = DateTime.Now.Date,
                TrainPersonNum = ProjectData.Sum(x => x.TrainPersonNum),
                TechnicalDisclosePersonNum = ProjectData.Sum(x => x.TechnicalDisclosePersonNum),
                UseNum = ProjectData.Sum(x => x.UseNum),
                OKNum = ProjectData.Sum(x => x.OKNum),
                CompanyPersonNum = GetCompanyPersonNum(),
                BranchPersonNum = GetBranchPersonNum(),
                ProjectPersonNum = ProjectData.Sum(x => x.ProjectPersonNum),
                ProblemNum = ProjectData.Sum(x => x.ProblemNum),
                ProblemCompletedNum = ProjectData.Sum(x => x.ProblemCompletedNum),
                ProblemNotCompletedNum = ProjectData.Sum(x => x.ProblemNotCompletedNum),
                SNum = ProjectData.Sum(x => x.SNum),
                ANum = ProjectData.Sum(x => x.ANum),
                BNum = ProjectData.Sum(x => x.BNum),
                CNum = ProjectData.Sum(x => x.CNum),
                KeyProcessNum = ProjectData.Sum(x => x.KeyProcessNum),
                KeyProcessOKNum = ProjectData.Sum(x => x.KeyProcessOKNum),
                SpecialProcessNum = ProjectData.Sum(x => x.SpecialProcessNum),
                SpecialProcessOKNum = ProjectData.Sum(x => x.SpecialProcessOKNum),
                ConcealedWorksNum = ProjectData.Sum(x => x.ConcealedWorksNum),
                ConcealedWorksOKNum = ProjectData.Sum(x => x.ConcealedWorksOKNum),
                UnitProjectOnesNum = ProjectData.Sum(x => x.UnitProjectOnesNum),
                UnitProjectOnesOKNum = ProjectData.Sum(x => x.UnitProjectOnesOKNum),
                MaterialInRecheckNum = ProjectData.Sum(x => x.MaterialInRecheckNum),
                MaterialInRecheckOKNum = ProjectData.Sum(x => x.MaterialInRecheckOKNum),
                SingleProjectNum = ProjectData.Sum(x => x.SingleProjectNum),
                UnitProjectNum = ProjectData.Sum(x => x.UnitProjectNum),
                SubProjectNum = ProjectData.Sum(x => x.SubProjectNum),
                SubdivisionalWorksNum = ProjectData.Sum(x => x.SubdivisionalWorksNum),
                InspectionLotNum = ProjectData.Sum(x => x.InspectionLotNum),
                EquipmentInspectionNum = ProjectData.Sum(x => x.EquipmentInspectionNum),
                EquipmentInspectionQualifiedNum = ProjectData.Sum(x => x.EquipmentInspectionQualifiedNum),
                MachineInspectionNum = ProjectData.Sum(x => x.MachineInspectionNum),
                MachineInspectionQualifiedNum = ProjectData.Sum(x => x.MachineInspectionQualifiedNum),
                PersonInspectionNum = ProjectData.Sum(x => x.PersonInspectionNum),
                PersonInspectionQualifiedNum = ProjectData.Sum(x => x.PersonInspectionQualifiedNum),
                MaterialInspectionNum = ProjectData.Sum(x => x.MaterialInspectionNum),
                MaterialInspectionQualifiedNum = ProjectData.Sum(x => x.MaterialInspectionQualifiedNum),
                ConstructSolutionNum = ProjectData.Sum(x => x.ConstructSolutionNum),
                ConstructSolutionProjectApproveNum = ProjectData.Sum(x => x.ConstructSolutionProjectApproveNum),
                ConstructSolutionUnitApproveNum = ProjectData.Sum(x => x.ConstructSolutionUnitApproveNum),
                SpecialEquipmentQualityAssuranceSystemNum = ProjectData.Sum(x => x.SpecialEquipmentQualityAssuranceSystemNum),
                DesignDetailsNum = ProjectData.Sum(x => x.DesignDetailsNum),
                UnitProjectAcceptNum = ProjectData.Sum(x => x.UnitProjectAcceptNum),
                UnitProjectAcceptOKNum = ProjectData.Sum(x => x.UnitProjectAcceptOKNum),
                SubProjectAcceptNum = ProjectData.Sum(x => x.SubProjectAcceptNum),
                SubProjectAcceptOKNum = ProjectData.Sum(x => x.SubProjectAcceptOKNum),
                SubdivisionalWorksAcceptNum = ProjectData.Sum(x => x.SubdivisionalWorksAcceptNum),
                SubdivisionalWorksAcceptOKNum = ProjectData.Sum(x => x.SubdivisionalWorksAcceptOKNum),
                CreateMan = Const.sysglyId,
                CreateDate = DateTime.Now
            };
            if (IsReportByToday())
            {
                table.Id = GetTodayData().Id;
                table.State = Const.CNCEC_State_1;
                UpdateCQMSData_CQMS(table);
            }
            else
            {
                table.Id = SQLHelper.GetNewID();
                table.State = Const.CNCEC_State_0;
                AddCQMSData_CQMS(table);
            }

            var data = new CQMSData();
            data = GetDataByCQMSData_CQMS(table);
            return data;
        }

        /// <summary>
        /// 获取质量统计数据
        /// </summary> 
        public static async Task<CQMSData> StatisitcalDataAsync()
        {
            return await Task.Run(StatisticalData);
        }
        public static CQMSData GetDataByCQMSData_CQMS(CQMSData_CQMS table)
        {
            var data = new CQMSData();
            var item = new CqmsDataItem();
            item.Id = table.Id;
            item.ReportDate = table.ReportDate.Value.ToShortDateString();
            item.UnitId = table.UnitId;
            item.CollCropCode = table.CollCropCode;
            item.TrainPersonNum = table.TrainPersonNum;
            item.TechnicalDisclosePersonNum = table.TechnicalDisclosePersonNum;
            item.ComprehensiveConTechnologyDisclosureNum = table.ComprehensiveConTechnologyDisclosureNum;
            item.ComprehensiveConTechnologyDisclosurePersonNum = table.ComprehensiveConTechnologyDisclosurePersonNum;
            item.ComprehensiveReviewDrawingsNum = table.ComprehensiveReviewDrawingsNum;
            item.UseNum = table.UseNum;
            item.OKNum = table.OKNum;
            item.CompanyPersonNum = table.CompanyPersonNum;
            item.BranchPersonNum = table.BranchPersonNum;
            item.ProjectPersonNum = table.ProjectPersonNum;
            item.ProjectSubPersonNum = table.ProjectSubPersonNum;
            item.ProblemNum = table.ProblemNum;
            item.ProblemCompletedNum = table.ProblemCompletedNum;
            item.ProblemNotCompletedNum = table.ProblemNotCompletedNum;
            item.ProblemRate = "";
            item.UnitCheckNum = table.UnitCheckNum;
            item.UnitCheckClosedNum = table.UnitCheckClosedNum;
            item.UnitCheckNotClosedNum = table.UnitCheckNotClosedNum;
            item.BranchCheckNum = table.BranchCheckNum;
            item.BranchCheckClosedNum = table.BranchCheckClosedNum;
            item.BranchCheckNotClosedNum = table.BranchCheckNotClosedNum;
            item.SNum = table.SNum;
            item.ANum = table.ANum;
            item.BNum = table.BNum;
            item.CNum = table.CNum;
            item.KeyProcessNum = table.KeyProcessNum;
            item.KeyProcessOKNum = table.KeyProcessOKNum;
            item.KeyProcessRate = "";
            item.SpecialProcessNum = table.SpecialProcessNum;
            item.SpecialProcessOKNum = table.SpecialProcessOKNum;
            item.SpecialProcessRate = "";
            item.ConcealedWorksNum = table.ConcealedWorksNum;
            item.ConcealedWorksOKNum = table.ConcealedWorksOKNum;
            item.ConcealedWorksRate = "";
            item.UnitProjectOnesNum = table.UnitProjectOnesNum;
            item.UnitProjectOnesOKNum = table.UnitProjectOnesOKNum;
            item.UnitProjectOnesRate = "";
            item.MaterialInRecheckNum = table.MaterialInRecheckNum;
            item.MaterialInRecheckOKNum = table.MaterialInRecheckOKNum;
            item.MaterialInRecheckRate = "";
            item.SingleProjectNum = table.SingleProjectNum;
            item.UnitProjectNum = table.UnitProjectNum;
            item.SubProjectNum = table.SubProjectNum;
            item.SubdivisionalWorksNum = table.SubdivisionalWorksNum;
            item.InspectionLotNum = table.InspectionLotNum;
            item.EquipmentInspectionNum = table.EquipmentInspectionNum;
            item.EquipmentInspectionQualifiedNum = table.EquipmentInspectionQualifiedNum;
            item.MachineInspectionNum = table.MachineInspectionNum;
            item.MachineInspectionQualifiedNum = table.MachineInspectionQualifiedNum;
            item.PersonInspectionNum = table.PersonInspectionNum;
            item.PersonInspectionQualifiedNum = table.PersonInspectionQualifiedNum;
            item.MaterialInspectionNum = table.MaterialInspectionNum;
            item.MaterialInspectionQualifiedNum = table.MaterialInspectionQualifiedNum;
            item.ConstructSolutionNum = table.ConstructSolutionNum;
            item.ConstructSolutionProjectApproveNum = table.ConstructSolutionProjectApproveNum;
            item.ConstructSolutionUnitApproveNum = table.ConstructSolutionUnitApproveNum;
            item.SpecialEquipmentQualityAssuranceSystemNum = table.SpecialEquipmentQualityAssuranceSystemNum;
            item.DesignDetailsNum = table.DesignDetailsNum;
            item.UnitProjectAcceptNum = table.UnitProjectAcceptNum;
            item.UnitProjectAcceptOKNum = table.UnitProjectAcceptOKNum;
            item.SubProjectAcceptNum = table.SubProjectAcceptNum;
            item.SubProjectAcceptOKNum = table.SubProjectAcceptOKNum;
            item.SubdivisionalWorksAcceptNum = table.SubdivisionalWorksAcceptNum;
            item.SubdivisionalWorksAcceptOKNum = table.SubdivisionalWorksAcceptOKNum;
            item.InspectionMachineNum = table.InspectionMachineNum;
            item.InspectionMachineQualifiedNum = table.InspectionMachineQualifiedNum;
            var cqmsDataItems = new List<CqmsDataItem>();
            cqmsDataItems.Add(item);
            data.CQMSDataItems = cqmsDataItems;
            return data;

        }

        /// <summary>
        /// 获取企业总部人数
        /// </summary>
        /// <returns></returns>
        public static int GetCompanyPersonNum()
        {
            var unitId = string.Empty;
            var thisUnit = CommonService.GetIsThisUnit();
            if (thisUnit != null) unitId = thisUnit.UnitId;
            var result = (from x in Funs.DB.Person_Persons
                          join y in Funs.DB.Base_WorkPost on x.WorkPostId equals y.WorkPostId
                          where x.IsPost == true && y.IsCQMS == true && x.UnitId == unitId
                          select x).Count();
            return result;
        }

        /// <summary>
        /// 获取企业总部人数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<int> GetCompanyPersonNumAsync()
        {
            return await Task.Run(GetCompanyPersonNum);
        }

        /// <summary>
        /// 获取分支机构人数
        /// </summary>
        /// <returns></returns>
        public static int GetBranchPersonNum()
        {
            var unitId = string.Empty;
            var thisUnit = CommonService.GetIsThisUnit();
            if (thisUnit != null) unitId = thisUnit.UnitId;
            var result = (from x in Funs.DB.Person_Persons
                          join y in Funs.DB.Base_WorkPost on x.WorkPostId equals y.WorkPostId
                          join z in Funs.DB.Base_Unit on x.UnitId equals z.UnitId
                          where x.IsPost == true && y.IsCQMS == true && z.IsBranch == true && x.UnitId != unitId
                          select x).Count();
            return result;
        }

        /// <summary>
        /// 获取分支机构人数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<int> GetBranchPersonNumAsync()
        {
            return await Task.Run(GetBranchPersonNum);
        }

        /// <summary>
        /// 获取项目专职人数
        /// </summary>
        /// <returns></returns>
        public static IEnumerable<Model.OfSafetySupervisorsOutput> GetProjectPersonNum()
        {
            var result = (from x in Funs.DB.SitePerson_Person
                          join y in Funs.DB.Base_WorkPost on x.WorkPostId equals y.WorkPostId
                          join z in Funs.DB.Person_Persons on x.PersonId equals z.PersonId
                          join p in Funs.DB.Base_Project on x.ProjectId equals p.ProjectId into pGroup
                          from p in pGroup.DefaultIfEmpty()
                          join u in Funs.DB.Base_Unit on x.UnitId equals u.UnitId into uGroup
                          from u in uGroup.DefaultIfEmpty()
                          where BeUnderConstructionList.Contains(p.ProjectId) && y.IsCQMS == true
                          select new Model.OfSafetySupervisorsOutput
                          {
                              ProjectId = x.ProjectId,
                              ProjectName = p.ProjectName,
                              ProjectFromUnitId = p.UnitId,
                              UnitId = u.UnitId,
                              UnitName = u.UnitName,
                              Name = x.PersonName,
                              Sex = z.Sex == null ? "" : (z.Sex == "1" ? "男" : "女"),
                              IdentityCard = x.IdentityCard,
                              WorkPostName = y.WorkPostName == null ? "" : y.WorkPostName,
                              Phone = z.Telephone,
                              IsOffice = (u.UnitId == BLL.Const.UnitId_SEDIN ? true : false)
                          }).ToList();
            result = result
                .GroupBy(x => x.IdentityCard)
                .Select(g => g.FirstOrDefault())
                .ToList();
            return result;
        }
        /// <summary>
        /// 获取项目专职人数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<IEnumerable<Model.OfSafetySupervisorsOutput>> GetProjectPersonNumAsync()
        {
            return await Task.Run(GetProjectPersonNum);
        }

        #region 质量监督大检查数据

        #region 企业级-本单位

        /// <summary>
        ///     获取企业质量大检查次数
        /// </summary>
        /// <returns></returns>
        /// <summary>
        ///     获取企业质量大检查次数（异步）
        /// </summary>
        /// <returns></returns>

        #endregion

        #region 分支机构

        /// <summary>
        ///     获取分支机构质量大检查次数
        /// </summary>
        /// <returns></returns>
        /// <summary>
        ///     获取分支机构质量大检查次数（异步）
        /// </summary>
        /// <returns></returns>


        #endregion

        #endregion


        /// <summary>
        /// 获取设备报验
        /// </summary>
        /// <returns></returns>
        public static List<Model.Check_CheckEquipment> GetComprehensive_InspectionEquipment()
        {
            var result = (from x in Funs.DB.Check_CheckEquipment
                          where BeUnderConstructionList.Contains(x.ProjectId) && x.CompileDate > Const.DtmarkTime
                          select x).ToList();
            return result;
        }

        /// <summary>
        /// 获取设备报验(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<Check_CheckEquipment>> GetComprehensive_InspectionEquipmentAsync()
        {
            return await Task.Run(GetComprehensive_InspectionEquipment);
        }

        /// <summary>
        /// 获取人员报验
        /// </summary>
        /// <returns></returns>
        public static List<Model.SitePerson_Person> GetComprehensive_InspectionPerson()
        {
            var result = (from x in Funs.DB.SitePerson_Person
                          where BeUnderConstructionList.Contains(x.ProjectId) && x.IsCQMSCheck.HasValue && x.IsCQMSCheck == true
                          select x).ToList();
            return result;
        }

        /// <summary>
        /// 获取人员报验(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<SitePerson_Person>> GetComprehensive_InspectionPersonAsync()
        {
            return await Task.Run(GetComprehensive_InspectionPerson);
        }

        /// <summary>
        /// 获取机具报验
        /// </summary>
        /// <returns></returns>
        public static List<Model.Check_CheckEquipment> GetComprehensive_InspectionMachine()
        {
            var result = (from x in Funs.DB.Check_CheckEquipment
                          where BeUnderConstructionList.Contains(x.ProjectId) && x.CompileDate > Const.DtmarkTime
                          select x).ToList();
            return result;
        }

        /// <summary>
        /// 获取机具报验(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<Check_CheckEquipment>> GetComprehensive_InspectionMachineAsync()
        {
            return await Task.Run(GetComprehensive_InspectionMachine);
        }

        /// <summary>
        /// 获取在用计量器具数
        /// </summary>
        /// <returns></returns>
        public static List<Check_CheckEquipment> GetUseNum()
        {
            var result = (from x in Funs.DB.Check_CheckEquipment
                          where BeUnderConstructionList.Contains(x.ProjectId) && x.CompileDate > Const.DtmarkTime
                          select x).ToList();
            return result;
        }

        /// <summary>
        /// 获取在用计量器具数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<Check_CheckEquipment>> GetUseNumAsync()
        {
            return await Task.Run(GetUseNum);
        }

        /// <summary>
        /// 获取校准合格数
        /// </summary>
        /// <returns></returns>
        public static List<Check_CheckEquipment> GetOkNum()
        {
            var result = (from x in Funs.DB.Check_CheckEquipment
                          where BeUnderConstructionList.Contains(x.ProjectId) && x.IsCheckCertificate == true
                          && x.CompileDate > Const.DtmarkTime
                          select x).ToList();
            return result;
        }

        /// <summary>
        /// 获取校准合格数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<Check_CheckEquipment>> GetOkNumAsync()
        {
            return await Task.Run(GetOkNum);
        }

        /// <summary>
        /// 获取单项工程个数  
        /// </summary>
        /// <returns></returns>
        public static List<ProjectData_MainItem> GetSingleProjectNum()
        {
            var result = (from x in Funs.DB.ProjectData_MainItem
                          where BeUnderConstructionList.Contains(x.ProjectId)
                          select x).ToList();
            return result;
        }

        /// <summary>
        /// 获取单项工程个数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<ProjectData_MainItem>> GetSingleProjectNumAsync()
        {
            return await Task.Run(GetSingleProjectNum);
        }

        /// <summary>
        /// 获取单位工程个数
        /// </summary>
        /// <returns></returns>
        public static List<WBS_UnitWork> GetUnitProjectNum()
        {
            var result = (from x in Funs.DB.WBS_UnitWork
                          where BeUnderConstructionList.Contains(x.ProjectId)
                          select x).ToList();
            return result;
        }

        /// <summary>
        /// 获取单位工程个数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<WBS_UnitWork>> GetUnitProjectNumAsync()
        {
            return await Task.Run(GetUnitProjectNum);
        }

        /// <summary>
        /// 获取分部工程个数
        /// </summary>
        /// <returns></returns>
        public static List<WBS_WorkPackage> GetSubProjectNum()
        {
            var result = (from x in Funs.DB.WBS_WorkPackage
                          where BeUnderConstructionList.Contains(x.ProjectId) && x.SubItemType == "1" && x.IsApprove == true
                          select x).ToList();
            return result;
        }

        /// <summary>
        /// 获取分部工程个数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<WBS_WorkPackage>> GetSubProjectNumAsync()
        {
            return await Task.Run(GetSubProjectNum);
        }

        /// <summary>
        /// 获取分项工程个数
        /// </summary>
        /// <returns></returns>
        public static List<WBS_WorkPackage> GetSubdivisionalWorksNum()
        {
            var result = (from x in Funs.DB.WBS_WorkPackage
                          where BeUnderConstructionList.Contains(x.ProjectId) && x.SubItemType == "3" && x.IsApprove == true
                          select x).ToList();
            return result;
        }

        /// <summary>
        /// 获取分项工程个数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<WBS_WorkPackage>> GetSubdivisionalWorksNumAsync()
        {
            return await Task.Run(GetSubdivisionalWorksNum);
        }

        /// <summary>
        /// 获取检验批个数
        /// </summary>
        /// <returns></returns>
        public static List<WBSBreakdownProjectOutput> GetInspectionLotNum()
        {
            var result = (from x in Funs.DB.WBS_BreakdownProject
                          where BeUnderConstructionList.Contains(x.ProjectId) && x.IsSelected == true
                          group x by x.ProjectId into g
                          select new Model.WBSBreakdownProjectOutput()
                          {
                              ProjectId = g.Key,
                              Sum = g.Count(),
                          }).ToList();
            return result;
        }

        /// <summary>
        /// 获取检验批个数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<WBSBreakdownProjectOutput>> GetInspectionLotNumAsync()
        {
            return await Task.Run(GetInspectionLotNum);
        }


        /// <summary>
        /// 获取质量问题
        /// </summary>
        /// <returns></returns>
        public static List<Check_CheckControl> GetCQMSProblem()
        {
            var result = (from x in Funs.DB.Check_CheckControl
                          where BeUnderConstructionList.Contains(x.ProjectId) && x.CheckDate > Const.DtmarkTime
                          select x).ToList();
            return result;
        }

        /// <summary>
        /// 获取质量问题(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<Check_CheckControl>> GetCQMSProblemAsync()
        {
            return await Task.Run(GetCQMSProblem);
        }


        #region 质量验收数据

        /// <summary>
        /// 获取关键工序验收数
        /// </summary>
        /// <returns></returns>
        public static List<InspectionManagementOutput> GetKeyProcessNum()
        {
            var result = (from x in Funs.DB.Check_SpotCheckDetail
                          join y in Funs.DB.WBS_ControlItemAndCycle on x.ControlItemAndCycleId equals y.ControlItemAndCycleId
                          where BeUnderConstructionList.Contains(y.ProjectId) && y.CheckAcceptType == "1" && x.CreateDate > Const.DtmarkTime
                          select new Model.InspectionManagementOutput()
                          {
                              ProjectId = y.ProjectId,
                              //ProjectName = p.ProjectName,
                              //UnitName = UnitService.getUnitNamesUnitIds(x.UnitIds),
                              Id = x.SpotCheckDetailId,
                              BreakdownCode = y.ControlItemAndCycleCode,
                              BreakdownName = y.ControlItemContent,
                              Basis = y.HGForms,
                              CheckPoints = y.ControlItemDef,
                          }).ToList();
            return result;
        }
        /// <summary>
        /// 获取关键工序验收数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<InspectionManagementOutput>> GetKeyProcessNumAsync()
        {
            return await Task.Run(GetKeyProcessNum);
        }

        /// <summary>
        /// 获取关键工序验收合格数
        /// </summary>
        /// <returns></returns>
        public static List<InspectionManagementOutput> GetKeyProcessOkNum()
        {
            var result = (from x in Funs.DB.Check_SpotCheckDetail
                          join y in Funs.DB.WBS_ControlItemAndCycle on x.ControlItemAndCycleId equals y.ControlItemAndCycleId
                          where BeUnderConstructionList.Contains(y.ProjectId) && y.CheckAcceptType == "1" && x.IsOK == true && x.CreateDate > Const.DtmarkTime
                          select new Model.InspectionManagementOutput()
                          {
                              ProjectId = y.ProjectId,
                              //ProjectName = p.ProjectName,
                              //UnitName = UnitService.getUnitNamesUnitIds(x.UnitIds),
                              Id = x.SpotCheckDetailId,
                              BreakdownCode = y.ControlItemAndCycleCode,
                              BreakdownName = y.ControlItemContent,
                              Basis = y.HGForms,
                              CheckPoints = y.ControlItemDef,
                          }).ToList();
            return result;
        }
        /// <summary>
        /// 获取关键工序验收合格数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<InspectionManagementOutput>> GetKeyProcessOkNumAsync()
        {
            return await Task.Run(GetKeyProcessOkNum);
        }

        /// <summary>
        /// 获取特殊过程验收数
        /// </summary>
        /// <returns></returns>
        public static List<InspectionManagementOutput> GetSpecialProcessNum()
        {
            var result = (from x in Funs.DB.Check_SpotCheckDetail
                          join y in Funs.DB.WBS_ControlItemAndCycle on x.ControlItemAndCycleId equals y.ControlItemAndCycleId
                          where BeUnderConstructionList.Contains(y.ProjectId) && y.CheckAcceptType == "2" && x.CreateDate > Const.DtmarkTime
                          select new Model.InspectionManagementOutput()
                          {
                              ProjectId = y.ProjectId,
                              //ProjectName = p.ProjectName,
                              //UnitName = UnitService.getUnitNamesUnitIds(x.UnitIds),
                              Id = x.SpotCheckDetailId,
                              BreakdownCode = y.ControlItemAndCycleCode,
                              BreakdownName = y.ControlItemContent,
                              Basis = y.HGForms,
                              CheckPoints = y.ControlItemDef,
                          }).ToList();
            return result;
        }
        /// <summary>
        /// 获取特殊过程验收数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<InspectionManagementOutput>> GetSpecialProcessNumAsync()
        {
            return await Task.Run(GetSpecialProcessNum);
        }
        /// <summary>
        /// 获取特殊过程验收合格数
        /// </summary>
        /// <returns></returns>
        public static List<InspectionManagementOutput> GetSpecialProcessOkNum()
        {
            var result = (from x in Funs.DB.Check_SpotCheckDetail
                          join y in Funs.DB.WBS_ControlItemAndCycle on x.ControlItemAndCycleId equals y.ControlItemAndCycleId
                          where BeUnderConstructionList.Contains(y.ProjectId) && y.CheckAcceptType == "2" && x.IsOK == true && x.CreateDate > Const.DtmarkTime
                          select new Model.InspectionManagementOutput()
                          {
                              ProjectId = y.ProjectId,
                              //ProjectName = p.ProjectName,
                              //UnitName = UnitService.getUnitNamesUnitIds(x.UnitIds),
                              Id = x.SpotCheckDetailId,
                              BreakdownCode = y.ControlItemAndCycleCode,
                              BreakdownName = y.ControlItemContent,
                              Basis = y.HGForms,
                              CheckPoints = y.ControlItemDef,
                          }).ToList();
            return result;
        }
        /// <summary>
        /// 获取特殊过程验收合格数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<InspectionManagementOutput>> GetSpecialProcessOkNumAsync()
        {
            return await Task.Run(GetSpecialProcessOkNum);
        }
        /// <summary>
        /// 获取隐蔽工程验收数
        /// </summary>
        /// <returns></returns>
        public static List<InspectionManagementOutput> GetConcealedWorksNum()
        {
            var result = (from x in Funs.DB.Check_SpotCheckDetail
                          join y in Funs.DB.WBS_ControlItemAndCycle on x.ControlItemAndCycleId equals y.ControlItemAndCycleId
                          where BeUnderConstructionList.Contains(y.ProjectId) && y.CheckAcceptType == "3" && x.CreateDate > Const.DtmarkTime
                          select new Model.InspectionManagementOutput()
                          {
                              ProjectId = y.ProjectId,
                              //ProjectName = p.ProjectName,
                              //UnitName = UnitService.getUnitNamesUnitIds(x.UnitIds),
                              Id = x.SpotCheckDetailId,
                              BreakdownCode = y.ControlItemAndCycleCode,
                              BreakdownName = y.ControlItemContent,
                              Basis = y.HGForms,
                              CheckPoints = y.ControlItemDef,
                          }).ToList();
            return result;
        }
        /// <summary>
        /// 获取隐蔽工程验收数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<InspectionManagementOutput>> GetConcealedWorksNumAsync()
        {
            return await Task.Run(GetConcealedWorksNum);
        }
        /// <summary>
        /// 获取隐蔽工程验收合格数
        /// </summary>
        /// <returns></returns>
        public static List<InspectionManagementOutput> GetConcealedWorksOkNum()
        {
            var result = (from x in Funs.DB.Check_SpotCheckDetail
                          join y in Funs.DB.WBS_ControlItemAndCycle on x.ControlItemAndCycleId equals y.ControlItemAndCycleId
                          where BeUnderConstructionList.Contains(y.ProjectId) && y.CheckAcceptType == "3" && x.IsOK == true && x.CreateDate > Const.DtmarkTime
                          select new Model.InspectionManagementOutput()
                          {
                              ProjectId = y.ProjectId,
                              //ProjectName = p.ProjectName,
                              //UnitName = UnitService.getUnitNamesUnitIds(x.UnitIds),
                              Id = x.SpotCheckDetailId,
                              BreakdownCode = y.ControlItemAndCycleCode,
                              BreakdownName = y.ControlItemContent,
                              Basis = y.HGForms,
                              CheckPoints = y.ControlItemDef,
                          }).ToList();
            return result;
        }
        /// <summary>
        /// 获取隐蔽工程验收合格数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<InspectionManagementOutput>> GetConcealedWorksOkNumAsync()
        {
            return await Task.Run(GetConcealedWorksOkNum);
        }

        /// <summary>
        /// 获取单位工程验收数
        /// </summary>
        /// <returns></returns>
        public static List<InspectionManagementOutput> GetUnitProjectAcceptNum()
        {
            var result = (from x in Funs.DB.Check_SpotCheckDetail
                          join y in Funs.DB.WBS_ControlItemAndCycle on x.ControlItemAndCycleId equals y.ControlItemAndCycleId
                          where BeUnderConstructionList.Contains(y.ProjectId) && y.CheckAcceptType == "4" && x.CreateDate > Const.DtmarkTime
                          select new Model.InspectionManagementOutput()
                          {
                              ProjectId = y.ProjectId,
                              //ProjectName = p.ProjectName,
                              //UnitName = UnitService.getUnitNamesUnitIds(x.UnitIds),
                              Id = x.SpotCheckDetailId,
                              BreakdownCode = y.ControlItemAndCycleCode,
                              BreakdownName = y.ControlItemContent,
                              Basis = y.HGForms,
                              CheckPoints = y.ControlItemDef,
                          }).ToList();
            return result;
        }
        /// <summary>
        /// 获取单位工程验收数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<InspectionManagementOutput>> GetUnitProjectAcceptNumAsync()
        {
            return await Task.Run(GetUnitProjectAcceptNum);
        }
        /// <summary>
        /// 获取单位工程验收合格数
        /// </summary>
        /// <returns></returns>
        public static List<InspectionManagementOutput> GetUnitProjectAcceptOKNum()
        {
            var result = (from x in Funs.DB.Check_SpotCheckDetail
                          join y in Funs.DB.WBS_ControlItemAndCycle on x.ControlItemAndCycleId equals y.ControlItemAndCycleId
                          where BeUnderConstructionList.Contains(y.ProjectId) && y.CheckAcceptType == "4" && x.IsOK == true && x.CreateDate > Const.DtmarkTime
                          select new Model.InspectionManagementOutput()
                          {
                              ProjectId = y.ProjectId,
                              //ProjectName = p.ProjectName,
                              //UnitName = UnitService.getUnitNamesUnitIds(x.UnitIds),
                              Id = x.SpotCheckDetailId,
                              BreakdownCode = y.ControlItemAndCycleCode,
                              BreakdownName = y.ControlItemContent,
                              Basis = y.HGForms,
                              CheckPoints = y.ControlItemDef,
                          }).ToList();
            return result;
        }
        /// <summary>
        /// 获取单位工程验收合格数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<InspectionManagementOutput>> GetUnitProjectAcceptOKNumAsync()
        {
            return await Task.Run(GetUnitProjectAcceptOKNum);
        }


        /// 获取材料进场复验数
        /// </summary>
        /// <returns></returns>
        public static List<InspectionManagementOutput> GetMaterialInRecheckNum()
        {
            var result = (from x in Funs.DB.Check_SpotCheckDetail
                          join y in Funs.DB.WBS_ControlItemAndCycle on x.ControlItemAndCycleId equals y.ControlItemAndCycleId
                          where BeUnderConstructionList.Contains(y.ProjectId) && y.CheckAcceptType == "5" && x.CreateDate > Const.DtmarkTime
                          select new Model.InspectionManagementOutput()
                          {
                              ProjectId = y.ProjectId,
                              //ProjectName = p.ProjectName,
                              //UnitName = UnitService.getUnitNamesUnitIds(x.UnitIds),
                              Id = x.SpotCheckDetailId,
                              BreakdownCode = y.ControlItemAndCycleCode,
                              BreakdownName = y.ControlItemContent,
                              Basis = y.HGForms,
                              CheckPoints = y.ControlItemDef,
                          }).ToList();
            return result;
        }
        /// <summary>
        /// 获取材料进场复验数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<InspectionManagementOutput>> GetMaterialInRecheckNumAsync()
        {
            return await Task.Run(GetMaterialInRecheckNum);
        }
        /// <summary>
        /// 获取材料进场复验数合格数
        /// </summary>
        /// <returns></returns>
        public static List<InspectionManagementOutput> GetMaterialInRecheckOKNum()
        {
            var result = (from x in Funs.DB.Check_SpotCheckDetail
                          join y in Funs.DB.WBS_ControlItemAndCycle on x.ControlItemAndCycleId equals y.ControlItemAndCycleId
                          where BeUnderConstructionList.Contains(y.ProjectId) && y.CheckAcceptType == "5" && x.IsOK == true && x.CreateDate > Const.DtmarkTime
                          select new Model.InspectionManagementOutput()
                          {
                              ProjectId = y.ProjectId,
                              //ProjectName = p.ProjectName,
                              //UnitName = UnitService.getUnitNamesUnitIds(x.UnitIds),
                              Id = x.SpotCheckDetailId,
                              BreakdownCode = y.ControlItemAndCycleCode,
                              BreakdownName = y.ControlItemContent,
                              Basis = y.HGForms,
                              CheckPoints = y.ControlItemDef,
                          }).ToList();
            return result;
        }
        /// <summary>
        /// 获取材料进场复验数合格数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<InspectionManagementOutput>> GetMaterialInRecheckOKNumAsync()
        {
            return await Task.Run(GetMaterialInRecheckOKNum);
        }

        /// <summary>
        /// 获取分部工程验收数
        /// </summary>
        /// <returns></returns>
        public static List<InspectionManagementOutput> GetSubProjectAcceptNum()
        {
            var result = (from x in Funs.DB.Check_SpotCheckDetail
                          join y in Funs.DB.WBS_ControlItemAndCycle on x.ControlItemAndCycleId equals y.ControlItemAndCycleId
                          where BeUnderConstructionList.Contains(y.ProjectId) && y.CheckAcceptType == "5" && x.CreateDate > Const.DtmarkTime
                          select new Model.InspectionManagementOutput()
                          {
                              ProjectId = y.ProjectId,
                              //ProjectName = p.ProjectName,
                              //UnitName = UnitService.getUnitNamesUnitIds(x.UnitIds),
                              Id = x.SpotCheckDetailId,
                              BreakdownCode = y.ControlItemAndCycleCode,
                              BreakdownName = y.ControlItemContent,
                              Basis = y.HGForms,
                              CheckPoints = y.ControlItemDef,
                          }).ToList();
            return result;
        }
        /// <summary>
        /// 获取分部工程验收数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<InspectionManagementOutput>> GetSubProjectAcceptNumAsync()
        {
            return await Task.Run(GetSubProjectAcceptNum);
        }
        /// <summary>
        /// 获取分部工程验收合格数
        /// </summary>
        /// <returns></returns>
        public static List<InspectionManagementOutput> GetSubProjectAcceptOKNum()
        {
            var result = (from x in Funs.DB.Check_SpotCheckDetail
                          join y in Funs.DB.WBS_ControlItemAndCycle on x.ControlItemAndCycleId equals y.ControlItemAndCycleId
                          where BeUnderConstructionList.Contains(y.ProjectId) && y.CheckAcceptType == "5" && x.IsOK == true && x.CreateDate > Const.DtmarkTime
                          select new Model.InspectionManagementOutput()
                          {
                              ProjectId = y.ProjectId,
                              //ProjectName = p.ProjectName,
                              //UnitName = UnitService.getUnitNamesUnitIds(x.UnitIds),
                              Id = x.SpotCheckDetailId,
                              BreakdownCode = y.ControlItemAndCycleCode,
                              BreakdownName = y.ControlItemContent,
                              Basis = y.HGForms,
                              CheckPoints = y.ControlItemDef,
                          }).ToList();
            return result;
        }
        /// <summary>
        /// 获取分部工程验收合格数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<InspectionManagementOutput>> GetSubProjectAcceptOKNumAsync()
        {
            return await Task.Run(GetSubProjectAcceptOKNum);
        }
        /// <summary>
        /// 获取分项工程验收数
        /// </summary>
        /// <returns></returns>
        public static List<InspectionManagementOutput> GetSubdivisionalWorksAcceptNum()
        {
            var result = (from x in Funs.DB.Check_SpotCheckDetail
                          join y in Funs.DB.WBS_ControlItemAndCycle on x.ControlItemAndCycleId equals y.ControlItemAndCycleId
                          where BeUnderConstructionList.Contains(y.ProjectId) && y.CheckAcceptType == "6" && x.CreateDate > Const.DtmarkTime
                          select new Model.InspectionManagementOutput()
                          {
                              ProjectId = y.ProjectId,
                              //ProjectName = p.ProjectName,
                              //UnitName = UnitService.getUnitNamesUnitIds(x.UnitIds),
                              Id = x.SpotCheckDetailId,
                              BreakdownCode = y.ControlItemAndCycleCode,
                              BreakdownName = y.ControlItemContent,
                              Basis = y.HGForms,
                              CheckPoints = y.ControlItemDef,
                          }).ToList();
            return result;
        }
        /// <summary>
        /// 获取分项工程验收数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<InspectionManagementOutput>> GetSubdivisionalWorksAcceptNumAsync()
        {
            return await Task.Run(GetSubdivisionalWorksAcceptNum);
        }
        /// <summary>
        /// 获取分项工程验收合格数
        /// </summary>
        /// <returns></returns>
        public static List<InspectionManagementOutput> GetSubdivisionalWorksAcceptOKNum()
        {
            var result = (from x in Funs.DB.Check_SpotCheckDetail
                          join y in Funs.DB.WBS_ControlItemAndCycle on x.ControlItemAndCycleId equals y.ControlItemAndCycleId
                          where BeUnderConstructionList.Contains(y.ProjectId) && y.CheckAcceptType == "6" && x.IsOK == true && x.CreateDate > Const.DtmarkTime
                          select new Model.InspectionManagementOutput()
                          {
                              ProjectId = y.ProjectId,
                              //ProjectName = p.ProjectName,
                              //UnitName = UnitService.getUnitNamesUnitIds(x.UnitIds),
                              Id = x.SpotCheckDetailId,
                              BreakdownCode = y.ControlItemAndCycleCode,
                              BreakdownName = y.ControlItemContent,
                              Basis = y.HGForms,
                              CheckPoints = y.ControlItemDef,
                          }).ToList();
            return result;
        }
        /// <summary>
        /// 获取分项工程验收合格数(异步)
        /// </summary>
        /// <returns></returns>
        public static async Task<List<InspectionManagementOutput>> GetSubdivisionalWorksAcceptOKNumAsync()
        {
            return await Task.Run(GetSubdivisionalWorksAcceptOKNum);
        }
        #endregion

    }
}