peis/src/Shentun.Peis.Application/PeisReports/PeisReportAppService.cs

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Shentun.Peis.CustomerOrgs;
using Shentun.Peis.Enums;
using Shentun.Peis.Models;
using Shentun.Peis.PatientRegisters;
using Shentun.Peis.SampleTypes;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;

namespace Shentun.Peis.PeisReports
{
    /// <summary>
    /// 体检查询
    /// </summary>
    [ApiExplorerSettings(GroupName = "Work")]
    [Authorize]
    public class PeisReportAppService : ApplicationService
    {
        private readonly IRepository<PatientRegister, Guid> _patientRegisterRepository;
        private readonly IRepository<Patient, Guid> _patientRepository;
        private readonly IRepository<MedicalType, Guid> _medicalTypeRepository;
        private readonly IRepository<PersonnelType, Guid> _personnelTypeRepository;
        private readonly IRepository<CustomerOrgGroup, Guid> _customerOrgGroupRepository;
        private readonly IRepository<MedicalPackage, Guid> _medicalPackageRepository;
        private readonly IRepository<CustomerOrg, Guid> _customerOrgRepository;
        private readonly IRepository<Sex> _sexRepository;
        private readonly IRepository<RegisterCheckAsbitem, Guid> _registerAsbitemRepository;
        private readonly IRepository<RegisterCheck, Guid> _registerCheckRepository;
        private readonly IRepository<Asbitem, Guid> _asbitemRepository;
        private readonly CustomerOrgManager _customerOrgManager;
        private readonly CacheService _cacheService;

        public PeisReportAppService(
            IRepository<PatientRegister, Guid> patientRegisterRepository,
            IRepository<Patient, Guid> patientRepository,
            IRepository<MedicalType, Guid> medicalTypeRepository,
            IRepository<PersonnelType, Guid> personnelTypeRepository,
            IRepository<CustomerOrgGroup, Guid> customerOrgGroupRepository,
            IRepository<MedicalPackage, Guid> medicalPackageRepository,
            IRepository<CustomerOrg, Guid> customerOrgRepository,
            IRepository<Sex> sexRepository,
            IRepository<RegisterCheckAsbitem, Guid> registerAsbitemRepository,
            IRepository<RegisterCheck, Guid> registerCheckRepository,
            IRepository<Asbitem, Guid> asbitemRepository,
            CustomerOrgManager customerOrgManager,
            CacheService cacheService)
        {
            this._patientRegisterRepository = patientRegisterRepository;
            this._patientRepository = patientRepository;
            this._medicalTypeRepository = medicalTypeRepository;
            this._personnelTypeRepository = personnelTypeRepository;
            this._customerOrgGroupRepository = customerOrgGroupRepository;
            this._medicalPackageRepository = medicalPackageRepository;
            this._customerOrgRepository = customerOrgRepository;
            this._sexRepository = sexRepository;
            this._registerAsbitemRepository = registerAsbitemRepository;
            this._registerCheckRepository = registerCheckRepository;
            this._asbitemRepository = asbitemRepository;
            this._customerOrgManager = customerOrgManager;
            this._cacheService = cacheService;
        }


        /// <summary>
        /// 体检报告查询接口
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/peisreport/getpatientregisterreport")]
        public async Task<PagedResultDto<GetPatientRegisterReportDto>> GetPatientRegisterReportAsync(GetPatientRegisterReportRequestDto input)
        {
            var query = from a in await _patientRegisterRepository.GetQueryableAsync()
                        join b in await _patientRepository.GetQueryableAsync() on a.PatientId equals b.Id into bb
                        from ab in bb.DefaultIfEmpty()
                        join registerCheck in await _registerCheckRepository.GetQueryableAsync() on a.Id equals registerCheck.PatientRegisterId
                        join registerAsbitem in await _registerAsbitemRepository.GetQueryableAsync() on registerCheck.Id equals registerAsbitem.RegisterCheckId
                        join asbitem in await _asbitemRepository.GetQueryableAsync() on registerAsbitem.AsbitemId equals asbitem.Id
                        join c in await _customerOrgGroupRepository.GetQueryableAsync() on a.CustomerOrgGroupId equals c.Id into cc
                        from ac in cc.DefaultIfEmpty()
                        join d in await _medicalPackageRepository.GetQueryableAsync() on a.MedicalPackageId equals d.Id into dd
                        from ad in dd.DefaultIfEmpty()
                        join e in await _medicalTypeRepository.GetQueryableAsync() on a.MedicalTypeId equals e.Id into ee
                        from ae in ee.DefaultIfEmpty()
                        join f in await _personnelTypeRepository.GetQueryableAsync() on a.PersonnelTypeId equals f.Id into ff
                        from af in ff.DefaultIfEmpty()
                        join g in await _sexRepository.GetQueryableAsync() on a.SexId equals g.Id into gg
                        from ag in gg.DefaultIfEmpty()
                        orderby a.Id ascending
                        select new
                        {
                            a = new
                            {
                                a.Id,
                                a.CustomerOrgGroupId,
                                a.CustomerOrgRegisterId,
                                a.CustomerOrgId,
                                a.CreationTime,
                                a.MedicalStartDate,
                                a.SummaryDate,
                                a.PatientName,
                                a.PatientRegisterNo,
                                a.Age,
                                a.BirthDate,
                                a.CompleteFlag,
                                a.IsAudit,
                                a.ReportPrintTimes,
                                a.MedicalTypeId,
                                a.PersonnelTypeId,
                                a.IsUpload
                            },
                            RegisterCheckCompleteFlag = registerCheck.CompleteFlag,
                            IsCheck = asbitem.IsCheck,
                            ab = new { ab.IdNo, ab.Address, ab.PatientNo, ab.MobileTelephone, ab.Telephone, ab.Email, ab.DisplayName },
                            ac = new { ac.DisplayName },
                            ad = new { ad.DisplayName },
                            ae = new { ae.DisplayName },
                            af = new { af.DisplayName },
                            ag = new { ag.DisplayName },
                        };


            var sumquery = query;


            if (input.CustomerOrgs.Any())
            {

                var item = input.CustomerOrgs[0];

                if (item.CustomerOrgGroupId.Any())
                {
                    sumquery = sumquery.Where(m => m.a.CustomerOrgGroupId != null && item.CustomerOrgGroupId.Contains(m.a.CustomerOrgGroupId.Value));
                }
                if (item.CustomerOrgRegisterId != null && item.CustomerOrgRegisterId != Guid.Empty)
                {
                    sumquery = sumquery.Where(m => m.a.CustomerOrgRegisterId == item.CustomerOrgRegisterId);
                }
                if (item.CustomerOrgId != null)
                {
                    var CustomerOrgIds = await _customerOrgManager.GetCustomerOrgChildrenId(item.CustomerOrgId.Value);
                    sumquery = sumquery.Where(m => CustomerOrgIds.Contains(m.a.CustomerOrgId));
                }
                if (!string.IsNullOrEmpty(item.StartDate) && !string.IsNullOrEmpty(item.EndDate))
                {
                    if (item.DateType == '1')
                    {
                        sumquery = sumquery.Where(m => m.a.CreationTime >= Convert.ToDateTime(item.StartDate) &&
                     m.a.CreationTime < Convert.ToDateTime(item.EndDate).AddDays(1));
                    }
                    else if (item.DateType == '2')
                    {
                        sumquery = sumquery.Where(m => m.a.MedicalStartDate != null && m.a.MedicalStartDate.Value >= Convert.ToDateTime(item.StartDate) &&
                     m.a.MedicalStartDate.Value < Convert.ToDateTime(item.EndDate).AddDays(1));
                    }
                    else if (item.DateType == '3')
                    {
                        sumquery = sumquery.Where(m => m.a.SummaryDate != null && m.a.SummaryDate.Value >= Convert.ToDateTime(item.StartDate) &&
                  m.a.SummaryDate.Value < Convert.ToDateTime(item.EndDate).AddDays(1));
                    }
                }

                if (input.CustomerOrgs.Count > 1)
                {
                    foreach (var item2 in input.CustomerOrgs)
                    {

                        if (input.CustomerOrgs.IndexOf(item2) > 0)
                        {
                            var newquery = query;
                            if (item2.CustomerOrgGroupId.Any())
                            {
                                newquery = newquery.Where(m => m.a.CustomerOrgGroupId != null && item2.CustomerOrgGroupId.Contains(m.a.CustomerOrgGroupId.Value));
                            }
                            if (item2.CustomerOrgRegisterId != null && item2.CustomerOrgRegisterId != Guid.Empty)
                            {
                                newquery = newquery.Where(m => m.a.CustomerOrgRegisterId == item2.CustomerOrgRegisterId);
                            }
                            if (item2.CustomerOrgId != null)
                            {
                                var CustomerOrgIds = await _customerOrgManager.GetCustomerOrgChildrenId(item2.CustomerOrgId.Value);
                                newquery = newquery.Where(m => CustomerOrgIds.Contains(m.a.CustomerOrgId));
                            }
                            if (!string.IsNullOrEmpty(item2.StartDate) && !string.IsNullOrEmpty(item2.EndDate))
                            {
                                if (item2.DateType == '1')
                                {
                                    newquery = newquery.Where(m => m.a.CreationTime >= Convert.ToDateTime(item2.StartDate) &&
                                 m.a.CreationTime < Convert.ToDateTime(item2.EndDate).AddDays(1));
                                }
                                else if (item2.DateType == '2')
                                {
                                    newquery = newquery.Where(m => m.a.MedicalStartDate != null && m.a.MedicalStartDate.Value >= Convert.ToDateTime(item2.StartDate) &&
                                 m.a.MedicalStartDate.Value < Convert.ToDateTime(item2.EndDate).AddDays(1));
                                }
                                else if (item2.DateType == '3')
                                {
                                    newquery = newquery.Where(m => m.a.SummaryDate != null && m.a.SummaryDate.Value >= Convert.ToDateTime(item2.StartDate) &&
                              m.a.SummaryDate.Value < Convert.ToDateTime(item2.EndDate).AddDays(1));
                                }
                            }
                            sumquery = sumquery.Union(newquery);
                        }
                    }
                }
            }

            if (!string.IsNullOrEmpty(input.PatientName))
            {
                sumquery = sumquery.Where(m => m.a.PatientName != null && m.a.PatientName.Contains(input.PatientName));
            }

            if (!string.IsNullOrEmpty(input.PatientRegisterNo))
            {
                sumquery = sumquery.Where(m => m.a.PatientRegisterNo == input.PatientRegisterNo);
            }

            if (!string.IsNullOrEmpty(input.PatientNo))
            {
                sumquery = sumquery.Where(m => m.ab.PatientNo == input.PatientNo);
            }

            if (!string.IsNullOrEmpty(input.phone))
            {
                sumquery = sumquery.Where(m => m.ab.MobileTelephone == input.phone || m.ab.Telephone == input.phone);
            }

            if (input.CompleteFlag != null && input.CompleteFlag != PatientRegisterCompleteFlag.ItemCheckUnSumCheck)
            {
                sumquery = sumquery.Where(m => m.a.CompleteFlag == input.CompleteFlag);
            }
            else
            {
                sumquery = sumquery.Where(m => m.a.CompleteFlag != PatientRegisterCompleteFlag.PreRegistration);
            }

            if (input.IsAudit != null)
            {
                sumquery = sumquery.Where(m => m.a.IsAudit == input.IsAudit);
            }

            if (input.IsReportPrint != null)
            {
                if (input.IsReportPrint == 'Y')
                {
                    sumquery = sumquery.Where(m => m.a.ReportPrintTimes > 0);
                }
                else
                {
                    sumquery = sumquery.Where(m => m.a.ReportPrintTimes == 0);
                }
            }

            if (input.MedicalTypeId != null)
            {
                sumquery = sumquery.Where(m => m.a.MedicalTypeId == input.MedicalTypeId);
            }

            if (input.PersonnelTypeId != null)
            {
                sumquery = sumquery.Where(m => m.a.PersonnelTypeId == input.PersonnelTypeId);
            }

            if (input.IsUpload != null)
            {
                sumquery = sumquery.Where(m => m.a.IsUpload == input.IsUpload);
            }

            if (!string.IsNullOrEmpty(input.IdNo))
            {
                sumquery = sumquery.Where(m => m.ab.IdNo == input.IdNo);
            }




            var sumqueryGroup = sumquery.ToList().GroupBy(g => g.a.Id);


            List<GetPatientRegisterReportDto> entlist = new List<GetPatientRegisterReportDto>();

            foreach (var s in sumqueryGroup.OrderBy(o => o.Key))
            {
                bool IsDisplay = false;

                if (input.CompleteFlag == PatientRegisterCompleteFlag.ItemCheckUnSumCheck)
                {
                    if (s.Where(m => m.RegisterCheckCompleteFlag != RegisterCheckCompleteFlag.Checked && m.IsCheck == 'Y').Count() == 0
                        && s.FirstOrDefault().a.CompleteFlag != PatientRegisterCompleteFlag.SumCheck)
                    {
                        IsDisplay = true;
                    }
                    else
                    {
                        IsDisplay = false;
                    }
                }
                else
                {
                    IsDisplay = true;
                }

                if (IsDisplay)
                {
                    entlist.Add(new GetPatientRegisterReportDto
                    {
                        Address = s.FirstOrDefault().ab.Address,
                        PatientName = s.FirstOrDefault().a.PatientName,
                        Age = s.FirstOrDefault().a.Age,
                        BirthDate = DataHelper.ConversionDateToString(s.FirstOrDefault().a.BirthDate),
                        CompleteFlag = s.FirstOrDefault().a.CompleteFlag,
                        CustomerOrgGroupName = s.FirstOrDefault().ac.DisplayName,
                        //CustomerOrgName = _cacheService.GetTopCustomerOrgAsync(s.a.CustomerOrgId).Result.DisplayName,
                        CustomerOrgName = _cacheService.GetTopCustomerOrgNameAsync(s.FirstOrDefault().a.CustomerOrgId).Result,
                        DepartmentName = _cacheService.GetCustomerOrgNameAsync(s.FirstOrDefault().a.CustomerOrgId).Result,
                        Email = s.FirstOrDefault().ab.Email,
                        IdNo = s.FirstOrDefault().ab.IdNo,
                        IsAudit = s.FirstOrDefault().a.IsAudit,
                        IsReportPrint = s.FirstOrDefault().a.ReportPrintTimes > 0 ? 'Y' : 'N',
                        MedicalPackageName = s.FirstOrDefault().ad.DisplayName,
                        MedicalTypeName = s.FirstOrDefault().ae.DisplayName,
                        MobileTelephone = s.FirstOrDefault().ab.MobileTelephone,
                        PatientNo = s.FirstOrDefault().ab.PatientNo,
                        PatientRegisterNo = s.FirstOrDefault().a.PatientRegisterNo,
                        PersonnelTypeName = s.FirstOrDefault().af.DisplayName,
                        SexName = s.FirstOrDefault().ag.DisplayName,
                        Telephone = s.FirstOrDefault().ab.Telephone,
                        PatientRegisterId = s.FirstOrDefault().a.Id
                    });
                }

            }

            int totalCount = entlist.Count;

            entlist = entlist.Skip(input.SkipCount * input.MaxResultCount).Take(input.MaxResultCount).ToList();

            return new PagedResultDto<GetPatientRegisterReportDto>(totalCount, entlist);
        }


        /// <summary>
        /// 查询 检查项目状态  RegisterAsbitem为主表  筛选registercheck表状态
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/peisreport/getregisterasbitemregistercheckstatus")]
        public async Task<List<GetRegisterAsbitemRegisterCheckStatusDto>> GetRegisterAsbitemRegisterCheckStatusAsync(GetRegisterAsbitemRegisterCheckStatusRequestDto input)
        {
            var query = from j in await _registerAsbitemRepository.GetQueryableAsync()
                        join k in await _registerCheckRepository.GetQueryableAsync() on j.RegisterCheckId equals k.Id into kk
                        from jk in kk.DefaultIfEmpty()
                        join l in await _patientRegisterRepository.GetQueryableAsync() on j.PatientRegisterId equals l.Id into ll
                        from a in ll.DefaultIfEmpty()
                        join b in await _patientRepository.GetQueryableAsync() on a.PatientId equals b.Id into bb
                        from ab in bb.DefaultIfEmpty()
                        join c in await _customerOrgGroupRepository.GetQueryableAsync() on a.CustomerOrgGroupId equals c.Id into cc
                        from ac in cc.DefaultIfEmpty()
                        join d in await _medicalPackageRepository.GetQueryableAsync() on a.MedicalPackageId equals d.Id into dd
                        from ad in dd.DefaultIfEmpty()
                        join e in await _medicalTypeRepository.GetQueryableAsync() on a.MedicalTypeId equals e.Id into ee
                        from ae in ee.DefaultIfEmpty()
                        join f in await _personnelTypeRepository.GetQueryableAsync() on a.PersonnelTypeId equals f.Id into ff
                        from af in ff.DefaultIfEmpty()
                        join g in await _sexRepository.GetQueryableAsync() on a.SexId equals g.Id into gg
                        from ag in gg.DefaultIfEmpty()
                        join p in await _asbitemRepository.GetQueryableAsync() on j.AsbitemId equals p.Id into pp
                        from jp in pp.DefaultIfEmpty()
                        select new
                        {
                            j,
                            jk,
                            a,
                            ab,
                            ac,
                            ad,
                            ae,
                            af,
                            ag,
                            jp
                        };


            var sumquery = query;

            if (input.CustomerOrgs.Any())
            {

                var item = input.CustomerOrgs[0];

                if (item.CustomerOrgGroupId.Any())
                {
                    sumquery = sumquery.Where(m => m.a.CustomerOrgGroupId != null && item.CustomerOrgGroupId.Contains(m.a.CustomerOrgGroupId.Value));
                }
                if (item.CustomerOrgRegisterId != null && item.CustomerOrgRegisterId != Guid.Empty)
                {
                    sumquery = sumquery.Where(m => m.a.CustomerOrgRegisterId == item.CustomerOrgRegisterId);
                }
                if (item.CustomerOrgId != null)
                {
                    var CustomerOrgIds = await _customerOrgManager.GetCustomerOrgChildrenId(item.CustomerOrgId.Value);
                    sumquery = sumquery.Where(m => CustomerOrgIds.Contains(m.a.CustomerOrgId));
                }
                if (!string.IsNullOrEmpty(item.StartDate) && !string.IsNullOrEmpty(item.EndDate))
                {
                    if (item.DateType == '1')
                    {
                        sumquery = sumquery.Where(m => m.a.CreationTime >= Convert.ToDateTime(item.StartDate) &&
                     m.a.CreationTime < Convert.ToDateTime(item.EndDate).AddDays(1));
                    }
                    else if (item.DateType == '2')
                    {
                        sumquery = sumquery.Where(m => m.a.MedicalStartDate != null && m.a.MedicalStartDate.Value >= Convert.ToDateTime(item.StartDate) &&
                     m.a.MedicalStartDate.Value < Convert.ToDateTime(item.EndDate).AddDays(1));
                    }
                    else if (item.DateType == '3')
                    {
                        sumquery = sumquery.Where(m => m.a.SummaryDate != null && m.a.SummaryDate.Value >= Convert.ToDateTime(item.StartDate) &&
                  m.a.SummaryDate.Value < Convert.ToDateTime(item.EndDate).AddDays(1));
                    }
                }

                if (input.CustomerOrgs.Count > 1)
                {
                    foreach (var item2 in input.CustomerOrgs)
                    {

                        if (input.CustomerOrgs.IndexOf(item2) > 0)
                        {
                            var newquery = query;
                            if (item2.CustomerOrgGroupId.Any())
                            {
                                newquery = newquery.Where(m => m.a.CustomerOrgGroupId != null && item2.CustomerOrgGroupId.Contains(m.a.CustomerOrgGroupId.Value));
                            }
                            if (item2.CustomerOrgRegisterId != null && item2.CustomerOrgRegisterId != Guid.Empty)
                            {
                                newquery = newquery.Where(m => m.a.CustomerOrgRegisterId == item2.CustomerOrgRegisterId);
                            }
                            if (item2.CustomerOrgId != null)
                            {
                                var CustomerOrgIds = await _customerOrgManager.GetCustomerOrgChildrenId(item2.CustomerOrgId.Value);
                                newquery = newquery.Where(m => CustomerOrgIds.Contains(m.a.CustomerOrgId));
                            }
                            if (!string.IsNullOrEmpty(item2.StartDate) && !string.IsNullOrEmpty(item2.EndDate))
                            {
                                if (item2.DateType == '1')
                                {
                                    newquery = newquery.Where(m => m.a.CreationTime >= Convert.ToDateTime(item2.StartDate) &&
                                 m.a.CreationTime < Convert.ToDateTime(item2.EndDate).AddDays(1));
                                }
                                else if (item2.DateType == '2')
                                {
                                    newquery = newquery.Where(m => m.a.MedicalStartDate != null && m.a.MedicalStartDate.Value >= Convert.ToDateTime(item2.StartDate) &&
                                 m.a.MedicalStartDate.Value < Convert.ToDateTime(item2.EndDate).AddDays(1));
                                }
                                else if (item2.DateType == '3')
                                {
                                    newquery = newquery.Where(m => m.a.SummaryDate != null && m.a.SummaryDate.Value >= Convert.ToDateTime(item2.StartDate) &&
                              m.a.SummaryDate.Value < Convert.ToDateTime(item2.EndDate).AddDays(1));
                                }
                            }

                            sumquery = sumquery.Union(newquery);

                        }


                    }
                }
            }

            if (input.AsbitemIds.Any())
            {
                sumquery = sumquery.Where(m => input.AsbitemIds.Contains(m.j.AsbitemId));
            }

            if (input.CompleteFlag != null)
            {
                sumquery = sumquery.Where(m => m.jk.CompleteFlag == input.CompleteFlag);
            }

            var entlist = sumquery.Select(s => new GetRegisterAsbitemRegisterCheckStatusDto
            {

                PatientName = s.a.PatientName,
                Age = s.a.Age,
                CompleteFlag = s.jk.CompleteFlag,
                CustomerOrgGroupName = s.ac.DisplayName,
                CustomerOrgName = _cacheService.GetTopCustomerOrgAsync(s.a.CustomerOrgId).Result.DisplayName,
                DepartmentName = _cacheService.GetCustomerOrgNameAsync(s.a.CustomerOrgId).Result,
                MedicalPackageName = s.ad.DisplayName,
                MobileTelephone = s.ab.MobileTelephone,
                PatientNo = s.ab.PatientNo,
                PatientRegisterNo = s.a.PatientRegisterNo,
                SexName = s.ag.DisplayName,
                Telephone = s.ab.Telephone,
                AsbitemName = s.jp.DisplayName,
                ChargePrice = s.j.ChargePrice,
                IsCharge = s.j.IsCharge,
                MedicalTimes = s.a.MedicalTimes,
                StandardPrice = s.j.StandardPrice
            }).ToList();


            return entlist;
        }


        /// <summary>
        /// 查询 检查项目收费状态  RegisterAsbitem为主表  筛选RegisterAsbitem表收费状态
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/peisreport/getregisterasbitemchargestatus")]
        public async Task<List<GetRegisterAsbitemChargeStatusDto>> GetRegisterAsbitemChargeStatusAsync(GetRegisterAsbitemChargeStatusRequestDto input)
        {

            var query = from j in await _registerAsbitemRepository.GetQueryableAsync()
                        join k in await _registerCheckRepository.GetQueryableAsync() on j.RegisterCheckId equals k.Id into kk
                        from jk in kk.DefaultIfEmpty()
                        join l in await _patientRegisterRepository.GetQueryableAsync() on j.PatientRegisterId equals l.Id into ll
                        from a in ll.DefaultIfEmpty()
                        join b in await _patientRepository.GetQueryableAsync() on a.PatientId equals b.Id into bb
                        from ab in bb.DefaultIfEmpty()
                        join c in await _customerOrgGroupRepository.GetQueryableAsync() on a.CustomerOrgGroupId equals c.Id into cc
                        from ac in cc.DefaultIfEmpty()
                        join d in await _medicalPackageRepository.GetQueryableAsync() on a.MedicalPackageId equals d.Id into dd
                        from ad in dd.DefaultIfEmpty()
                        join e in await _medicalTypeRepository.GetQueryableAsync() on a.MedicalTypeId equals e.Id into ee
                        from ae in ee.DefaultIfEmpty()
                        join f in await _personnelTypeRepository.GetQueryableAsync() on a.PersonnelTypeId equals f.Id into ff
                        from af in ff.DefaultIfEmpty()
                        join g in await _sexRepository.GetQueryableAsync() on a.SexId equals g.Id into gg
                        from ag in gg.DefaultIfEmpty()
                        join p in await _asbitemRepository.GetQueryableAsync() on j.AsbitemId equals p.Id into pp
                        from jp in pp.DefaultIfEmpty()
                        select new
                        {
                            j,
                            jk,
                            a,
                            ab,
                            ac,
                            ad,
                            ae,
                            af,
                            ag,
                            jp
                        };


            var sumquery = query;

            if (input.CustomerOrgs.Any())
            {

                var item = input.CustomerOrgs[0];

                if (item.CustomerOrgGroupId.Any())
                {
                    sumquery = sumquery.Where(m => m.a.CustomerOrgGroupId != null && item.CustomerOrgGroupId.Contains(m.a.CustomerOrgGroupId.Value));
                }
                if (item.CustomerOrgRegisterId != null && item.CustomerOrgRegisterId != Guid.Empty)
                {
                    sumquery = sumquery.Where(m => m.a.CustomerOrgRegisterId == item.CustomerOrgRegisterId);
                }
                if (item.CustomerOrgId != null)
                {
                    var CustomerOrgIds = await _customerOrgManager.GetCustomerOrgChildrenId(item.CustomerOrgId.Value);
                    sumquery = sumquery.Where(m => CustomerOrgIds.Contains(m.a.CustomerOrgId));
                }
                if (!string.IsNullOrEmpty(item.StartDate) && !string.IsNullOrEmpty(item.EndDate))
                {
                    if (item.DateType == '1')
                    {
                        sumquery = sumquery.Where(m => m.a.CreationTime >= Convert.ToDateTime(item.StartDate) &&
                     m.a.CreationTime < Convert.ToDateTime(item.EndDate).AddDays(1));
                    }
                    else if (item.DateType == '2')
                    {
                        sumquery = sumquery.Where(m => m.a.MedicalStartDate != null && m.a.MedicalStartDate.Value >= Convert.ToDateTime(item.StartDate) &&
                     m.a.MedicalStartDate.Value < Convert.ToDateTime(item.EndDate).AddDays(1));
                    }
                    else if (item.DateType == '3')
                    {
                        sumquery = sumquery.Where(m => m.a.SummaryDate != null && m.a.SummaryDate.Value >= Convert.ToDateTime(item.StartDate) &&
                  m.a.SummaryDate.Value < Convert.ToDateTime(item.EndDate).AddDays(1));
                    }
                }

                if (input.CustomerOrgs.Count > 1)
                {
                    foreach (var item2 in input.CustomerOrgs)
                    {

                        if (input.CustomerOrgs.IndexOf(item2) > 0)
                        {
                            var newquery = query;
                            if (item2.CustomerOrgGroupId.Any())
                            {
                                newquery = newquery.Where(m => m.a.CustomerOrgGroupId != null && item2.CustomerOrgGroupId.Contains(m.a.CustomerOrgGroupId.Value));
                            }
                            if (item2.CustomerOrgRegisterId != null && item2.CustomerOrgRegisterId != Guid.Empty)
                            {
                                newquery = newquery.Where(m => m.a.CustomerOrgRegisterId == item2.CustomerOrgRegisterId);
                            }
                            if (item2.CustomerOrgId != null)
                            {
                                var CustomerOrgIds = await _customerOrgManager.GetCustomerOrgChildrenId(item2.CustomerOrgId.Value);
                                newquery = newquery.Where(m => CustomerOrgIds.Contains(m.a.CustomerOrgId));
                            }
                            if (!string.IsNullOrEmpty(item2.StartDate) && !string.IsNullOrEmpty(item2.EndDate))
                            {
                                if (item2.DateType == '1')
                                {
                                    newquery = newquery.Where(m => m.a.CreationTime >= Convert.ToDateTime(item2.StartDate) &&
                                 m.a.CreationTime < Convert.ToDateTime(item2.EndDate).AddDays(1));
                                }
                                else if (item2.DateType == '2')
                                {
                                    newquery = newquery.Where(m => m.a.MedicalStartDate != null && m.a.MedicalStartDate.Value >= Convert.ToDateTime(item2.StartDate) &&
                                 m.a.MedicalStartDate.Value < Convert.ToDateTime(item2.EndDate).AddDays(1));
                                }
                                else if (item2.DateType == '3')
                                {
                                    newquery = newquery.Where(m => m.a.SummaryDate != null && m.a.SummaryDate.Value >= Convert.ToDateTime(item2.StartDate) &&
                              m.a.SummaryDate.Value < Convert.ToDateTime(item2.EndDate).AddDays(1));
                                }
                            }
                            sumquery = sumquery.Union(newquery);
                        }


                    }
                }
            }

            if (input.AsbitemIds.Any())
            {
                sumquery = sumquery.Where(m => input.AsbitemIds.Contains(m.j.AsbitemId));
            }

            if (input.IsCharge != null)
            {
                sumquery = sumquery.Where(m => m.j.IsCharge == input.IsCharge);
            }

            var entlist = sumquery.Select(s => new GetRegisterAsbitemChargeStatusDto
            {

                PatientName = s.a.PatientName,
                Age = s.a.Age,
                CompleteFlag = s.jk.CompleteFlag,
                CustomerOrgGroupName = s.ac.DisplayName,
                CustomerOrgName = _cacheService.GetTopCustomerOrgAsync(s.a.CustomerOrgId).Result.DisplayName,
                DepartmentName = _cacheService.GetCustomerOrgNameAsync(s.a.CustomerOrgId).Result,
                MedicalPackageName = s.ad.DisplayName,
                MobileTelephone = s.ab.MobileTelephone,
                PatientNo = s.ab.PatientNo,
                PatientRegisterNo = s.a.PatientRegisterNo,
                SexName = s.ag.DisplayName,
                Telephone = s.ab.Telephone,
                AsbitemName = s.jp.DisplayName,
                ChargePrice = s.j.ChargePrice,
                IsCharge = s.j.IsCharge,
                MedicalTimes = s.a.MedicalTimes,
                StandardPrice = s.j.StandardPrice
            }).ToList();


            return entlist;
        }


        /// <summary>
        /// 查询  人员未检组合项目清单  勾选包含弃检时需要检索弃检项目
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/peisreport/getpatientregisteruncheckedreport")]
        public async Task<List<GetPatientRegisterUnCheckedReportDto>> GetPatientRegisterUnCheckedReportAsync(GetPatientRegisterUnCheckedReportRequestDto input)
        {
            var query = from a in await _patientRegisterRepository.GetQueryableAsync()
                        join b in await _patientRepository.GetQueryableAsync() on a.PatientId equals b.Id into bb
                        from ab in bb.DefaultIfEmpty()
                        join c in await _customerOrgGroupRepository.GetQueryableAsync() on a.CustomerOrgGroupId equals c.Id into cc
                        from ac in cc.DefaultIfEmpty()
                        join d in await _medicalPackageRepository.GetQueryableAsync() on a.MedicalPackageId equals d.Id into dd
                        from ad in dd.DefaultIfEmpty()
                        join e in await _medicalTypeRepository.GetQueryableAsync() on a.MedicalTypeId equals e.Id into ee
                        from ae in ee.DefaultIfEmpty()
                        join f in await _personnelTypeRepository.GetQueryableAsync() on a.PersonnelTypeId equals f.Id into ff
                        from af in ff.DefaultIfEmpty()
                        join g in await _sexRepository.GetQueryableAsync() on a.SexId equals g.Id into gg
                        from ag in gg.DefaultIfEmpty()
                        join aj in await _registerAsbitemRepository.GetQueryableAsync() on a.Id equals aj.PatientRegisterId
                        join ak in await _registerCheckRepository.GetQueryableAsync() on aj.RegisterCheckId equals ak.Id
                        join al in await _asbitemRepository.GetQueryableAsync() on aj.AsbitemId equals al.Id
                        //join j in await _registerAsbitemRepository.GetQueryableAsync() on a.Id equals j.PatientRegisterId into jj
                        //from aj in jj.DefaultIfEmpty()
                        //join k in await _registerCheckRepository.GetQueryableAsync() on aj.RegisterCheckId equals k.Id into kk
                        //from ak in kk.DefaultIfEmpty()
                        //join l in await _asbitemRepository.GetQueryableAsync() on aj.AsbitemId equals l.Id into ll
                        //from al in ll.DefaultIfEmpty()
                        select new
                        {
                            a,
                            ab,
                            ac,
                            ad,
                            ae,
                            af,
                            ag,
                            aj,
                            ak,
                            al
                        };


            var sumquery = query;

            if (input.CustomerOrgs.Any())
            {

                var item = input.CustomerOrgs[0];

                if (item.CustomerOrgGroupId.Any())
                {
                    sumquery = sumquery.Where(m => m.a.CustomerOrgGroupId != null && item.CustomerOrgGroupId.Contains(m.a.CustomerOrgGroupId.Value));
                }
                if (item.CustomerOrgRegisterId != null && item.CustomerOrgRegisterId != Guid.Empty)
                {
                    sumquery = sumquery.Where(m => m.a.CustomerOrgRegisterId == item.CustomerOrgRegisterId);
                }
                if (item.CustomerOrgId != null)
                {
                    var CustomerOrgIds = await _customerOrgManager.GetCustomerOrgChildrenId(item.CustomerOrgId.Value);
                    sumquery = sumquery.Where(m => CustomerOrgIds.Contains(m.a.CustomerOrgId));
                }
                if (!string.IsNullOrEmpty(item.StartDate) && !string.IsNullOrEmpty(item.EndDate))
                {
                    if (item.DateType == '1')
                    {
                        sumquery = sumquery.Where(m => m.a.CreationTime >= Convert.ToDateTime(item.StartDate) &&
                     m.a.CreationTime < Convert.ToDateTime(item.EndDate).AddDays(1));
                    }
                    else if (item.DateType == '2')
                    {
                        sumquery = sumquery.Where(m => m.a.MedicalStartDate != null && m.a.MedicalStartDate.Value >= Convert.ToDateTime(item.StartDate) &&
                     m.a.MedicalStartDate.Value < Convert.ToDateTime(item.EndDate).AddDays(1));
                    }
                    else if (item.DateType == '3')
                    {
                        sumquery = sumquery.Where(m => m.a.SummaryDate != null && m.a.SummaryDate.Value >= Convert.ToDateTime(item.StartDate) &&
                  m.a.SummaryDate.Value < Convert.ToDateTime(item.EndDate).AddDays(1));
                    }
                }

                if (input.CustomerOrgs.Count > 1)
                {
                    foreach (var item2 in input.CustomerOrgs)
                    {

                        if (input.CustomerOrgs.IndexOf(item2) > 0)
                        {
                            var newquery = query;
                            if (item2.CustomerOrgGroupId.Any())
                            {
                                newquery = newquery.Where(m => m.a.CustomerOrgGroupId != null && item2.CustomerOrgGroupId.Contains(m.a.CustomerOrgGroupId.Value));
                            }
                            if (item2.CustomerOrgRegisterId != null && item2.CustomerOrgRegisterId != Guid.Empty)
                            {
                                newquery = newquery.Where(m => m.a.CustomerOrgRegisterId == item2.CustomerOrgRegisterId);
                            }
                            if (item2.CustomerOrgId != null)
                            {
                                var CustomerOrgIds = await _customerOrgManager.GetCustomerOrgChildrenId(item2.CustomerOrgId.Value);
                                newquery = newquery.Where(m => CustomerOrgIds.Contains(m.a.CustomerOrgId));
                            }
                            if (!string.IsNullOrEmpty(item2.StartDate) && !string.IsNullOrEmpty(item2.EndDate))
                            {
                                if (item2.DateType == '1')
                                {
                                    newquery = newquery.Where(m => m.a.CreationTime >= Convert.ToDateTime(item2.StartDate) &&
                                 m.a.CreationTime < Convert.ToDateTime(item2.EndDate).AddDays(1));
                                }
                                else if (item2.DateType == '2')
                                {
                                    newquery = newquery.Where(m => m.a.MedicalStartDate != null && m.a.MedicalStartDate.Value >= Convert.ToDateTime(item2.StartDate) &&
                                 m.a.MedicalStartDate.Value < Convert.ToDateTime(item2.EndDate).AddDays(1));
                                }
                                else if (item2.DateType == '3')
                                {
                                    newquery = newquery.Where(m => m.a.SummaryDate != null && m.a.SummaryDate.Value >= Convert.ToDateTime(item2.StartDate) &&
                              m.a.SummaryDate.Value < Convert.ToDateTime(item2.EndDate).AddDays(1));
                                }
                            }
                            sumquery = sumquery.Union(newquery);
                        }


                    }
                }
            }

            if (input.IsGiveUpCheck != null && input.IsGiveUpCheck == 'Y')
            {
                sumquery = sumquery.Where(m => m.ak.CompleteFlag == RegisterCheckCompleteFlag.UnChecked || m.ak.CompleteFlag == RegisterCheckCompleteFlag.GiveUpChecked);
            }
            else
            {
                sumquery = sumquery.Where(m => m.ak.CompleteFlag == RegisterCheckCompleteFlag.UnChecked);
            }

            if (input.CompleteFlag != null)
            {
                sumquery = sumquery.Where(m => m.a.CompleteFlag == input.CompleteFlag);
            }


            var entlist = sumquery.GroupBy(g => g.a.Id).Select(s => new GetPatientRegisterUnCheckedReportDto
            {
                Age = s.FirstOrDefault().a.Age,
                CustomerOrgGroupName = s.FirstOrDefault().ac.DisplayName,
                CustomerOrgName = _cacheService.GetTopCustomerOrgAsync(s.FirstOrDefault().a.CustomerOrgId).Result.DisplayName,
                DepartmentName = _cacheService.GetCustomerOrgNameAsync(s.FirstOrDefault().a.CustomerOrgId).Result,
                //GiveUpAsbitems = s.Where(m => m.ak.CompleteFlag == '2').Select(gs => new GetPatientRegisterUnCheckedReport_GiveUpAsbitem
                //{
                //    AsbitemName = gs.al.DisplayName
                //}).ToList(),
                GiveUpAsbitems = s.Where(m => m.ak.CompleteFlag == RegisterCheckCompleteFlag.GiveUpChecked).Select(gs => gs.al.DisplayName).ToList(),
                MedicalPackageName = s.FirstOrDefault().ad.DisplayName,
                MedicalTimes = s.FirstOrDefault().a.MedicalTimes,
                MobileTelephone = s.FirstOrDefault().ab.MobileTelephone,
                PatientName = s.FirstOrDefault().a.PatientName,
                PatientNo = s.FirstOrDefault().ab.PatientNo,
                PatientRegisterNo = s.FirstOrDefault().a.PatientRegisterNo,
                SexName = s.FirstOrDefault().ag.DisplayName,
                Telephone = s.FirstOrDefault().ab.Telephone,
                UnCheckAsbitems = s.Where(m => m.ak.CompleteFlag == RegisterCheckCompleteFlag.UnChecked).Select(gs => gs.al.DisplayName).ToList(),
                //UnCheckAsbitems = s.Where(m => m.ak.CompleteFlag == '0').Select(gs => new GetPatientRegisterUnCheckedReport_UnCheckAsbitem
                //{
                //    AsbitemName = gs.al.DisplayName
                //}).ToList()
            }).ToList();

            return entlist;
        }

    }
}