peis/src/Shentun.Peis.Application/PatientRegisters/PatientRegisterAppService.cs

using Castle.Core.Logging;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using NPOI.POIFS.Properties;
using NPOI.SS.Formula.Functions;
using NPOI.Util;
using NUglify.Helpers;
using Org.BouncyCastle.Asn1.Ocsp;
using Shentun.Peis.AppointPatientRegisters;
using Shentun.Peis.CommonCharTypes;
using Shentun.Peis.CustomerOrgRegisters;
using Shentun.Peis.CustomerOrgs;
using Shentun.Peis.Enums;
using Shentun.Peis.LisRequests;
using Shentun.Peis.Models;
using Shentun.Peis.OcCheckTypeDetails;
using Shentun.Peis.PatientOccupationalDiseases;
using Shentun.Peis.PatientPoisons;
using Shentun.Peis.PatientRegisterExters;
using Shentun.Peis.Patients;
using Shentun.Peis.PeisReports;
using Shentun.Peis.RegisterAsbitems;
using Shentun.Peis.RegisterCheckAsbitems;
using Shentun.Peis.RegisterChecks;
using Shentun.Peis.SumSuggestionContents;
using Shentun.Peis.SumSuggestionHeaders;
using Shentun.Peis.SumSummaryContents;
using Shentun.Peis.SumSummaryHeaders;
using Shentun.Peis.SumSummaryReports;
using Shentun.Peis.SysParmValues;
using Shentun.Peis.ThirdBookingPushs;
using Shentun.Utilities;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Entities;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Guids;
using Volo.Abp.Identity;
using Volo.Abp.ObjectMapping;
using Volo.Abp.Users;

namespace Shentun.Peis.PatientRegisters
{


    /// <summary>
    /// 人员体检登记
    /// </summary>
    [ApiExplorerSettings(GroupName = "Work")]
    [Authorize]
    public class PatientRegisterAppService : CrudAppService<
            PatientRegister, //The Book entity
            PatientRegisterDto, //Used to show books
            Guid, //Primary key of the book entity
            PagedAndSortedResultRequestDto, //Used for paging/sorting
            CreatePatientRegisterDto,
            UpdatePatientRegisterDto>
    {
        private readonly IRepository<PatientRegister, Guid> _repository;
        private readonly IRepository<Patient, Guid> _patientRepository;
        private readonly IRepository<IdentityUser, Guid> _userRepository;
        private readonly IRepository<Sex> _sexRepository;
        private readonly IRepository<BirthPlace, Guid> _birthPlaceRepository;
        private readonly IRepository<MaritalStatus> _maritalStatusRepository;
        private readonly IRepository<Nation> _nationRepository;
        private readonly IRepository<CustomerOrgGroup, Guid> _customerOrgGroupRepository;
        private readonly IRepository<CustomerOrgGroupDetail> _customerOrgGroupDetailRepository;
        private readonly IRepository<CustomerOrg, Guid> _customerOrgRepository;
        private readonly IRepository<PersonnelType, Guid> _personnelTypeRepository;
        private readonly IRepository<MedicalType, Guid> _medicalTypeRepository;
        private readonly IRepository<SexHormoneTerm, Guid> _sexHormoneTermRepository;
        private readonly IRepository<PayMode> _payModeRepository;
        private readonly IRepository<RegisterCheckAsbitem, Guid> _registerCheckAsbitemRepository;
        private readonly IRepository<RegisterCheck, Guid> _registerCheckRepository;
        private readonly IRepository<RegisterCheckItem> _registerCheckItemRepository;
        private readonly IRepository<RegisterCheckPicture, Guid> _registerCheckPictureRepository;
        private readonly IRepository<Item, Guid> _itemRepository;
        private readonly IRepository<Asbitem, Guid> _asbitemRepository;
        private readonly IPatientRegisterChargeRepository _patientRegisterChargeRepository;
        private readonly IRepository<MedicalPackageDetail> _medicalPackageDetailRepository;
        private readonly IRepository<SumSummaryHeader, Guid> _sumSummaryHeaderRepository;
        private readonly IRepository<SumSummaryContent, Guid> _sumSummaryContentRepository;
        private readonly IRepository<SumSuggestionHeader, Guid> _sumSuggestionHeaderRepository;
        private readonly IRepository<SumSuggestionContent, Guid> _sumSuggestionContentRepository;
        private readonly IRepository<SumDiagnosis> _sumDiagnosisRepository;
        private readonly ILogger<PatientRegisterAppService> _logger;
        private readonly CustomerOrgManager _customerOrgManager;
        private readonly CustomerOrgRegisterManager _customerOrgRegisterManager;
        private readonly PatientManager _patientManager;
        private readonly PatientRegisterManager _patientRegisterManager;
        private readonly RegisterCheckAsbitemManager _registerAsbitemManager;
        private readonly SumSummaryHeaderManager _sumSummaryHeaderManager;
        private readonly SumSummaryContentManager _sumSummaryContentManager;
        private readonly SumSuggestionHeaderManager _sumSuggestionHeaderManager;
        private readonly SumSuggestionContentManager _sumSuggestionContentManager;
        //private readonly IRepository<CustomerOrg, Guid> _customerOrgRepository;
        //private readonly IRepository<PrimarykeyBuilder> _primarykeyBuilderRepository;
        //private readonly IRepository<SysParmValue> _sysParmValueRepository;
        private readonly PatientRegisterManager _manager;
        private readonly CacheService _cacheService;
        private readonly SysParmValueManager _sysParmValueManager;
        private readonly IRepository<PatientRegisterExter> _patientRegisterExterRepository;
        private readonly PatientRegisterExterManager _patientRegisterExterManager;
        private readonly IRepository<LisRequest, Guid> _lisRequestRepository;
        private readonly IConfiguration _configuration;
        private readonly ICurrentUser _currentUser;
        private readonly IRepository<UserItemType> _userItemTypeRepository;
        private readonly PatientOccupationalDiseaseManager _patientOccupationalDiseaseManager;
        private readonly IRepository<ThirdInterface, Guid> _thirdInterfaceRepository;
        private readonly IRepository<CustomerOrgRegister, Guid> _customerOrgRegisterRepository;
        private readonly IRepository<OcCheckType, Guid> _ocCheckTypeRepository;
        private readonly IRepository<Poison, Guid> _poisonRepository;
        private readonly IRepository<OcCheckTypeDetail> _ocCheckTypeDetailRepository;
        private readonly IRepository<PatientOccupationalDisease, Guid> _patientOccupationalDiseaseRepository;
        private readonly IRepository<PatientPoison> _patientPoisonRepository;
        private readonly PatientPoisonManager _patientPoisonManager;
        private readonly IRepository<Diagnosis> _diagnosisRepository;
        private readonly ThirdBookingPushAppService _thirdBookingPushAppService;
        private readonly IRepository<ThirdBooking, Guid> _thirdBookingRepository;
        public PatientRegisterAppService(
            IRepository<PatientRegister, Guid> repository,
            IRepository<Patient, Guid> patientRepository,
            IRepository<IdentityUser, Guid> userRepository,
            IRepository<Sex> sexRepository,
            IRepository<BirthPlace, Guid> birthPlaceRepository,
            IRepository<MaritalStatus> maritalStatusRepository,
            IRepository<Nation> nationRepository,
            IRepository<CustomerOrgGroup, Guid> customerOrgGroupRepository,
            IRepository<CustomerOrgGroupDetail> customerOrgGroupDetailRepository,
            IRepository<CustomerOrg, Guid> customerOrgRepository,
            IRepository<PersonnelType, Guid> personnelTypeRepository,
            IRepository<MedicalType, Guid> medicalTypeRepository,
            IRepository<SexHormoneTerm, Guid> sexHormoneTermRepository,
            IRepository<PayMode> payModeRepository,
            IRepository<RegisterCheckAsbitem, Guid> registerAsbitemRepository,
            IRepository<RegisterCheck, Guid> registerCheckRepository,
            IRepository<RegisterCheckItem> registerCheckItemRepository,
            IRepository<RegisterCheckPicture, Guid> registerCheckPictureRepository,
            IRepository<Item, Guid> itemRepository,
            IRepository<Asbitem, Guid> asbitemRepository,
            IRepository<SumSummaryHeader, Guid> sumSummaryHeaderRepository,
            IRepository<SumSummaryContent, Guid> sumSummaryContentRepository,
            IRepository<SumSuggestionHeader, Guid> sumSuggestionHeaderRepository,
            IRepository<SumSuggestionContent, Guid> sumSuggestionContentRepository,
            IRepository<SumDiagnosis> sumDiagnosisRepository,
        //IRepository<SysParmValue> sysParmValueRepository,
        //IRepository<CustomerOrg, Guid> customerOrgRepository,
        //IRepository<PrimarykeyBuilder> primarykeyBuilderRepository,
        IPatientRegisterChargeRepository patientRegisterChargeRepository,
            IRepository<MedicalPackageDetail> medicalPackageDetailRepository,
            ILogger<PatientRegisterAppService> logger,
            CustomerOrgManager customerOrgManager,
            CustomerOrgRegisterManager customerOrgRegisterManager,
            PatientManager patientManager,
            PatientRegisterManager patientRegisterManager,
            RegisterCheckAsbitemManager registerAsbitemManager,
            PatientRegisterManager manager,
            CacheService cacheService,
            SumSummaryHeaderManager sumSummaryHeaderManager,
            SumSummaryContentManager sumSummaryContentManager,
            SumSuggestionHeaderManager sumSuggestionHeaderManager,
            SumSuggestionContentManager sumSuggestionContentManager,
            SysParmValueManager sysParmValueManager,
            IRepository<PatientRegisterExter> patientRegisterExterRepository,
            PatientRegisterExterManager patientRegisterExterManager,
            IRepository<LisRequest, Guid> lisRequestRepository,
            IConfiguration configuration,
            ICurrentUser currentUser,
            IRepository<UserItemType> userItemTypeRepository,
            PatientOccupationalDiseaseManager patientOccupationalDiseaseManager,
            IRepository<ThirdInterface, Guid> thirdInterfaceRepository,
            IRepository<CustomerOrgRegister, Guid> customerOrgRegisterRepository,
            IRepository<OcCheckType, Guid> ocCheckTypeRepository,
            IRepository<Poison, Guid> poisonRepository,
            IRepository<OcCheckTypeDetail> ocCheckTypeDetailRepository,
            IRepository<PatientOccupationalDisease, Guid> patientOccupationalDiseaseRepository,
            IRepository<PatientPoison> patientPoisonRepository,
            PatientPoisonManager patientPoisonManager,
            IRepository<Diagnosis> diagnosisRepository,
            ThirdBookingPushAppService thirdBookingPushAppService,
            IRepository<ThirdBooking, Guid> thirdBookingRepository)
            : base(repository)
        {
            this._repository = repository;
            this._patientRepository = patientRepository;
            this._userRepository = userRepository;
            this._sexRepository = sexRepository;
            this._birthPlaceRepository = birthPlaceRepository;
            this._maritalStatusRepository = maritalStatusRepository;
            this._nationRepository = nationRepository;
            this._customerOrgGroupRepository = customerOrgGroupRepository;
            this._customerOrgGroupDetailRepository = customerOrgGroupDetailRepository;
            this._customerOrgRepository = customerOrgRepository;
            this._personnelTypeRepository = personnelTypeRepository;
            this._medicalTypeRepository = medicalTypeRepository;
            this._sexHormoneTermRepository = sexHormoneTermRepository;
            this._payModeRepository = payModeRepository;
            this._registerCheckAsbitemRepository = registerAsbitemRepository;
            this._registerCheckRepository = registerCheckRepository;
            this._registerCheckItemRepository = registerCheckItemRepository;
            this._registerCheckPictureRepository = registerCheckPictureRepository;
            this._itemRepository = itemRepository;
            this._patientRegisterChargeRepository = patientRegisterChargeRepository;
            this._logger = logger;
            this._customerOrgManager = customerOrgManager;
            this._customerOrgRegisterManager = customerOrgRegisterManager;
            this._patientManager = patientManager;
            this._patientRegisterManager = patientRegisterManager;
            this._registerAsbitemManager = registerAsbitemManager;
            //this._customerOrgRepository = customerOrgRepository;
            //this._primarykeyBuilderRepository = primarykeyBuilderRepository;
            //this._sysParmValueRepository = sysParmValueRepository;
            _sumSummaryHeaderRepository = sumSummaryHeaderRepository;
            _sumSummaryContentRepository = sumSummaryContentRepository;
            _sumSuggestionHeaderRepository = sumSuggestionHeaderRepository;
            _sumSuggestionContentRepository = sumSuggestionContentRepository;
            _sumDiagnosisRepository = sumDiagnosisRepository;
            _manager = manager;
            _cacheService = cacheService;
            _medicalPackageDetailRepository = medicalPackageDetailRepository;
            _asbitemRepository = asbitemRepository;
            _sumSummaryHeaderManager = sumSummaryHeaderManager;
            _sumSummaryContentManager = sumSummaryContentManager;
            _sumSuggestionHeaderManager = sumSuggestionHeaderManager;
            _sumSuggestionContentManager = sumSuggestionContentManager;
            _sysParmValueManager = sysParmValueManager;
            _patientRegisterExterRepository = patientRegisterExterRepository;
            _patientRegisterExterManager = patientRegisterExterManager;
            _lisRequestRepository = lisRequestRepository;
            _configuration = configuration;
            _currentUser = currentUser;
            _userItemTypeRepository = userItemTypeRepository;
            _patientOccupationalDiseaseManager = patientOccupationalDiseaseManager;
            _thirdInterfaceRepository = thirdInterfaceRepository;
            _customerOrgRegisterRepository = customerOrgRegisterRepository;
            _ocCheckTypeRepository = ocCheckTypeRepository;
            _poisonRepository = poisonRepository;
            _ocCheckTypeDetailRepository = ocCheckTypeDetailRepository;
            _patientOccupationalDiseaseRepository = patientOccupationalDiseaseRepository;
            _patientPoisonRepository = patientPoisonRepository;
            _patientPoisonManager = patientPoisonManager;
            _diagnosisRepository = diagnosisRepository;
            _thirdBookingPushAppService = thirdBookingPushAppService;
            _thirdBookingRepository = thirdBookingRepository;
        }
        /// <summary>
        /// 获取通过主键
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public override async Task<PatientRegisterDto> GetAsync(Guid id)
        {
            return await base.GetAsync(id);
        }


        /// <summary>
        /// 根据lis申请单号 获取人员条码号
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        [HttpPost("api/app/PatientRegister/GetPatientRegisterNoByLisRequestNo")]
        public async Task<PatientRegisterSimpleDto> GetPatientRegisterNoByLisRequestNoAsync(LisRequestNoInputDto input)
        {
            if (input == null)
            {
                throw new UserFriendlyException("请求参数有误");
            }

            var patientRegisterNo = (from lisRequest in await _lisRequestRepository.GetQueryableAsync()
                                     join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync() on lisRequest.Id equals registerCheckAsbitem.LisRequestId
                                     join registerCheck in await _registerCheckRepository.GetQueryableAsync() on registerCheckAsbitem.RegisterCheckId equals registerCheck.Id
                                     join patientRegister in await Repository.GetQueryableAsync() on registerCheck.PatientRegisterId equals patientRegister.Id
                                     where lisRequest.LisRequestNo == input.LisRequestNo
                                     select patientRegister.PatientRegisterNo).FirstOrDefault();

            if (!string.IsNullOrEmpty(patientRegisterNo))
            {
                return new PatientRegisterSimpleDto
                {
                    PatientRegisterNo = patientRegisterNo
                };
            }
            else
            {
                throw new UserFriendlyException("Lis申请单有误");
            }
        }

        /// <summary>
        /// 根据检查单号 获取人员条码号
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        [HttpPost("api/app/PatientRegister/GetPatientRegisterNoByCheckRequestNo")]
        public async Task<PatientRegisterSimpleDto> GetPatientRegisterNoByCheckRequestNoAsync(CheckRequestNoInputDto input)
        {
            if (input == null)
            {
                throw new UserFriendlyException("请求参数有误");
            }

            var patientRegisterNo = (from registerCheck in await _registerCheckRepository.GetQueryableAsync()
                                     join patientRegister in await Repository.GetQueryableAsync() on registerCheck.PatientRegisterId equals patientRegister.Id
                                     where registerCheck.CheckRequestNo == input.CheckRequestNo
                                     select patientRegister.PatientRegisterNo).FirstOrDefault();

            if (!string.IsNullOrEmpty(patientRegisterNo))
            {
                return new PatientRegisterSimpleDto
                {
                    PatientRegisterNo = patientRegisterNo
                };
            }
            else
            {
                throw new UserFriendlyException("检查单有误");
            }
        }


        /// <summary>
        /// 编辑反写接口，包含档案表跟登记表的信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/patientregister/getinfoorpatient")]
        public async Task<PatientRegisterOrNoDto> GetInfoOrPatientAsync(PatientRegisterIdInputDto input)
        {
            return await GetPatientRegisterOrNo(input.PatientRegisterId);
            //var ent = (await _repository.GetQueryableAsync()).Include(x => x.Patient).Where(m => m.Id == input.PatientRegisterId).FirstOrDefault();

            //var entdto = new PatientRegisterOrNoDto();
            //if (ent != null)
            //{
            //    //var userList = await _userRepository.GetListAsync();
            //    //var customerOrgList = await _customerOrgRepository.GetListAsync();

            //    entdto = new PatientRegisterOrNoDto
            //    {
            //        HisPatientId = ent.HisPatientId,
            //        Age = ent.Age,
            //        AuditDate = DataHelper.ConversionDateToString(ent.AuditDate),
            //        Id = ent.Id,
            //        AuditDoctorId = ent.AuditDoctorId,
            //        BirthDate = DataHelper.ConversionDateToString(ent.BirthDate),
            //        CompleteFlag = ent.CompleteFlag,
            //        CreationTime = ent.CreationTime,
            //        CreatorId = ent.CreatorId,
            //        CustomerOrgGroupId = ent.CustomerOrgGroupId,
            //        CustomerOrgId = ent.CustomerOrgId,
            //        CustomerOrgRegisterId = ent.CustomerOrgRegisterId,
            //        GuidePrintTimes = ent.GuidePrintTimes,
            //        InterposeMeasure = ent.InterposeMeasure,
            //        IsAudit = ent.IsAudit,
            //        IsLock = ent.IsLock,
            //        IsMedicalStart = ent.IsMedicalStart,
            //        IsNameHide = ent.IsNameHide,
            //        IsPhoneFollow = ent.IsPhoneFollow,
            //        IsRecoverGuide = ent.IsRecoverGuide,
            //        IsUpload = ent.IsUpload,
            //        IsVip = ent.IsVip,
            //        JobCardNo = ent.JobCardNo,
            //        JobPost = ent.JobPost,
            //        JobTitle = ent.JobTitle,
            //        LastModificationTime = ent.LastModificationTime,
            //        LastModifierId = ent.LastModifierId,
            //        MaritalStatusId = ent.MaritalStatusId,
            //        MedicalCardNo = ent.MedicalCardNo,
            //        MedicalConclusionId = ent.MedicalConclusionId,
            //        MedicalPackageId = ent.MedicalPackageId,
            //        MedicalStartDate = DataHelper.ConversionDateToString(ent.MedicalStartDate),
            //        MedicalTimes = ent.MedicalTimes,
            //        MedicalTypeId = ent.MedicalTypeId,
            //        MedicalCenterId = ent.MedicalCenterId,
            //        PatientId = ent.PatientId,
            //        PatientName = ent.PatientName,
            //        PatientRegisterNo = ent.PatientRegisterNo,
            //        PersonnelTypeId = ent.PersonnelTypeId,
            //        Photo = ent.Photo,
            //        Remark = ent.Remark,
            //        ReportPrintTimes = ent.ReportPrintTimes,
            //        Salesman = ent.Salesman,
            //        SexHormoneTermId = ent.SexHormoneTermId,
            //        SexId = ent.SexId,
            //        SummaryDate = DataHelper.ConversionDateToString(ent.SummaryDate),
            //        SummaryDoctorId = ent.SummaryDoctorId,
            //        ThirdInfo = ent.ThirdInfo,
            //        CreatorName = _cacheService.GetSurnameAsync(ent.CreatorId).Result,
            //        LastModifierName = _cacheService.GetSurnameAsync(ent.LastModifierId).Result,
            //        Address = ent.Patient.Address,  //档案表信息
            //        BirthPlaceId = ent.Patient.BirthPlaceId,
            //        DisplayName = ent.Patient.DisplayName,
            //        Email = ent.Patient.Email,
            //        IdNo = ent.Patient.IdNo,
            //        MobileTelephone = ent.Patient.MobileTelephone,
            //        NationId = ent.Patient.NationId,
            //        PatientNo = ent.Patient.PatientNo,
            //        PatientPassword = ent.Patient.PatientPassword,
            //        PostalCode = ent.Patient.PostalCode,
            //        Telephone = ent.Patient.Telephone,
            //        CustomerOrgName = _cacheService.GetCustomerOrgNameAsync(ent.CustomerOrgId).Result,
            //        CustomerOrgParentId = _cacheService.GetTopCustomerOrgAsync(ent.CustomerOrgId).Result.Id
            //        //CustomerOrgParentName = EntityHelper.GetCustomerOrgParentNameNoSql(customerOrgList, ent.CustomerOrgId)
            //    };
            //}
            //return entdto;
        }

        /// <summary>
        /// 获取是否总检过
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/patientregister/GetHaveSumData")]
        public async Task<string> GetHaveSumData(PatientRegisterIdInputDto input)
        {
            var sumSummaryHeader = await _sumSummaryHeaderRepository.GetListAsync(o => o.PatientRegisterId == input.PatientRegisterId);
            if (sumSummaryHeader.Any())
            {
                return "Y";
            }
            var sumSuggestionHeader = await _sumSuggestionHeaderRepository.GetListAsync(o => o.PatientRegisterId == input.PatientRegisterId);
            if (sumSuggestionHeader.Any())
            {
                return "Y";
            }
            return "N";
        }
        /// <summary>
        /// 获取列表  人员体检
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [RemoteService(false)]
        public override async Task<PagedResultDto<PatientRegisterDto>> GetListAsync(PagedAndSortedResultRequestDto input)
        {
            return await base.GetListAsync(input);
        }


        /// <summary>
        /// 获取档案登记列表   带联合搜索条件
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/patientregister/getlistinfilter")]
        public async Task<PagedResultDto<PatientRegisterOrNoDto>> GetListInFilterAsync(GetListInSearchDto input)
        {
            //var customerOrgList = await _customerOrgRepository.GetListAsync();



            #region MyRegion
            var entlist = from patientRegister in (await _repository.GetQueryableAsync()).Include(x => x.Patient).AsQueryable()
                          join patientRegisterExter in await _patientRegisterExterRepository.GetQueryableAsync()
                          on patientRegister.Id equals patientRegisterExter.PatientRegisterId into patientRegisterExterTemp
                          from patientRegisterExterHaveEmpty in patientRegisterExterTemp.DefaultIfEmpty()
                          select new
                          {
                              patientRegister,
                              patientRegisterExterHaveEmpty
                          };


            if (!string.IsNullOrEmpty(input.PatientNo))
                entlist = entlist.Where(m => m.patientRegister.Patient.PatientNo == input.PatientNo);

            if (!string.IsNullOrEmpty(input.IdNo))
                entlist = entlist.Where(m => m.patientRegister.Patient.IdNo == input.IdNo);

            if (!string.IsNullOrEmpty(input.PatientName))
                entlist = entlist.Where(m => !string.IsNullOrEmpty(m.patientRegister.PatientName) && m.patientRegister.PatientName.Contains(input.PatientName));

            if (!string.IsNullOrEmpty(input.PatientRegisterNo))
                entlist = entlist.Where(m => m.patientRegister.PatientRegisterNo == input.PatientRegisterNo);

            if (!string.IsNullOrEmpty(input.Phone))
                entlist = entlist.Where(m => m.patientRegister.Patient.MobileTelephone == input.Phone || m.patientRegister.Patient.Telephone == input.Phone);

            if (input.SexId != null && input.SexId != ForSexFlag.All)
                entlist = entlist.Where(m => m.patientRegister.SexId == input.SexId);

            if (!string.IsNullOrEmpty(input.StartDate) && !string.IsNullOrEmpty(input.EndDate))
            {
                if (input.DateType == '1')
                {
                    entlist = entlist.Where(m => m.patientRegister.CreationTime >= Convert.ToDateTime(input.StartDate) &&
                    m.patientRegister.CreationTime < Convert.ToDateTime(input.EndDate).AddDays(1));
                }
                else if (input.DateType == '2')
                {
                    entlist = entlist.Where(m => m.patientRegister.MedicalStartDate >= Convert.ToDateTime(input.StartDate) &&
                      m.patientRegister.MedicalStartDate < Convert.ToDateTime(input.EndDate).AddDays(1));
                }
                else
                {
                    entlist = entlist.Where(m => (m.patientRegister.CreationTime >= Convert.ToDateTime(input.StartDate) &&
                       m.patientRegister.CreationTime < Convert.ToDateTime(input.EndDate).AddDays(1))
                       || (m.patientRegister.MedicalStartDate >= Convert.ToDateTime(input.StartDate) &&
                      m.patientRegister.MedicalStartDate < Convert.ToDateTime(input.EndDate).AddDays(1))
                       );
                }
            }
            if (input.CompleteFlags.Any())
            {
                entlist = entlist.Where(m => input.CompleteFlags.Contains(m.patientRegister.CompleteFlag));
            }

            if (input.MedicalTypeIds.Any())
            {
                entlist = entlist.Where(m => input.MedicalTypeIds.Contains(m.patientRegister.MedicalTypeId));
            }


            if (input.CustomerOrgId != null)
            {
                var CustomerOrgIds = await _customerOrgManager.GetCustomerOrgChildrenId(input.CustomerOrgId.Value);
                entlist = entlist.Where(m => CustomerOrgIds.Contains(m.patientRegister.CustomerOrgId));
            }

            if (input.CustomerOrgRegisterId != null && input.CustomerOrgRegisterId != Guid.Empty)
            {
                entlist = entlist.Where(m => m.patientRegister.CustomerOrgRegisterId == input.CustomerOrgRegisterId);
            }

            if (input.CustomerOrgGroupIds.Any())
            {
                entlist = entlist.Where(m => m.patientRegister.CustomerOrgGroupId != null && input.CustomerOrgGroupIds.Contains(m.patientRegister.CustomerOrgGroupId.Value));
            }

            #endregion



            int totalCount = entlist.Count();

            entlist = entlist.OrderByDescending(o => o.patientRegister.CompleteFlag).ThenBy(o => o.patientRegister.Id).Skip(input.SkipCount * input.MaxResultCount).Take(input.MaxResultCount);

            var ggg = entlist.Select(s => s.patientRegister.CustomerOrgId).ToList();

            var entdto = entlist.Select(s => new PatientRegisterOrNoDto
            {
                CreationTime = s.patientRegister.CreationTime,
                CreatorId = s.patientRegister.CreatorId,
                Id = s.patientRegister.Id,
                LastModificationTime = s.patientRegister.LastModificationTime,
                LastModifierId = s.patientRegister.LastModifierId,
                ThirdInfo = s.patientRegister.ThirdInfo,
                SummaryDoctorId = s.patientRegister.SummaryDoctorId,
                SummaryDate = DataHelper.ConversionDateToString(s.patientRegister.SummaryDate),
                SexId = s.patientRegister.SexId,
                Age = s.patientRegister.Age,
                AuditDate = DataHelper.ConversionDateToString(s.patientRegister.AuditDate),
                AuditDoctorId = s.patientRegister.AuditDoctorId,
                BirthDate = DataHelper.ConversionDateToString(s.patientRegister.BirthDate),
                CompleteFlag = s.patientRegister.CompleteFlag,
                CustomerOrgGroupId = s.patientRegister.CustomerOrgGroupId,
                CustomerOrgId = s.patientRegister.CustomerOrgId,
                CustomerOrgRegisterId = s.patientRegister.CustomerOrgRegisterId,
                GuidePrintTimes = s.patientRegister.GuidePrintTimes,
                InterposeMeasure = s.patientRegister.InterposeMeasure,
                IsAudit = s.patientRegister.IsAudit,
                IsLock = s.patientRegister.IsLock,
                IsMedicalStart = s.patientRegister.IsMedicalStart,
                IsNameHide = s.patientRegister.IsNameHide,
                IsPhoneFollow = s.patientRegister.IsPhoneFollow,
                IsRecoverGuide = s.patientRegister.IsRecoverGuide,
                IsUpload = s.patientRegister.IsUpload,
                IsVip = s.patientRegister.IsVip,
                JobCardNo = s.patientRegister.JobCardNo,
                JobPost = s.patientRegister.JobPost,
                JobTitle = s.patientRegister.JobTitle,
                MaritalStatusId = s.patientRegister.MaritalStatusId,
                MedicalCardNo = s.patientRegister.MedicalCardNo,
                MedicalConclusionId = s.patientRegister.MedicalConclusionId,
                MedicalPackageId = s.patientRegister.MedicalPackageId,
                MedicalStartDate = DataHelper.ConversionDateToString(s.patientRegister.MedicalStartDate),
                MedicalTimes = s.patientRegister.MedicalTimes,
                MedicalTypeId = s.patientRegister.MedicalTypeId,
                MedicalCenterId = s.patientRegister.MedicalCenterId,
                PatientId = s.patientRegister.PatientId,
                PatientName = s.patientRegister.PatientName,
                PatientRegisterNo = s.patientRegister.PatientRegisterNo,
                PersonnelTypeId = s.patientRegister.PersonnelTypeId,
                Photo = s.patientRegister.Photo,
                Remark = s.patientRegister.Remark,
                ReportPrintTimes = s.patientRegister.ReportPrintTimes,
                Salesman = s.patientRegister.Salesman,
                SexHormoneTermId = s.patientRegister.SexHormoneTermId,
                CreatorName = _cacheService.GetSurnameAsync(s.patientRegister.CreatorId).Result,
                LastModifierName = _cacheService.GetSurnameAsync(s.patientRegister.LastModifierId).Result,
                Address = s.patientRegister.Patient.Address,  //档案表信息
                BirthPlaceId = s.patientRegister.Patient.BirthPlaceId,
                DisplayName = s.patientRegister.Patient.DisplayName,
                Email = s.patientRegister.Patient.Email,
                IdNo = s.patientRegister.Patient.IdNo,
                MobileTelephone = s.patientRegister.Patient.MobileTelephone,
                NationId = s.patientRegister.Patient.NationId,
                PatientNo = s.patientRegister.Patient.PatientNo,
                PatientPassword = s.patientRegister.Patient.PatientPassword,
                PostalCode = s.patientRegister.Patient.PostalCode,
                Telephone = s.patientRegister.Patient.Telephone,
                Planuserid = s.patientRegisterExterHaveEmpty != null ? s.patientRegisterExterHaveEmpty.Planuserid : "",
                QztlIsCw = s.patientRegisterExterHaveEmpty != null ? s.patientRegisterExterHaveEmpty.QztlIsCw : null,
                QztlIsCy = s.patientRegisterExterHaveEmpty != null ? s.patientRegisterExterHaveEmpty.QztlIsCy : null,
                QztlIsFj = s.patientRegisterExterHaveEmpty != null ? s.patientRegisterExterHaveEmpty.QztlIsFj : null,
                QztlIsGt = s.patientRegisterExterHaveEmpty != null ? s.patientRegisterExterHaveEmpty.QztlIsGt : null,
                QztlIsMain = s.patientRegisterExterHaveEmpty != null ? s.patientRegisterExterHaveEmpty.QztlIsMain : null,
                QztlIsWh = s.patientRegisterExterHaveEmpty != null ? s.patientRegisterExterHaveEmpty.QztlIsWh : null,
                QztlType = s.patientRegisterExterHaveEmpty != null ? s.patientRegisterExterHaveEmpty.QztlType : null,
                IsQztlImport = s.patientRegisterExterHaveEmpty != null ? s.patientRegisterExterHaveEmpty.IsQztlImport : null,
                Remark2 = s.patientRegisterExterHaveEmpty != null ? s.patientRegisterExterHaveEmpty.Remark2 : null,
                Remark3 = s.patientRegisterExterHaveEmpty != null ? s.patientRegisterExterHaveEmpty.Remark3 : null,
                Remark4 = s.patientRegisterExterHaveEmpty != null ? s.patientRegisterExterHaveEmpty.Remark4 : null,
                UploadQztlFlag = s.patientRegisterExterHaveEmpty != null ? s.patientRegisterExterHaveEmpty.UploadQztlFlag : null,
                //CustomerOrgName = EntityHelper.GetCustomerOrgNameNoSql(customerOrgList, s.patientRegister.CustomerOrgId),
                //CustomerOrgParentId = EntityHelper.GetParentNoSql(customerOrgList, s.patientRegister.CustomerOrgId),
                //CustomerOrgParentName = EntityHelper.GetCustomerOrgParentNameNoSql(customerOrgList, s.patientRegister.CustomerOrgId)
                CustomerOrgName = _cacheService.GetCustomerOrgNameAsync(s.patientRegister.CustomerOrgId).GetAwaiter().GetResult(),
                CustomerOrgParentId = _cacheService.GetTopCustomerOrgAsync(s.patientRegister.CustomerOrgId).GetAwaiter().GetResult().Id,
                CustomerOrgParentName = _cacheService.GetTopCustomerOrgNameAsync(s.patientRegister.CustomerOrgId).GetAwaiter().GetResult()
            }).ToList();


            return new PagedResultDto<PatientRegisterOrNoDto>(totalCount, entdto);

        }


        /// <summary>
        /// 获取档案登记信息   根据档案号或者条码号（档案号条件返回最新的一条）
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/patientregister/getpatientregisterorpatient")]
        public async Task<PatientRegisterOrNoDto> GetPatientRegisterOrPatientAsync(GetPatientRegisterOrPatientDto input)
        {
            var entdto = new PatientRegisterOrNoDto();

            #region MyRegion
            var entlist = (await _repository.GetDbSetAsync()).Include(x => x.Patient).AsQueryable();

            if (input.SType == 1)
                entlist = entlist.Where(m => m.PatientRegisterNo == input.PatientRegisterNo);
            else
                entlist = entlist.Where(m => m.Patient.PatientNo == input.PatientNo).OrderByDescending(o => o.MedicalTimes);

            if (input.IsFilterPreRegistration != null && input.IsFilterPreRegistration == 'Y')
            {
                //直接过滤
                entlist = entlist.Where(m => m.CompleteFlag != PatientRegisterCompleteFlag.PreRegistration);
            }


            var ent = entlist.FirstOrDefault();

            #endregion

            if (ent != null)
            {
                var userList = await _userRepository.GetListAsync();

                var customerOrgList = await _customerOrgRepository.GetListAsync();

                entdto = new PatientRegisterOrNoDto
                {
                    CreationTime = ent.CreationTime,
                    CreatorId = ent.CreatorId,
                    Id = ent.Id,
                    LastModificationTime = ent.LastModificationTime,
                    LastModifierId = ent.LastModifierId,
                    ThirdInfo = ent.ThirdInfo,
                    SummaryDoctorId = ent.SummaryDoctorId,
                    SummaryDate = DataHelper.ConversionDateToString(ent.SummaryDate),
                    SexId = ent.SexId,
                    Age = ent.Age,
                    AuditDate = DataHelper.ConversionDateToString(ent.AuditDate),
                    AuditDoctorId = ent.AuditDoctorId,
                    BirthDate = DataHelper.ConversionDateToString(ent.BirthDate),
                    CompleteFlag = ent.CompleteFlag,
                    CustomerOrgGroupId = ent.CustomerOrgGroupId,
                    CustomerOrgId = ent.CustomerOrgId,
                    CustomerOrgRegisterId = ent.CustomerOrgRegisterId,
                    GuidePrintTimes = ent.GuidePrintTimes,
                    InterposeMeasure = ent.InterposeMeasure,
                    IsAudit = ent.IsAudit,
                    IsLock = ent.IsLock,
                    IsMedicalStart = ent.IsMedicalStart,
                    IsNameHide = ent.IsNameHide,
                    IsPhoneFollow = ent.IsPhoneFollow,
                    IsRecoverGuide = ent.IsRecoverGuide,
                    IsUpload = ent.IsUpload,
                    IsVip = ent.IsVip,
                    JobCardNo = ent.JobCardNo,
                    JobPost = ent.JobPost,
                    JobTitle = ent.JobTitle,
                    MaritalStatusId = ent.MaritalStatusId,
                    MedicalCardNo = ent.MedicalCardNo,
                    MedicalConclusionId = ent.MedicalConclusionId,
                    MedicalPackageId = ent.MedicalPackageId,
                    MedicalStartDate = DataHelper.ConversionDateToString(ent.MedicalStartDate),
                    MedicalTimes = ent.MedicalTimes,
                    MedicalTypeId = ent.MedicalTypeId,
                    MedicalCenterId = ent.MedicalCenterId,
                    PatientId = ent.PatientId,
                    PatientName = ent.PatientName,
                    PatientRegisterNo = ent.PatientRegisterNo,
                    PersonnelTypeId = ent.PersonnelTypeId,
                    Photo = ent.Photo,
                    Remark = ent.Remark,
                    ReportPrintTimes = ent.ReportPrintTimes,
                    Salesman = ent.Salesman,
                    SexHormoneTermId = ent.SexHormoneTermId,
                    CreatorName = EntityHelper.GetSurnameNoSql(userList, ent.CreatorId),
                    LastModifierName = EntityHelper.GetSurnameNoSql(userList, ent.LastModifierId),
                    Address = ent.Patient.Address,  //档案表信息
                    BirthPlaceId = ent.Patient.BirthPlaceId,
                    DisplayName = ent.Patient.DisplayName,
                    Email = ent.Patient.Email,
                    IdNo = ent.Patient.IdNo,
                    MobileTelephone = ent.Patient.MobileTelephone,
                    NationId = ent.Patient.NationId,
                    PatientNo = ent.Patient.PatientNo,
                    PatientPassword = ent.Patient.PatientPassword,
                    PostalCode = ent.Patient.PostalCode,
                    Telephone = ent.Patient.Telephone,
                    CustomerOrgName = EntityHelper.GetCustomerOrgNameNoSql(customerOrgList, ent.CustomerOrgId),
                    CustomerOrgParentId = EntityHelper.GetParentNoSql(customerOrgList, ent.CustomerOrgId),
                    CustomerOrgParentName = EntityHelper.GetCustomerOrgParentNameNoSql(customerOrgList, ent.CustomerOrgId)
                };
            }
            else
            {
                entdto = null;
            }


            return entdto;
        }
        /// <summary>
        /// 获取档案登记信息   根据档案号或者条码号（档案号条件返回最新的一条）
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        [HttpPost("api/app/patientregister/GetAlreadyRegisterPatientRegisterByNo")]
        public async Task<PatientRegisterOrNoDto> GetAlreadyRegisterPatientRegisterByNoAsync(PatientRegisterNoInputDto input)
        {
            var query = (await _repository.GetQueryableAsync()).Include(x => x.Patient).AsQueryable();
            var patientRegisterList = new List<PatientRegister>();
            PatientRegister ent = null;
            if (!string.IsNullOrWhiteSpace(input.PatientRegisterNo))
            {
                ent = query.Where(m => m.PatientRegisterNo == input.PatientRegisterNo).FirstOrDefault();
                if (ent == null)
                {
                    throw new UserFriendlyException("未找到人员信息");
                }
            }

            else if (!string.IsNullOrWhiteSpace(input.PatientNo))
            {
                patientRegisterList = query.Where(m => m.Patient.PatientNo == input.PatientNo).OrderByDescending(o => o.MedicalTimes).ToList();
                if (patientRegisterList.Count == 0)
                {
                    throw new UserFriendlyException("未找到人员信息");
                }

                patientRegisterList = patientRegisterList.Where(m => m.CompleteFlag != PatientRegisterCompleteFlag.PreRegistration).ToList();
                if (patientRegisterList.Count == 0)
                {
                    throw new UserFriendlyException("该人未正式登记");
                }
                ent = patientRegisterList.First();
            }

            else
            {
                throw new UserFriendlyException("人员登记号和档案号至少有一个");
            }
            if (ent.CompleteFlag == PatientRegisterCompleteFlag.PreRegistration)
            {
                throw new UserFriendlyException("该人未正式登记");
            }

            var entdto = new PatientRegisterOrNoDto
            {
                CreationTime = ent.CreationTime,
                CreatorId = ent.CreatorId,
                Id = ent.Id,
                LastModificationTime = ent.LastModificationTime,
                LastModifierId = ent.LastModifierId,
                ThirdInfo = ent.ThirdInfo,
                SummaryDoctorId = ent.SummaryDoctorId,
                SummaryDate = DataHelper.ConversionDateToString(ent.SummaryDate),
                SexId = ent.SexId,
                SexName = _cacheService.GetSexNameAsync(ent.SexId).Result,
                Age = ent.Age,
                AuditDate = DataHelper.ConversionDateToString(ent.AuditDate),
                AuditDoctorId = ent.AuditDoctorId,
                BirthDate = DataHelper.ConversionDateToString(ent.BirthDate),
                CompleteFlag = ent.CompleteFlag,
                CustomerOrgGroupId = ent.CustomerOrgGroupId,
                CustomerOrgId = ent.CustomerOrgId,
                CustomerOrgRegisterId = ent.CustomerOrgRegisterId,
                GuidePrintTimes = ent.GuidePrintTimes,
                InterposeMeasure = ent.InterposeMeasure,
                IsAudit = ent.IsAudit,
                IsLock = ent.IsLock,
                IsMedicalStart = ent.IsMedicalStart,
                IsNameHide = ent.IsNameHide,
                IsPhoneFollow = ent.IsPhoneFollow,
                IsRecoverGuide = ent.IsRecoverGuide,
                IsUpload = ent.IsUpload,
                IsVip = ent.IsVip,
                JobCardNo = ent.JobCardNo,
                JobPost = ent.JobPost,
                JobTitle = ent.JobTitle,
                MaritalStatusId = ent.MaritalStatusId,
                MaritalStatusName = _cacheService.GetMaritalStatusNameAsync(ent.MaritalStatusId).GetAwaiter().GetResult(),
                MedicalCardNo = ent.MedicalCardNo,
                MedicalConclusionId = ent.MedicalConclusionId,
                MedicalPackageId = ent.MedicalPackageId,
                MedicalStartDate = DataHelper.ConversionDateToString(ent.MedicalStartDate),
                MedicalTimes = ent.MedicalTimes,
                MedicalTypeId = ent.MedicalTypeId,
                MedicalTypeName = _cacheService.GetMedicalTypeNameAsync(ent.MedicalTypeId).GetAwaiter().GetResult(),
                MedicalCenterId = ent.MedicalCenterId,
                PatientId = ent.PatientId,
                PatientName = ent.PatientName,
                PatientRegisterNo = ent.PatientRegisterNo,
                PersonnelTypeId = ent.PersonnelTypeId,
                PersonnelTypeName = _cacheService.GetPersonnelTypeNameAsync(ent.PersonnelTypeId).GetAwaiter().GetResult(),
                Remark = ent.Remark,
                ReportPrintTimes = ent.ReportPrintTimes,
                Salesman = ent.Salesman,
                SexHormoneTermId = ent.SexHormoneTermId,
                Photo = ent.Photo,
                CreatorName = _cacheService.GetSurnameAsync(ent.CreatorId).GetAwaiter().GetResult(),
                LastModifierName = _cacheService.GetSurnameAsync(ent.LastModifierId).GetAwaiter().GetResult(),
                Address = ent.Patient.Address,  //档案表信息
                BirthPlaceId = ent.Patient.BirthPlaceId,
                DisplayName = ent.Patient.DisplayName,
                Email = ent.Patient.Email,
                IdNo = ent.Patient.IdNo,
                MobileTelephone = ent.Patient.MobileTelephone,
                NationId = ent.Patient.NationId,
                NationName = _cacheService.GetNationNameAsync(ent.Patient.NationId).GetAwaiter().GetResult(),
                PatientNo = ent.Patient.PatientNo,
                PostalCode = ent.Patient.PostalCode,
                Telephone = ent.Patient.Telephone,
                CustomerOrgName = _cacheService.GetCustomerOrgNameAsync(ent.CustomerOrgId).GetAwaiter().GetResult(),
                CustomerOrgParentId = _cacheService.GetTopCustomerOrgAsync(ent.CustomerOrgId).GetAwaiter().GetResult().Id,
                CustomerOrgParentName = _cacheService.GetTopCustomerOrgAsync(ent.CustomerOrgId).GetAwaiter().GetResult().DisplayName,
                IsPatientOccupationalDisease = _patientOccupationalDiseaseManager.GetPatientRegisterIsOccupationalDisease(ent.Id).GetAwaiter().GetResult()
            };
            return entdto;
        }


        ///// <summary>
        ///// 创建  登记档案  弃用
        ///// </summary>
        ///// <param name="input"></param>
        ///// <returns></returns>
        //[RemoteService(false)]
        //public override async Task<PatientRegisterDto> CreateAsync(CreatePatientRegisterDto input)
        //{
        //    var createEntity = ObjectMapper.Map<CreatePatientRegisterDto, PatientRegister>(input);
        //    var createPatientEntity = ObjectMapper.Map<CreatePatientRegisterDto, Patient>(input);
        //    var entity = await _manager.CreateAsync(createEntity, createPatientEntity);
        //    var dto = ObjectMapper.Map<PatientRegister, PatientRegisterDto>(entity);
        //    return dto;
        //}


        /// <summary>
        /// 新版人员登记
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/PatientRegister/CreatePatientRegister")]
        public async Task<PatientRegisterOrNoDto> CreatePatientRegisterAsync(CreatePatientRegisterDto input)
        {
            PatientRegisterOrNoDto msg = new PatientRegisterOrNoDto();
            input.RegisterCheckAsbitems.ForEach(o =>
            {
                if (o.Id == null)
                {
                    o.Id = Guid.Empty;
                }
            });

            var createPatientRegisterArg = ObjectMapper.Map<CreatePatientRegisterDto, CreatePatientRegisterArg>(input);
            var createPatientRegisterExterArg = ObjectMapper.Map<CreatePatientRegisterDto, CreatePatientRegisterExterArg>(input);
            var updatePatientEntity = ObjectMapper.Map<CreatePatientRegisterDto, Patient>(input);
            var registerAsbitems = ObjectMapper.Map<List<CreatePatientRegisterRegisterCheckAsbitem>, List<RegisterCheckAsbitem>>(input.RegisterCheckAsbitems);
            var updatePatientRegisterArg = ObjectMapper.Map<CreatePatientRegisterDto, UpdatePatientRegisterArg>(input);
            var updatePatientRegisterExterArg = ObjectMapper.Map<CreatePatientRegisterDto, UpdatePatientRegisterExterArg>(input);
            updatePatientEntity.DisplayName = input.PatientName;
            //创建人员信息
            Patient patient = null;
            _patientManager.IsAllowIdNoSexError = input.IsAllowIdNoSexError;
            if (createPatientRegisterArg.PatientId == Guid.Empty)
            {
                patient = await _patientManager.CreateAsync(updatePatientEntity);
                await _patientRepository.InsertAsync(patient);
            }
            else
            {
                patient = await _patientRepository.GetAsync(createPatientRegisterArg.PatientId);
                await _patientManager.UpdateAsync(updatePatientEntity, patient);
            }
            //创建人员登记信息
            createPatientRegisterArg.PatientId = patient.Id;
            if (patient.BirthDate != null)
            {
                createPatientRegisterArg.BirthDate = patient.BirthDate;
            }
            PatientRegister entity = null;
            PatientRegisterExter patientRegisterExterEntity = null;
            CreateRegisterCheckAsbitemEntity createRegisterCheckAsbitemEntity = null;
            if (input.PatientRegisterId == null || input.PatientRegisterId == Guid.Empty)
            {
                entity = await _manager.CreateAsync(createPatientRegisterArg);
                createRegisterCheckAsbitemEntity = await _registerAsbitemManager.UpdateManyAsync(entity, registerAsbitems);
                entity = await _repository.InsertAsync(entity, true);

                createPatientRegisterExterArg.PatientRegisterId = entity.Id;

                #region 扩展表
                patientRegisterExterEntity = _patientRegisterExterManager.CreateAsync(createPatientRegisterExterArg);
                await _patientRegisterExterRepository.InsertAsync(patientRegisterExterEntity);
                #endregion
            }
            else
            {
                entity = await Repository.GetAsync((Guid)input.PatientRegisterId);
                char oldCompleteFlag = entity.CompleteFlag; //更新前状态
                await _manager.UpdateAsync(updatePatientRegisterArg, entity);
                createRegisterCheckAsbitemEntity = await _registerAsbitemManager.UpdateManyAsync(entity, registerAsbitems);

                #region 预登记转正式登记修改登记者ID

                string goRegisterIsUpdateRegisterPerson = await _sysParmValueManager.GetSysParmValueAsync(Guid.Empty, "go_register_is_update_register_person");
                if (goRegisterIsUpdateRegisterPerson == "1")
                {
                    if (oldCompleteFlag == PatientRegisterCompleteFlag.PreRegistration
                             && entity.CompleteFlag == PatientRegisterCompleteFlag.Registration
                             && _currentUser.Id != null)
                    {
                        //判断是预登记转正式登记
                        entity.UpdateCreatorId(_currentUser.Id.Value);
                    }
                }

                #endregion

                await _repository.UpdateAsync(entity);

                #region 扩展表
                patientRegisterExterEntity = await _patientRegisterExterRepository.FirstOrDefaultAsync(m => m.PatientRegisterId == entity.Id);
                if (patientRegisterExterEntity != null)
                {
                    _patientRegisterExterManager.UpdateAsync(updatePatientRegisterExterArg, patientRegisterExterEntity);
                    await _patientRegisterExterRepository.UpdateAsync(patientRegisterExterEntity);
                }
                #endregion
            }


            #region 推送人寿状态

            if (!string.IsNullOrWhiteSpace(entity.ThirdBookingId))
            {
                try
                {
                    await _thirdBookingPushAppService.PushRegisterAsync(new PatientRegisterIdInputDto { PatientRegisterId = entity.Id });
                }
                catch (Exception ex)
                {
                    _logger.LogError($"推送人寿完成登记=》{ex.Message}");
                }
            }
            #endregion

            //throw new Exception("后续不更新");
            if (createRegisterCheckAsbitemEntity != null)
            {
                await UpdateRegisterChecks(createRegisterCheckAsbitemEntity);
            }

            await CurrentUnitOfWork.SaveChangesAsync();
            msg = await GetPatientRegisterOrNo(entity.Id);
            return msg;
        }

        /// <summary>
        /// 批量增加组合项目
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/PatientRegister/BatchAddAsbitems")]
        public async Task BatchAddAsbitems(PatientRegisterBatchAddAsbitemsDto input)
        {


            var registerAsbitems = ObjectMapper.Map<List<BatchCreateRegisterCheckAsbitem>, List<RegisterCheckAsbitem>>(input.RegisterCheckAsbitems);

            CreateRegisterCheckAsbitemEntity createRegisterCheckAsbitemEntity = null;
            var entity = await Repository.GetAsync((Guid)input.PatientRegisterId);
            if (input.RegisterCheckAsbitems.Count == 0)
            {

                return;
            }
            var existRegisterChecks = (await _registerCheckRepository.GetQueryableAsync()).Where(o => o.PatientRegisterId == input.PatientRegisterId).AsNoTracking().ToList();

            var existRegisterAsbitems = (await _registerCheckAsbitemRepository.GetQueryableAsync()).Where(o =>
                 existRegisterChecks.Select(x => x.Id).Contains(o.RegisterCheckId)).AsNoTracking().ToList();
            foreach (var registerCheckAsbitem in input.RegisterCheckAsbitems)
            {
                if (existRegisterAsbitems.Where(o => o.AsbitemId == registerCheckAsbitem.AsbitemId).Count() > 0)
                {
                    continue;
                }
                var asbitem = await _asbitemRepository.GetAsync(registerCheckAsbitem.AsbitemId);
                var newRegisterCheckAsbitem = new RegisterCheckAsbitem()
                {
                    AsbitemId = registerCheckAsbitem.AsbitemId,
                    Amount = registerCheckAsbitem.Amount,
                    StandardPrice = asbitem.Price,
                    ChargePrice = registerCheckAsbitem.ChargePrice,
                    PayTypeFlag = registerCheckAsbitem.PayTypeFlag,
                    IsCharge = 'N'
                };
                existRegisterAsbitems.Add(newRegisterCheckAsbitem);
            }
            createRegisterCheckAsbitemEntity = await _registerAsbitemManager.UpdateManyAsync(entity, existRegisterAsbitems);

            if (createRegisterCheckAsbitemEntity != null)
            {
                await UpdateRegisterChecks(createRegisterCheckAsbitemEntity);
            }

            await CurrentUnitOfWork.SaveChangesAsync();
            return;
        }

        [HttpPost("api/PatientRegister/BatchDeleteAsbitems")]
        public async Task BatchDeleteAsbitems(PatientRegisterBatchDeleteAsbitemsDto input)
        {

            DataHelper.CheckCharIsYOrN(input.IsDeleteGroup, "如果组合项目属于分组删除分组");
            CreateRegisterCheckAsbitemEntity createRegisterCheckAsbitemEntity = null;
            var entity = await Repository.GetAsync((Guid)input.PatientRegisterId);
            if (input.RegisterCheckAsbitems.Count == 0)
            {

                return;
            }
            //删除组合项目时是否删除分组
            bool IsPatientRegisterModified = false;
            if (input.IsDeleteGroup == 'Y')
            {
                if (entity.CustomerOrgGroupId != null && entity.CustomerOrgGroupId != Guid.Empty)
                {
                    var customerOrgGroupDetails = (await _customerOrgGroupDetailRepository.GetQueryableAsync()).Where(o => o.CustomerOrgGroupId == entity.CustomerOrgGroupId).ToList();
                    foreach (var registerCheckAsbitem in input.RegisterCheckAsbitems)
                    {
                        if (customerOrgGroupDetails.Where(o => o.AsbitemId == registerCheckAsbitem.AsbitemId).Count() > 0)
                        {
                            entity.CustomerOrgGroupId = null;
                            IsPatientRegisterModified = true;
                            break;
                        }
                    }
                }
                else if (entity.MedicalPackageId != null && entity.MedicalPackageId != Guid.Empty)
                {
                    var medicalPackageDetails = (await _medicalPackageDetailRepository.GetQueryableAsync()).Where(o => o.MedicalPackageId == entity.MedicalPackageId).ToList();
                    foreach (var registerCheckAsbitem in input.RegisterCheckAsbitems)
                    {
                        if (medicalPackageDetails.Where(o => o.AsbitemId == registerCheckAsbitem.AsbitemId).Count() > 0)
                        {
                            entity.CustomerOrgGroupId = null;
                            IsPatientRegisterModified = true;
                            break;
                        }
                    }
                }
            }
            if (IsPatientRegisterModified)
            {
                await _repository.UpdateAsync(entity);
            }
            //批量删除项目
            var existRegisterChecks = (await _registerCheckRepository.GetQueryableAsync()).Where(o => o.PatientRegisterId == input.PatientRegisterId).AsNoTracking().ToList();

            var existRegisterAsbitems = (await _registerCheckAsbitemRepository.GetQueryableAsync()).Where(o =>
                 existRegisterChecks.Select(x => x.Id).Contains(o.RegisterCheckId)).AsNoTracking().ToList();
            foreach (var registerCheckAsbitem in input.RegisterCheckAsbitems)
            {
                var existRegisterAsbitem = existRegisterAsbitems.Where(o => o.AsbitemId == registerCheckAsbitem.AsbitemId).FirstOrDefault();
                if (existRegisterAsbitem != null)
                {
                    existRegisterAsbitems.Remove(existRegisterAsbitem);
                }
            }

            createRegisterCheckAsbitemEntity = await _registerAsbitemManager.UpdateManyAsync(entity, existRegisterAsbitems);

            if (createRegisterCheckAsbitemEntity != null)
            {
                await UpdateRegisterChecks(createRegisterCheckAsbitemEntity);
            }

            await CurrentUnitOfWork.SaveChangesAsync();
            return;
        }


        ///// <summary>
        ///// 体检记录查询 医生诊台
        ///// </summary>
        ///// <param name="input"></param>
        ///// <returns></returns>
        //[HttpPost("api/app/PatientRegister/GetDoctorPeisRecordList")]
        //public async Task<PagedResultDto<PatientRegisterOrNoDto>> GetDoctorPeisRecordListAsync(DoctorPeisRecordListInputDto input)
        //{

        //    var query = from a in await _repository.GetQueryableAsync()
        //                join b in await _patientRepository.GetQueryableAsync() on a.PatientId equals b.Id into bb
        //                from ab in bb.DefaultIfEmpty()
        //                join c in await _registerCheckRepository.GetQueryableAsync() on a.Id equals c.PatientRegisterId into cc
        //                from ac in cc.DefaultIfEmpty()
        //                join d in await _registerCheckAsbitemRepository.GetQueryableAsync() on ac.Id equals d.RegisterCheckId into dd
        //                from ad in dd.DefaultIfEmpty()
        //                join e in await _asbitemRepository.GetQueryableAsync() on ad.AsbitemId equals e.Id
        //                where e.IsCheck == 'Y'
        //                select new
        //                {
        //                    a,
        //                    ab,
        //                    AsbitemId = ad != null ? ad.AsbitemId : Guid.Empty,
        //                    RegisterCheckCompleteFlag = ac != null ? ac.CompleteFlag : '9',
        //                    RegisterCheckIsAudit = ac != null ? ac.IsAudit : '9'
        //                };


        //    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 >= 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 (input.SexId != null)
        //    {
        //        sumquery = sumquery.Where(m => m.a.SexId == input.SexId);
        //    }



        //    if (input.CompleteFlag != null)
        //    {
        //        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.Asbitems.Any())
        //    {

        //        sumquery = sumquery.Where(m => input.Asbitems.Contains(m.AsbitemId));
        //    }

        //    //if (input.IsPicture == 'Y')
        //    //{
        //    //    //查询有图数据
        //    //    var query_picture = from a in await _registerCheckAsbitemRepository.GetQueryableAsync()
        //    //                        join b in await _registerCheckPictureRepository.GetQueryableAsync() on a.RegisterCheckId equals b.RegisterCheckId
        //    //                        select a.PatientRegisterId;
        //    //    sumquery = sumquery.Where(m => query_picture.Contains(m.a.Id));
        //    //}

        //    if (input.AsbitemCompleteFlag != null)
        //    {
        //        sumquery = sumquery.Where(m => m.RegisterCheckCompleteFlag == input.AsbitemCompleteFlag);
        //    }

        //    if (input.AsbitemIsAudit != null)
        //    {
        //        sumquery = sumquery.Where(m => m.RegisterCheckIsAudit == input.AsbitemIsAudit);
        //    }


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

        //    int totalCount = sumqueryGroup.Count();

        //    var entlist = sumqueryGroup.OrderBy(o => o.Key).Skip(input.SkipCount * input.MaxResultCount).Take(input.MaxResultCount).Select(s => new PatientRegisterOrNoDto
        //    {
        //        CreationTime = s.FirstOrDefault().a.CreationTime,
        //        CreatorId = s.FirstOrDefault().a.CreatorId,
        //        Id = s.FirstOrDefault().a.Id,
        //        LastModificationTime = s.FirstOrDefault().a.LastModificationTime,
        //        LastModifierId = s.FirstOrDefault().a.LastModifierId,
        //        ThirdInfo = s.FirstOrDefault().a.ThirdInfo,
        //        SummaryDoctorId = s.FirstOrDefault().a.SummaryDoctorId,
        //        SummaryDate = DataHelper.ConversionDateToString(s.FirstOrDefault().a.SummaryDate),
        //        SexId = s.FirstOrDefault().a.SexId,
        //        Age = s.FirstOrDefault().a.Age,
        //        AuditDate = DataHelper.ConversionDateToString(s.FirstOrDefault().a.AuditDate),
        //        AuditDoctorId = s.FirstOrDefault().a.AuditDoctorId,
        //        BirthDate = DataHelper.ConversionDateToString(s.FirstOrDefault().a.BirthDate),
        //        CompleteFlag = s.FirstOrDefault().a.CompleteFlag,
        //        CustomerOrgGroupId = s.FirstOrDefault().a.CustomerOrgGroupId,
        //        CustomerOrgId = s.FirstOrDefault().a.CustomerOrgId,
        //        CustomerOrgRegisterId = s.FirstOrDefault().a.CustomerOrgRegisterId,
        //        GuidePrintTimes = s.FirstOrDefault().a.GuidePrintTimes,
        //        InterposeMeasure = s.FirstOrDefault().a.InterposeMeasure,
        //        IsAudit = s.FirstOrDefault().a.IsAudit,
        //        IsLock = s.FirstOrDefault().a.IsLock,
        //        IsMedicalStart = s.FirstOrDefault().a.IsMedicalStart,
        //        IsNameHide = s.FirstOrDefault().a.IsNameHide,
        //        IsPhoneFollow = s.FirstOrDefault().a.IsPhoneFollow,
        //        IsRecoverGuide = s.FirstOrDefault().a.IsRecoverGuide,
        //        IsUpload = s.FirstOrDefault().a.IsUpload,
        //        IsVip = s.FirstOrDefault().a.IsVip,
        //        JobCardNo = s.FirstOrDefault().a.JobCardNo,
        //        JobPost = s.FirstOrDefault().a.JobPost,
        //        JobTitle = s.FirstOrDefault().a.JobTitle,
        //        MaritalStatusId = s.FirstOrDefault().a.MaritalStatusId,
        //        MedicalCardNo = s.FirstOrDefault().a.MedicalCardNo,
        //        MedicalConclusionId = s.FirstOrDefault().a.MedicalConclusionId,
        //        MedicalPackageId = s.FirstOrDefault().a.MedicalPackageId,
        //        MedicalStartDate = DataHelper.ConversionDateToString(s.FirstOrDefault().a.MedicalStartDate),
        //        MedicalTimes = s.FirstOrDefault().a.MedicalTimes,
        //        MedicalTypeId = s.FirstOrDefault().a.MedicalTypeId,
        //        MedicalCenterId = s.FirstOrDefault().a.MedicalCenterId,
        //        PatientId = s.FirstOrDefault().a.PatientId,
        //        PatientName = s.FirstOrDefault().a.PatientName,
        //        PatientRegisterNo = s.FirstOrDefault().a.PatientRegisterNo,
        //        PersonnelTypeId = s.FirstOrDefault().a.PersonnelTypeId,
        //        Photo = s.FirstOrDefault().a.Photo,
        //        Remark = s.FirstOrDefault().a.Remark,
        //        ReportPrintTimes = s.FirstOrDefault().a.ReportPrintTimes,
        //        Salesman = s.FirstOrDefault().a.Salesman,
        //        SexHormoneTermId = s.FirstOrDefault().a.SexHormoneTermId,
        //        CreatorName = "",
        //        LastModifierName = "",
        //        Address = s.FirstOrDefault().ab.Address,  //档案表信息
        //        BirthPlaceId = s.FirstOrDefault().ab.BirthPlaceId,
        //        DisplayName = s.FirstOrDefault().ab.DisplayName,
        //        Email = s.FirstOrDefault().ab.Email,
        //        IdNo = s.FirstOrDefault().ab.IdNo,
        //        MobileTelephone = s.FirstOrDefault().ab.MobileTelephone,
        //        NationId = s.FirstOrDefault().ab.NationId,
        //        PatientNo = s.FirstOrDefault().ab.PatientNo,
        //        PatientPassword = s.FirstOrDefault().ab.PatientPassword,
        //        PostalCode = s.FirstOrDefault().ab.PostalCode,
        //        Telephone = s.FirstOrDefault().ab.Telephone,
        //        CustomerOrgName = _cacheService.GetCustomerOrgNameAsync(s.FirstOrDefault().a.CustomerOrgId).Result,
        //        CustomerOrgParentId = _cacheService.GetTopCustomerOrgAsync(s.FirstOrDefault().a.CustomerOrgId).Result.Id,
        //        CustomerOrgParentName = _cacheService.GetTopCustomerOrgNameAsync(s.FirstOrDefault().a.CustomerOrgId).Result

        //    }).ToList();

        //    return new PagedResultDto<PatientRegisterOrNoDto>(totalCount, entlist);

        //}





        /// <summary>
        /// 体检记录查询 医生诊台
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/PatientRegister/GetDoctorPeisRecordList")]
        public async Task<PagedResultDto<PatientRegisterOrNoDto>> GetDoctorPeisRecordListAsync(DoctorPeisRecordListInputDto input)
        {

            var query = from a in await _repository.GetQueryableAsync()
                        join b in await _patientRepository.GetQueryableAsync() on a.PatientId equals b.Id into bb
                        from ab in bb.DefaultIfEmpty()
                        join c in await _registerCheckRepository.GetQueryableAsync() on a.Id equals c.PatientRegisterId into cc
                        from ac in cc.DefaultIfEmpty()
                        join d in await _registerCheckAsbitemRepository.GetQueryableAsync() on ac.Id equals d.RegisterCheckId into dd
                        from ad in dd.DefaultIfEmpty()
                        join e in await _asbitemRepository.GetQueryableAsync() on ad.AsbitemId equals e.Id
                        where e.IsCheck == 'Y'
                        select new
                        {
                            a,
                            ab,
                            AsbitemId = ad != null ? ad.AsbitemId : Guid.Empty,
                            RegisterCheckCompleteFlag = ac != null ? ac.CompleteFlag : '9',
                            RegisterCheckIsAudit = ac != null ? ac.IsAudit : '9',
                            CheckDoctorId = ac.CheckDoctorId
                        };


            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 >= 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 (input.SexId != null)
            {
                sumquery = sumquery.Where(m => m.a.SexId == input.SexId);
            }

            if (input.CheckDoctorIds.Any())
            {
                sumquery = sumquery.Where(m => input.CheckDoctorIds.Contains(m.CheckDoctorId));
            }

            if (input.CompleteFlag != null)
            {
                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.Asbitems.Any())
            {

                sumquery = sumquery.Where(m => input.Asbitems.Contains(m.AsbitemId));
            }

            //if (input.IsPicture == 'Y')
            //{
            //    //查询有图数据
            //    var query_picture = from a in await _registerCheckAsbitemRepository.GetQueryableAsync()
            //                        join b in await _registerCheckPictureRepository.GetQueryableAsync() on a.RegisterCheckId equals b.RegisterCheckId
            //                        select a.PatientRegisterId;
            //    sumquery = sumquery.Where(m => query_picture.Contains(m.a.Id));
            //}

            if (input.AsbitemCompleteFlag != null)
            {
                sumquery = sumquery.Where(m => m.RegisterCheckCompleteFlag == input.AsbitemCompleteFlag);
            }

            if (input.AsbitemIsAudit != null)
            {
                sumquery = sumquery.Where(m => m.RegisterCheckIsAudit == input.AsbitemIsAudit);
            }

            if (input.MedicalTypeIds.Any())
            {
                sumquery = sumquery.Where(m => m.a.MedicalTypeId != null && input.MedicalTypeIds.Contains(m.a.MedicalTypeId.Value));
            }


            #region 增加项目类别权限

            List<Guid> asbitemIds = new List<Guid>();

            string AdminId = _configuration.GetValue<string>("AdminId");
            if (_currentUser.Id.Value != Guid.Parse(AdminId))
            {
                asbitemIds = (from userItemType in await _userItemTypeRepository.GetQueryableAsync()
                              join asbitem in await _asbitemRepository.GetQueryableAsync() on userItemType.ItemTypeId equals asbitem.ItemTypeId
                              where userItemType.UserId == _currentUser.Id.Value
                              select asbitem.Id).ToList();
            }

            #endregion



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


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

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

                if (_currentUser.Id.Value == Guid.Parse(AdminId))
                {
                    IsDisplay = true;
                }
                else if (s.Where(m => asbitemIds.Contains(m.AsbitemId)).Count() > 0)
                {
                    IsDisplay = true;
                }

                if (IsDisplay)
                {
                    entlist.Add(new PatientRegisterOrNoDto
                    {
                        CreationTime = s.FirstOrDefault().a.CreationTime,
                        CreatorId = s.FirstOrDefault().a.CreatorId,
                        Id = s.FirstOrDefault().a.Id,
                        LastModificationTime = s.FirstOrDefault().a.LastModificationTime,
                        LastModifierId = s.FirstOrDefault().a.LastModifierId,
                        ThirdInfo = s.FirstOrDefault().a.ThirdInfo,
                        SummaryDoctorId = s.FirstOrDefault().a.SummaryDoctorId,
                        SummaryDate = DataHelper.ConversionDateToString(s.FirstOrDefault().a.SummaryDate),
                        SexId = s.FirstOrDefault().a.SexId,
                        Age = s.FirstOrDefault().a.Age,
                        AuditDate = DataHelper.ConversionDateToString(s.FirstOrDefault().a.AuditDate),
                        AuditDoctorId = s.FirstOrDefault().a.AuditDoctorId,
                        BirthDate = DataHelper.ConversionDateToString(s.FirstOrDefault().a.BirthDate),
                        CompleteFlag = s.FirstOrDefault().a.CompleteFlag,
                        CustomerOrgGroupId = s.FirstOrDefault().a.CustomerOrgGroupId,
                        CustomerOrgId = s.FirstOrDefault().a.CustomerOrgId,
                        CustomerOrgRegisterId = s.FirstOrDefault().a.CustomerOrgRegisterId,
                        GuidePrintTimes = s.FirstOrDefault().a.GuidePrintTimes,
                        InterposeMeasure = s.FirstOrDefault().a.InterposeMeasure,
                        IsAudit = s.FirstOrDefault().a.IsAudit,
                        IsLock = s.FirstOrDefault().a.IsLock,
                        IsMedicalStart = s.FirstOrDefault().a.IsMedicalStart,
                        IsNameHide = s.FirstOrDefault().a.IsNameHide,
                        IsPhoneFollow = s.FirstOrDefault().a.IsPhoneFollow,
                        IsRecoverGuide = s.FirstOrDefault().a.IsRecoverGuide,
                        IsUpload = s.FirstOrDefault().a.IsUpload,
                        IsVip = s.FirstOrDefault().a.IsVip,
                        JobCardNo = s.FirstOrDefault().a.JobCardNo,
                        JobPost = s.FirstOrDefault().a.JobPost,
                        JobTitle = s.FirstOrDefault().a.JobTitle,
                        MaritalStatusId = s.FirstOrDefault().a.MaritalStatusId,
                        MedicalCardNo = s.FirstOrDefault().a.MedicalCardNo,
                        MedicalConclusionId = s.FirstOrDefault().a.MedicalConclusionId,
                        MedicalPackageId = s.FirstOrDefault().a.MedicalPackageId,
                        MedicalStartDate = DataHelper.ConversionDateToString(s.FirstOrDefault().a.MedicalStartDate),
                        MedicalTimes = s.FirstOrDefault().a.MedicalTimes,
                        MedicalTypeId = s.FirstOrDefault().a.MedicalTypeId,
                        MedicalCenterId = s.FirstOrDefault().a.MedicalCenterId,
                        PatientId = s.FirstOrDefault().a.PatientId,
                        PatientName = s.FirstOrDefault().a.PatientName,
                        PatientRegisterNo = s.FirstOrDefault().a.PatientRegisterNo,
                        PersonnelTypeId = s.FirstOrDefault().a.PersonnelTypeId,
                        Photo = s.FirstOrDefault().a.Photo,
                        Remark = s.FirstOrDefault().a.Remark,
                        ReportPrintTimes = s.FirstOrDefault().a.ReportPrintTimes,
                        Salesman = s.FirstOrDefault().a.Salesman,
                        SexHormoneTermId = s.FirstOrDefault().a.SexHormoneTermId,
                        CreatorName = "",
                        LastModifierName = "",
                        Address = s.FirstOrDefault().ab.Address,  //档案表信息
                        BirthPlaceId = s.FirstOrDefault().ab.BirthPlaceId,
                        DisplayName = s.FirstOrDefault().ab.DisplayName,
                        Email = s.FirstOrDefault().ab.Email,
                        IdNo = s.FirstOrDefault().ab.IdNo,
                        MobileTelephone = s.FirstOrDefault().ab.MobileTelephone,
                        NationId = s.FirstOrDefault().ab.NationId,
                        PatientNo = s.FirstOrDefault().ab.PatientNo,
                        PatientPassword = s.FirstOrDefault().ab.PatientPassword,
                        PostalCode = s.FirstOrDefault().ab.PostalCode,
                        Telephone = s.FirstOrDefault().ab.Telephone,
                        CustomerOrgName = _cacheService.GetCustomerOrgNameAsync(s.FirstOrDefault().a.CustomerOrgId).Result,
                        CustomerOrgParentId = _cacheService.GetTopCustomerOrgAsync(s.FirstOrDefault().a.CustomerOrgId).Result.Id,
                        CustomerOrgParentName = _cacheService.GetTopCustomerOrgNameAsync(s.FirstOrDefault().a.CustomerOrgId).Result
                    });
                }


            }

            int totalCount = entlist.Count;

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

            return new PagedResultDto<PatientRegisterOrNoDto>(totalCount, entlist);

        }



        /// <summary>
        /// 体检记录查询 总症医生诊台
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/PatientRegister/GetSumDoctorPeisRecordList")]
        public async Task<PagedResultDto<PatientRegisterOrNoDto>> GetSumDoctorPeisRecordListAsync(SumDoctorPeisRecordListInputtDto input)
        {
            var query = from a in await _repository.GetQueryableAsync()
                        join b in await _patientRepository.GetQueryableAsync() on a.PatientId equals b.Id into bb
                        from ab in bb.DefaultIfEmpty()
                        join c in await _registerCheckRepository.GetQueryableAsync() on a.Id equals c.PatientRegisterId into cc
                        from ac in cc.DefaultIfEmpty()
                        join d in await _registerCheckAsbitemRepository.GetQueryableAsync() on ac.Id equals d.RegisterCheckId into dd
                        from ad in dd.DefaultIfEmpty()
                        join e in await _asbitemRepository.GetQueryableAsync() on ad.AsbitemId equals e.Id
                        where e.IsCheck == 'Y'
                        select new
                        {
                            a,
                            ab,
                            AsbitemId = ad != null ? ad.AsbitemId : Guid.Empty,
                            RegisterCheckCompleteFlag = ac != null ? ac.CompleteFlag : '9',
                            RegisterCheckIsAudit = ac != null ? ac.IsAudit : '9',
                            CheckDoctorId = ac.CheckDoctorId
                        };


            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 >= 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 (input.SexId != null)
            {
                sumquery = sumquery.Where(m => m.a.SexId == input.SexId);
            }

            if (input.CheckDoctorIds.Any())
            {
                sumquery = sumquery.Where(m => input.CheckDoctorIds.Contains(m.CheckDoctorId));
            }

            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.Asbitems.Any())
            {

                sumquery = sumquery.Where(m => input.Asbitems.Contains(m.AsbitemId));
            }



            if (input.AsbitemCompleteFlag != null)
            {
                sumquery = sumquery.Where(m => m.RegisterCheckCompleteFlag == input.AsbitemCompleteFlag);
            }

            if (input.AsbitemIsAudit != null)
            {
                sumquery = sumquery.Where(m => m.RegisterCheckIsAudit == input.AsbitemIsAudit);
            }

            if (input.MedicalTypeIds.Any())
            {
                sumquery = sumquery.Where(m => m.a.MedicalTypeId != null && input.MedicalTypeIds.Contains(m.a.MedicalTypeId.Value));
            }

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


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

            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.RegisterCheckCompleteFlag != RegisterCheckCompleteFlag.GiveUpChecked).Count() == 0
                        && s.FirstOrDefault().a.CompleteFlag != PatientRegisterCompleteFlag.SumCheck)
                    {
                        IsDisplay = true;
                    }
                    else
                    {
                        IsDisplay = false;
                    }
                }
                else
                {
                    IsDisplay = true;
                }

                if (IsDisplay)
                {
                    entlist.Add(new PatientRegisterOrNoDto
                    {
                        CreationTime = s.FirstOrDefault().a.CreationTime,
                        CreatorId = s.FirstOrDefault().a.CreatorId,
                        Id = s.FirstOrDefault().a.Id,
                        LastModificationTime = s.FirstOrDefault().a.LastModificationTime,
                        LastModifierId = s.FirstOrDefault().a.LastModifierId,
                        ThirdInfo = s.FirstOrDefault().a.ThirdInfo,
                        SummaryDoctorId = s.FirstOrDefault().a.SummaryDoctorId,
                        SummaryDate = DataHelper.ConversionDateToString(s.FirstOrDefault().a.SummaryDate),
                        SexId = s.FirstOrDefault().a.SexId,
                        Age = s.FirstOrDefault().a.Age,
                        AuditDate = DataHelper.ConversionDateToString(s.FirstOrDefault().a.AuditDate),
                        AuditDoctorId = s.FirstOrDefault().a.AuditDoctorId,
                        BirthDate = DataHelper.ConversionDateToString(s.FirstOrDefault().a.BirthDate),
                        CompleteFlag = s.FirstOrDefault().a.CompleteFlag,
                        CustomerOrgGroupId = s.FirstOrDefault().a.CustomerOrgGroupId,
                        CustomerOrgId = s.FirstOrDefault().a.CustomerOrgId,
                        CustomerOrgRegisterId = s.FirstOrDefault().a.CustomerOrgRegisterId,
                        GuidePrintTimes = s.FirstOrDefault().a.GuidePrintTimes,
                        InterposeMeasure = s.FirstOrDefault().a.InterposeMeasure,
                        IsAudit = s.FirstOrDefault().a.IsAudit,
                        IsLock = s.FirstOrDefault().a.IsLock,
                        IsMedicalStart = s.FirstOrDefault().a.IsMedicalStart,
                        IsNameHide = s.FirstOrDefault().a.IsNameHide,
                        IsPhoneFollow = s.FirstOrDefault().a.IsPhoneFollow,
                        IsRecoverGuide = s.FirstOrDefault().a.IsRecoverGuide,
                        IsUpload = s.FirstOrDefault().a.IsUpload,
                        IsVip = s.FirstOrDefault().a.IsVip,
                        JobCardNo = s.FirstOrDefault().a.JobCardNo,
                        JobPost = s.FirstOrDefault().a.JobPost,
                        JobTitle = s.FirstOrDefault().a.JobTitle,
                        MaritalStatusId = s.FirstOrDefault().a.MaritalStatusId,
                        MedicalCardNo = s.FirstOrDefault().a.MedicalCardNo,
                        MedicalConclusionId = s.FirstOrDefault().a.MedicalConclusionId,
                        MedicalPackageId = s.FirstOrDefault().a.MedicalPackageId,
                        MedicalStartDate = DataHelper.ConversionDateToString(s.FirstOrDefault().a.MedicalStartDate),
                        MedicalTimes = s.FirstOrDefault().a.MedicalTimes,
                        MedicalTypeId = s.FirstOrDefault().a.MedicalTypeId,
                        MedicalCenterId = s.FirstOrDefault().a.MedicalCenterId,
                        PatientId = s.FirstOrDefault().a.PatientId,
                        PatientName = s.FirstOrDefault().a.PatientName,
                        PatientRegisterNo = s.FirstOrDefault().a.PatientRegisterNo,
                        PersonnelTypeId = s.FirstOrDefault().a.PersonnelTypeId,
                        Photo = s.FirstOrDefault().a.Photo,
                        Remark = s.FirstOrDefault().a.Remark,
                        ReportPrintTimes = s.FirstOrDefault().a.ReportPrintTimes,
                        Salesman = s.FirstOrDefault().a.Salesman,
                        SexHormoneTermId = s.FirstOrDefault().a.SexHormoneTermId,
                        CreatorName = "",
                        LastModifierName = "",
                        Address = s.FirstOrDefault().ab.Address,  //档案表信息
                        BirthPlaceId = s.FirstOrDefault().ab.BirthPlaceId,
                        DisplayName = s.FirstOrDefault().ab.DisplayName,
                        Email = s.FirstOrDefault().ab.Email,
                        IdNo = s.FirstOrDefault().ab.IdNo,
                        MobileTelephone = s.FirstOrDefault().ab.MobileTelephone,
                        NationId = s.FirstOrDefault().ab.NationId,
                        PatientNo = s.FirstOrDefault().ab.PatientNo,
                        PatientPassword = s.FirstOrDefault().ab.PatientPassword,
                        PostalCode = s.FirstOrDefault().ab.PostalCode,
                        Telephone = s.FirstOrDefault().ab.Telephone,
                        CustomerOrgName = _cacheService.GetCustomerOrgNameAsync(s.FirstOrDefault().a.CustomerOrgId).Result,
                        CustomerOrgParentId = _cacheService.GetTopCustomerOrgAsync(s.FirstOrDefault().a.CustomerOrgId).Result.Id,
                        CustomerOrgParentName = _cacheService.GetTopCustomerOrgNameAsync(s.FirstOrDefault().a.CustomerOrgId).Result
                    });
                }

            }

            int totalCount = entlist.Count;

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

            return new PagedResultDto<PatientRegisterOrNoDto>(totalCount, entlist);

        }



        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="PatientRegisterId">登记表ID</param>
        /// <param name="input">更新参数（包含档案跟登记）</param>
        /// <returns></returns>
        [HttpPost("api/patientregister/UpdatePatientRegisterAndAsbitems")]
        public async Task<PatientRegisterDto> UpdatePatientRegisterAndAsbitemsAsync(Guid PatientRegisterId, UpdatePatientRegisterDto input)
        {
            var patientRegisterEnt = await Repository.GetAsync(PatientRegisterId);
            var patientEnt = await _patientRepository.GetAsync(patientRegisterEnt.PatientId);

            var patientRegisterSourceEntity = ObjectMapper.Map<UpdatePatientRegisterDto, UpdatePatientRegisterArg>(input);
            var patientSourceEntity = ObjectMapper.Map<UpdatePatientRegisterDto, Patient>(input);

            patientSourceEntity.DisplayName = input.PatientName;
            await _patientManager.UpdateAsync(patientSourceEntity, patientEnt);
            await _manager.UpdateAsync(patientRegisterSourceEntity, patientRegisterEnt);

            await _patientRepository.UpdateAsync(patientEnt);
            patientRegisterEnt = await Repository.UpdateAsync(patientRegisterEnt);


            return ObjectMapper.Map<PatientRegister, PatientRegisterDto>(patientRegisterEnt);
        }


        /// <summary>
        /// 修改人员照片
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<PatientRegisterDto> UpdatePhotoAsync(UpdatePhotoDto input)
        {
            var ent = await _repository.GetAsync(input.PatientRegisterId);
            if (ent != null)
            {
                ent.Photo = input.Photo;
                var newent = await _repository.UpdateAsync(ent);
                return ObjectMapper.Map<PatientRegister, PatientRegisterDto>(newent);
            }
            else
            {
                return new PatientRegisterDto();
            }
        }


        ///// <summary>
        ///// 修改人员照片  二进制
        ///// </summary>
        ///// <param name="input"></param>
        ///// <returns></returns>
        //[HttpPost]
        //public async Task<PatientRegisterDto> UpdatePhoto2Async(UpdatePhoto2Dto input)
        //{
        //    var ent = await _repository.GetAsync(input.PatientRegisterId);
        //    if (ent != null)
        //    {
        //        ent.Photo = input.Photo;
        //        var newent = await _repository.UpdateAsync(ent);
        //        return ObjectMapper.Map<PatientRegister, PatientRegisterDto>(newent);
        //    }
        //    else
        //    {
        //        return new PatientRegisterDto();
        //    }
        //}


        //

        /// <summary>
        /// 上传图片  手动拼接"http://81.70.217.145/" 
        /// </summary>
        /// <returns></returns>
        public string UpLoadImg(UpdatePhotoDto input)
        {
            //_logger.LogInformation(input.Photo);

            string imgurl = $"photo/{DateTime.Now.Year}/{DateTime.Now.Month}/{DateTime.Now.Day}/{input.PatientRegisterId}";
            var isupload = ImageHelper.Base64StrToImage(input.Photo, imgurl);
            if (!string.IsNullOrEmpty(isupload))
                return isupload;
            else
                return "";
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpPost("api/app/PatientRegister/DeleteById")]
        public async Task DeleteByIdAsync(PatientRegisterIdInputDto input)
        {
            if (input == null)
            {
                throw new UserFriendlyException("input参数不能为空");
            }
            await _manager.CheckAndDeleteAsync(input.PatientRegisterId);
        }


        /// <summary>
        /// 批量删除
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task DeleteManyAsync(DeletePatientRegisterManyDto input)
        {
            if (input.PatientRegisterIds.Count > 0)
            {
                var entlist = await _repository.GetListAsync(m => input.PatientRegisterIds.Contains(m.Id));

                if (entlist.Count > 0)
                {
                    foreach (var ent in entlist)
                    {
                        await _manager.CheckAndDeleteAsync(ent.Id);
                    }
                }

            }
            else
            {
                throw new UserFriendlyException($"无可删除数据");
            }
        }


        /// <summary>
        /// 人员签到 批量
        /// </summary>
        /// <param name="PatientRegisterIds">登记表ID集合</param>
        /// <returns></returns>
        [HttpPost("api/app/patientregister/updatesigninmany")]
        public async Task<List<PatientRegisterDto>> UpdateSignInManyAsync(List<Guid> PatientRegisterIds)
        {
            List<PatientRegisterDto> msg = new List<PatientRegisterDto>();

            if (!PatientRegisterIds.Any())
                throw new UserFriendlyException($"请求参数有误");

            foreach (var PatientRegisterId in PatientRegisterIds)
            {
                var entity = await Repository.FindAsync(f => f.Id == PatientRegisterId && f.IsMedicalStart != 'Y');
                if (entity != null)
                {
                    entity.IsMedicalStart = 'Y';
                    entity.MedicalStartDate = DateTime.Now;

                    var newentity = await Repository.UpdateAsync(entity);

                    msg.Add(ObjectMapper.Map<PatientRegister, PatientRegisterDto>(newentity));
                }
            }

            return msg;

        }


        /// <summary>
        /// 批量回收表格，暂时不加是否签到跟是否做完体检的判断   
        /// </summary>
        /// <param name="PatientRegisterIds"></param>
        /// <returns></returns>
        [HttpPost("api/app/patientregister/updaterecoverguidemany")]
        public async Task<List<PatientRegisterDto>> UpdateRecoverGuideManyAsync(List<Guid> PatientRegisterIds)
        {
            List<PatientRegisterDto> msg = new List<PatientRegisterDto>();
            if (!PatientRegisterIds.Any())
                throw new UserFriendlyException($"请求参数有误");

            foreach (var PatientRegisterId in PatientRegisterIds)
            {
                var newentity = await _manager.UpdateRecoverGuideAsync(PatientRegisterId);
                msg.Add(ObjectMapper.Map<PatientRegister, PatientRegisterDto>(newentity));
            }

            return msg;
        }

        ///// <summary>
        ///// 人员签到
        ///// </summary>
        ///// <param name="PatientRegisterId">登记表ID</param>
        ///// <returns></returns>
        //public async Task<PatientRegisterDto> UpdateSignIn(Guid PatientRegisterId)
        //{
        //    var entity = await Repository.GetAsync(PatientRegisterId);
        //    if (entity == null)
        //    {
        //        throw new UserFriendlyException($"最后一次体检还未结束，不能新开，请结束最后一次体检");
        //    }
        //    else
        //    {
        //        entity.IsMedicalStart = 'N';
        //        entity.MedicalStartDate = DateOnly.FromDateTime(DateTime.Now);

        //        var newentity = await Repository.UpdateAsync(entity);

        //        return ObjectMapper.Map<PatientRegister, PatientRegisterDto>(newentity);
        //    }
        //}


        ///// <summary>
        ///// 回收表格，暂时不加是否签到跟是否做完体检的判断
        ///// </summary>
        ///// <param name="PatientRegisterId"></param>
        ///// <returns></returns>
        //public async Task<PatientRegisterDto> UpdateRecoverGuideAsync(Guid PatientRegisterId)
        //{
        //    var entity = await _manager.UpdateRecoverGuideAsync(PatientRegisterId);
        //    return ObjectMapper.Map<PatientRegister, PatientRegisterDto>(entity);
        //}


        /// <summary>
        /// 修改人员锁定状态
        /// </summary>
        /// <param name="PatientRegisterId">人员登记ID</param>
        /// <param name="IsLock">是否锁住（Y   N）</param>
        /// <returns></returns>
        public async Task<PatientRegisterDto> UpdatePatientRegisterIsLockAsync(Guid PatientRegisterId, char IsLock)
        {
            PatientRegisterDto msg = new PatientRegisterDto();

            var ent = await _repository.GetAsync(PatientRegisterId);
            if (ent != null)
            {
                ent.IsLock = IsLock;

                var newent = await _repository.UpdateAsync(ent);
                msg = ObjectMapper.Map<PatientRegister, PatientRegisterDto>(newent);
            }
            return msg;
        }


        /// <summary>
        /// 更改总检审核医生信息（保存时，医生跟日期不传时取默认登录的用户跟当前时间；取消时，如果不传就不更新医生跟日期，只更新状态）
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/patientregister/updatepatientregisterauditordoctor")]
        public async Task<PatientRegisterDto> UpdatePatientRegisterAuditorDoctorAsync(UpdatePatientRegisterAuditorDoctorDto input)
        {

            if (input == null || input.PatientRegisterId == Guid.Empty)
            {
                throw new UserFriendlyException("请求参数有误");
            }

            var entity = await _repository.GetAsync(input.PatientRegisterId);
            var entitydto = ObjectMapper.Map<UpdatePatientRegisterAuditorDoctorDto, PatientRegister>(input);
            var newentity = await _manager.UpdatePatientRegisterAuditorDoctorAsync(entitydto, entity);
            #region 推送人寿体检完成状态

            if (!string.IsNullOrWhiteSpace(entity.ThirdBookingId)
                && input.IsAudit == 'Y')
            {
                try
                {
                    await _thirdBookingPushAppService.PushCompletePhysicalAsync(new PatientRegisterIdInputDto { PatientRegisterId = entity.Id });
                }
                catch (Exception ex)
                {
                    _logger.LogError($"推送人寿完成体检=》{ex.Message}");
                }

            }


            #endregion
            return ObjectMapper.Map<PatientRegister, PatientRegisterDto>(newentity);
        }


        /// <summary>
        /// 取消总检
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/patientregister/CancelSumCheck")]
        public async Task<PatientRegisterDto> CancelSumCheckAsync(PatientRegisterIdInputDto input)
        {

            if (input == null || input.PatientRegisterId == Guid.Empty)
            {
                throw new UserFriendlyException("请求参数有误");
            }


            var entity = await _repository.GetAsync(input.PatientRegisterId);
            if (entity.CompleteFlag != PatientRegisterCompleteFlag.SumCheck)
            {
                throw new UserFriendlyException("没有总检，无需取消总检");
            }
            if (entity.IsAudit == 'Y')
            {
                throw new UserFriendlyException("已审核，请先取消审核");
            }
            var isSummaryCheckOnlySelfCanCancel = await _sysParmValueManager.GetSysParmValueAsync(entity.MedicalCenterId, "summary_check_only_self_can_cancel");
            if (isSummaryCheckOnlySelfCanCancel == "Y")
            {
                if (entity.SummaryDoctorId != CurrentUser.Id)
                {
                    throw new UserFriendlyException("只有本人才能取消总检");
                }
            }
            entity.CompleteFlag = PatientRegisterCompleteFlag.PartCheck;
            var newentity = await _repository.UpdateAsync(entity);
            return ObjectMapper.Map<PatientRegister, PatientRegisterDto>(newentity);
        }
        /// <summary>
        /// 更新病人总检综述建议
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        [HttpPost("api/app/patientregister/UpdatePatientRegisterSummarySuggestion")]
        public async Task<PatientRegisterDto> UpdatePatientRegisterSummarySuggestionAsync(UpdatePatientRegisterSummarySuggestionDto input)
        {
            if (input == null || input.PatientRegisterId == Guid.Empty)
            {
                throw new UserFriendlyException("请求参数有误");
            }

            if (!input.SumSuggestions.Any())
                throw new UserFriendlyException("请完善总检建议");
            //更新总检
            var entity = await _repository.GetAsync(input.PatientRegisterId);
            var entitydto = ObjectMapper.Map<UpdatePatientRegisterSummarySuggestionDto, PatientRegister>(input);
            var newentity = await _manager.UpdatePatientRegisterSummaryDoctorAsync(entitydto, entity);
            //删除综述题头时通过级联关系删除相应的综述内容
            await _sumSummaryHeaderRepository.DeleteAsync(m => m.PatientRegisterId == input.PatientRegisterId, true);
            //先删除建议内容
            await _sumSuggestionHeaderRepository.DeleteAsync(m => m.PatientRegisterId == input.PatientRegisterId, true);
            //删除对应的诊断数据
            await _sumDiagnosisRepository.DeleteAsync(m => m.PatientRegisterId == input.PatientRegisterId, true);
            //更新综述
            if (input.SumSummarys != null && input.SumSummarys.Any())
            {
                foreach (var item in input.SumSummarys)
                {
                    #region 插入SumSummaryHeader
                    SumSummaryHeader sumSummaryHeaderEnt = _sumSummaryHeaderManager.CreateAsync(patientRegisterId: input.PatientRegisterId,
                        summaryTitle: item.SummaryTitle,
                        summaryFlag: null,
                        displayOrder: input.SumSummarys.IndexOf(item) + 1);

                    var sumSummaryHeaderEnt_New = await _sumSummaryHeaderRepository.InsertAsync(sumSummaryHeaderEnt, true);

                    if (sumSummaryHeaderEnt_New != null)
                    {
                        #region 插入SumSummaryContent
                        List<SumSummaryContent> sumSummaryContentList = new List<SumSummaryContent>();
                        foreach (var item2 in item.Details)
                        {
                            SumSummaryContent sumSummaryContentEnt = _sumSummaryContentManager.CreateAsync(sumSummaryHeaderId: sumSummaryHeaderEnt_New.Id,
                                summaryContent: item2.SummaryContent,
                                displayOrder: item.Details.IndexOf(item2) + 1);


                            sumSummaryContentList.Add(sumSummaryContentEnt);
                        }
                        await _sumSummaryContentRepository.InsertManyAsync(sumSummaryContentList);
                        #endregion
                    }
                    #endregion
                }
            }
            //更新建议和诊断
            if (input.SumSuggestions != null && input.SumSuggestions.Any())
            {
                //判断有没有重复诊断
                List<Guid> diagnosisList = new List<Guid>();
                foreach (var item in input.SumSuggestions)
                {
                    if (item.DiagnosisIds != null)
                    {
                        diagnosisList.AddRange(item.DiagnosisIds);
                    }

                }
                if (diagnosisList.Count() != diagnosisList.Distinct().Count())
                {
                    throw new UserFriendlyException("不允许有重复诊断");
                }
                foreach (var item in input.SumSuggestions)
                {
                    #region 插入SumSuggestionHeader
                    SumSuggestionHeader sumSuggestionHeaderEnt = _sumSuggestionHeaderManager.CreateAsync(patientRegisterId: input.PatientRegisterId,
                        suggestionTitle: item.SuggestionTitle,
                        suggestionFlag: null,
                        displayOrder: input.SumSuggestions.IndexOf(item) + 1);

                    var sumSuggestionHeaderEnt_New = await _sumSuggestionHeaderRepository.InsertAsync(sumSuggestionHeaderEnt, true);

                    if (sumSuggestionHeaderEnt_New != null)
                    {

                        #region 插入SumDiagnosis
                        if (item.DiagnosisIds != null && item.DiagnosisIds.Any())
                        {


                            foreach (var diagnosisId in item.DiagnosisIds)
                            {

                                #region 校验诊断性别
                                var diagnosisEnt = await _diagnosisRepository.FirstOrDefaultAsync(f => f.Id == diagnosisId);
                                if (diagnosisEnt == null)
                                    throw new UserFriendlyException("诊断不存在");
                                if (diagnosisEnt.ForSexId != ForSexFlag.All
                                    && entity.SexId != SexFlag.UnKnown
                                    && diagnosisEnt.ForSexId != entity.SexId)
                                {
                                    throw new UserFriendlyException($"诊断:{diagnosisEnt.DisplayName}与性别不符");
                                }

                                #endregion

                                SumDiagnosis sumDiagnosis = new SumDiagnosis
                                {
                                    DiagnosisId = diagnosisId,
                                    DisplayOrder = item.DiagnosisIds.IndexOf(diagnosisId) + 1,
                                    PatientRegisterId = input.PatientRegisterId,
                                    SumSuggestionHeaderId = sumSuggestionHeaderEnt_New.Id
                                };
                                await _sumDiagnosisRepository.InsertAsync(sumDiagnosis);
                            }

                        }

                        #endregion

                        #region 插入SumSuggestionContent
                        List<SumSuggestionContent> sumSuggestionContentList = new List<SumSuggestionContent>();
                        if (item.MedicalInterpretations != null)
                        {
                            foreach (var item2 in item.MedicalInterpretations)
                            {
                                SumSuggestionContent sumSuggestionContentEnt = _sumSuggestionContentManager.CreateAsync(sumSuggestionHeaderId: sumSuggestionHeaderEnt_New.Id,
                                    suggestionContent: item2.SuggestionContent,
                                    suggestionType: SuggestionTypeFlag.MedicalInterpretation,
                                    displayOrder: item.MedicalInterpretations.IndexOf(item2) + 1);

                                sumSuggestionContentList.Add(sumSuggestionContentEnt);
                            }
                        }
                        if (item.CommonReasons != null)
                        {
                            foreach (var item2 in item.CommonReasons)
                            {
                                SumSuggestionContent sumSuggestionContentEnt = _sumSuggestionContentManager.CreateAsync(sumSuggestionHeaderId: sumSuggestionHeaderEnt_New.Id,
                                    suggestionContent: item2.SuggestionContent,
                                    suggestionType: SuggestionTypeFlag.CommonReasons,
                                    displayOrder: item.CommonReasons.IndexOf(item2) + 1);

                                sumSuggestionContentList.Add(sumSuggestionContentEnt);
                            }
                        }
                        if (item.HealthGuidances != null)
                        {
                            foreach (var item2 in item.HealthGuidances)
                            {
                                SumSuggestionContent sumSuggestionContentEnt = _sumSuggestionContentManager.CreateAsync(sumSuggestionHeaderId: sumSuggestionHeaderEnt_New.Id,
                                    suggestionContent: item2.SuggestionContent,
                                    suggestionType: SuggestionTypeFlag.HealthGuidance,
                                    displayOrder: item.HealthGuidances.IndexOf(item2) + 1);

                                sumSuggestionContentList.Add(sumSuggestionContentEnt);
                            }
                        }

                        await _sumSuggestionContentRepository.InsertManyAsync(sumSuggestionContentList);
                        #endregion
                    }
                    #endregion
                }
            }

            return ObjectMapper.Map<PatientRegister, PatientRegisterDto>(newentity);
        }

        /// <summary>
        /// 批量修改指引单打印次数 原有基础上加1
        /// </summary>
        /// <param name="Ids"></param>
        /// <returns></returns>
        [HttpPost("api/app/patientregister/updatepatientregisterguideprinttimesmany")]
        public async Task UpdatePatientRegisterGuidePrintTimesManyAsync(List<Guid> Ids)
        {
            var entlist = await _repository.GetListAsync(m => Ids.Contains(m.Id));
            entlist.ForEach(f => f.GuidePrintTimes = (short)(f.GuidePrintTimes + 1));
        }

        /// <summary>
        /// 批量修改体检报告打印次数 原有基础上加1
        /// </summary>
        /// <param name="Ids"></param>
        /// <returns></returns>
        [HttpPost("api/app/patientregister/updatepatientregisterreportprinttimesmany")]
        public async Task UpdatePatientRegisterReportPrintTimesManyAsync(List<Guid> Ids)
        {
            var entlist = await _repository.GetListAsync(m => Ids.Contains(m.Id));
            entlist.ForEach(f => f.ReportPrintTimes = (short)(f.ReportPrintTimes + 1));
        }


        /// <summary>
        /// 导入体检名单操作
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        [HttpPost("api/app/patientregister/CreatePatientRegisterFromExcel")]
        public async Task CreatePatientRegisterFromExcelAsync(CreatePatientRegisterExcelRequestDto input)
        {
            if (input == null)
            {
                throw new UserFriendlyException("input参数不能为空");
            }
            if (string.IsNullOrWhiteSpace(input.PatientName))
            {
                throw new UserFriendlyException("姓名不能为空");
            }


            #region 转换职业病信息

            Guid ocCheckTypeId = Guid.Empty;
            List<Guid> poisonIds = new List<Guid>();

            if (input.IsOccupationalDisease == 'Y')
            {
                if (string.IsNullOrWhiteSpace(input.OcCheckTypeName))
                {
                    throw new UserFriendlyException("职业病检查类别不能为空");
                }

                if (string.IsNullOrWhiteSpace(input.JobType))
                {
                    throw new UserFriendlyException("职业病工种不能为空");
                }

                if (!input.Poisons.Any())
                {
                    throw new UserFriendlyException("职业病毒害因素不能为空");
                }

                #region 职业病检查类别
                var ocCheckTypeEnt = await _ocCheckTypeRepository.FirstOrDefaultAsync(f => f.DisplayName == input.OcCheckTypeName);
                if (ocCheckTypeEnt == null)
                {
                    throw new UserFriendlyException($"职业病检查类别{input.OcCheckTypeName}名称不正确");
                }

                ocCheckTypeId = ocCheckTypeEnt.Id;
                #endregion

                #region 职业病毒害因素


                foreach (var poisonItem in input.Poisons)
                {
                    if (string.IsNullOrWhiteSpace(poisonItem))
                        throw new UserFriendlyException($"职业病毒害因素{poisonItem}不能为空");

                    var poisonEnt = await _poisonRepository.FirstOrDefaultAsync(f => f.DisplayName == poisonItem);
                    if (poisonEnt == null)
                    {
                        throw new UserFriendlyException($"职业病毒害因素{poisonItem}名称不正确");
                    }
                    if (!poisonIds.Contains(poisonEnt.Id))
                    {
                        poisonIds.Add(poisonEnt.Id);
                    }
                }

                #endregion


            }

            Guid? medicalTypeId;

            if (input.IsDefaultMedicalType == 'Y' && input.IsOccupationalDisease == 'Y')
            {
                //人员登记检查类别
                var systemMedicalTypeId = await _sysParmValueManager.GetSysParmValueAsync(input.MedicalCenterId, "patient_register_occ_check_id");
                if (string.IsNullOrWhiteSpace(systemMedicalTypeId))
                    throw new UserFriendlyException("系统参数中未配置职业病检查的体检类别ID");
                medicalTypeId = Guid.Parse(systemMedicalTypeId);
            }
            else
            {
                medicalTypeId = await GetMedicalTypeIdByName(input.MedicalTypeName);
            }


            #endregion


            //设置人员信息
            Patient patient = null;
            Patient updatePatientEntity = new Patient()
            {
                MedicalCenterId = input.MedicalCenterId,
                DisplayName = input.PatientName,
                MaritalStatusId = await GetMaritalStatusIdByName(input.MaritalStatusName),
                Address = input.Address,
                BirthDate = GetBirthDateByString(input.BirthDate),
                BirthPlaceId = await GetBirthPlaceIdByName(input.BirthPlaceName),
                Email = input.Email,
                IdNo = input.IdNo,
                MobileTelephone = input.MobileTelephone,
                NationId = await GetNationIdByName(input.NationName),
                PostalCode = input.PostalCode,
                SexId = await GetSexIdByName(input.SexName),
                Telephone = input.Telephone
            };

            if (!string.IsNullOrWhiteSpace(input.IdNo))
            {
                var patientList = await _patientRepository.GetListAsync(o => o.IdNo == input.IdNo);
                if (patientList.Count > 0)
                {
                    if (patientList.Where(m => m.DisplayName == input.PatientName).Count() == 0)
                        throw new UserFriendlyException("系统中已有该身份证号的不同姓名人员");
                    else
                    {
                        patient = patientList.FirstOrDefault(f => f.DisplayName == input.PatientName);
                    }
                }

            }
            if (!string.IsNullOrWhiteSpace(input.PatientNo))
            {
                patient = await _patientRepository.FirstOrDefaultAsync(o => o.PatientNo == input.PatientNo);
                if (patient.DisplayName != input.PatientName)
                {
                    throw new UserFriendlyException("系统中已有该档案号的不同姓名人员");
                }
            }
            if (patient == null)
            {
                patient = await _patientManager.CreateAsync(updatePatientEntity);
                await _patientRepository.InsertAsync(patient, true);
            }
            else
            {
                await _patientManager.UpdateAsync(updatePatientEntity, patient);
                await _patientRepository.UpdateAsync(patient, true);
            }
            Guid? customerOrgId = await GetCustomerOrgIdByName(input.CustomerOrgId, input.DepartmentName, input.IsAutoCreateDepartment);
            if (customerOrgId == null)
            {
                customerOrgId = input.CustomerOrgId;
            }
            Guid? customerOrgGroupId = await GetCustomerOrgGroupIdByName(input.CustomerOrgRegisterId, input.CustomerOrgGroupName);
            //创建人员登记信息
            var createPatientRegisterArg = new CreatePatientRegisterArg()
            {
                Age = input.Age,
                BirthDate = updatePatientEntity.BirthDate,
                CompleteFlag = input.CompleteFlag,
                CustomerOrgGroupId = customerOrgGroupId,
                CustomerOrgId = (Guid)customerOrgId,
                CustomerOrgRegisterId = input.CustomerOrgRegisterId,
                IsNameHide = 'N',
                IsVip = 'N',
                JobCardNo = input.JobCardNo,
                JobPost = input.JobPost,
                JobTitle = input.JobTitle,
                MaritalStatusId = updatePatientEntity.MaritalStatusId,
                MedicalCardNo = input.MedicalCardNo,
                MedicalPackageId = null,
                MedicalTypeId = medicalTypeId,
                MedicalCenterId = input.MedicalCenterId,
                PatientId = patient.Id,
                PatientName = input.PatientName,
                PersonnelTypeId = await GetPersonnelTypeIdByName(input.PersonnelTypeName),
                Remark = input.Remark,
                Salesman = input.Salesman,
                SexId = updatePatientEntity.SexId,
                ThirdInfo = input.ThirdInfo
            };
            PatientRegister patientRegister = null;
            CreateRegisterCheckAsbitemEntity createRegisterCheckAsbitemEntity = null;
            patientRegister = await _manager.CreateAsync(createPatientRegisterArg);
            #region 人寿的信息生成一个预约ID

            var thirdBookingInterface = await _thirdInterfaceRepository.FirstOrDefaultAsync(o => o.ThirdInterfaceType ==
          ThirdInterfaceTypeFlag.ThirdBooking);
            if (thirdBookingInterface != null && thirdBookingInterface.IsActive == 'Y')
            {
                var parmValue = thirdBookingInterface.ParmValue;
                var configurationBuilder = new ConfigurationBuilder()
                     .AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
                var interfaceConfig = configurationBuilder.Build();
                var customerOrgRegisterId = interfaceConfig.GetSection("Interface").GetSection("CustomerOrgRegisterId").Value;
                if (customerOrgRegisterId == input.CustomerOrgRegisterId.ToString())
                {
                    var thirdBookingEnt = await _thirdBookingRepository.FirstOrDefaultAsync(f => f.PatientName == input.PatientName
                    && f.IdNo == input.IdNo
                    && (f.Phone == input.MobileTelephone || f.Phone == input.Telephone)
                    && f.MedicalStatus != '3');
                    if (thirdBookingEnt != null)
                    {
                        patientRegister.ThirdBookingId = thirdBookingEnt.Id.ToString();
                    }
                    else
                    {
                        throw new UserFriendlyException("该人员未预约，请先预约");
                    }
                }
            }

            #endregion
            if (customerOrgGroupId != null)
                await _patientRegisterManager.SetCustomerOrgGroupId(patientRegister, (Guid)customerOrgGroupId);
            await _repository.InsertAsync(patientRegister, true);


            List<RegisterCheckAsbitem> registerAsbitems = new List<RegisterCheckAsbitem>();

            //设置分组有关组合项目
            if (customerOrgGroupId != null)
            {
                registerAsbitems = (await _customerOrgGroupDetailRepository.GetQueryableAsync()).Include(x => x.Asbitem)
                      .Where(m => m.CustomerOrgGroupId == customerOrgGroupId)
                      .Select(s => new RegisterCheckAsbitem
                      {
                          Amount = s.Amount,
                          AsbitemId = s.AsbitemId,
                          ChargePrice = s.Price,
                          IsCharge = 'N',
                          PatientRegisterId = patientRegister.Id,
                          PayTypeFlag = PayTypeFlag.OrgPay,
                          StandardPrice = s.Asbitem.Price
                      }).ToList();

            }

            #region 职业病业务  检索职业病对应的项目

            if (input.IsOccupationalDisease == 'Y')
            {
                //var ocCheckTypeDetailList = await _ocCheckTypeDetailRepository.GetListAsync(f => f.OcCheckTypeId == ocCheckTypeId && poisonIds.Contains(f.PoisonId));
                var ocCheckTypeDetailList = from ocCheckTypeDetail in await _ocCheckTypeDetailRepository.GetQueryableAsync()
                                            join asbitem in await _asbitemRepository.GetQueryableAsync() on ocCheckTypeDetail.AsbitemId equals asbitem.Id
                                            where ocCheckTypeDetail.OcCheckTypeId == ocCheckTypeId && poisonIds.Contains(ocCheckTypeDetail.PoisonId)
                                            select new
                                            {
                                                Amount = ocCheckTypeDetail.Amount,
                                                AsbitemId = ocCheckTypeDetail.AsbitemId,
                                                ChargePrice = ocCheckTypeDetail.Price,
                                                StandardPrice = asbitem.Price
                                            };

                foreach (var item in ocCheckTypeDetailList)
                {
                    if (registerAsbitems.Where(m => m.AsbitemId == item.AsbitemId).Count() == 0)
                    {
                        registerAsbitems.Add(new RegisterCheckAsbitem
                        {
                            Amount = item.Amount,
                            AsbitemId = item.AsbitemId,
                            ChargePrice = item.ChargePrice,
                            IsCharge = 'N',
                            PatientRegisterId = patientRegister.Id,
                            PayTypeFlag = PayTypeFlag.OrgPay,
                            StandardPrice = item.StandardPrice
                        });
                    }
                }


            }
            #endregion

            if (registerAsbitems.Any())
            {

                createRegisterCheckAsbitemEntity = await _registerAsbitemManager.UpdateManyAsync(patientRegister, registerAsbitems);

                if (createRegisterCheckAsbitemEntity != null)
                {
                    await UpdateRegisterChecks(createRegisterCheckAsbitemEntity);
                }
            }

            #region   增加职业病信息

            if (input.IsOccupationalDisease == 'Y')
            {

                //基础信息
                var patientOccupationalDiseaseEnt = new PatientOccupationalDisease
                {
                    JobType = input.JobType,
                    OcCheckTypeId = ocCheckTypeId,
                    RiskFactors = string.Join(",", input.Poisons),
                    PatientRegisterId = patientRegister.Id,
                    DrinkFlag = '0',
                    SmokeFlag = '0',
                    FamilyGeneticHistory = "无",
                    Other = "无"
                };

                patientOccupationalDiseaseEnt = _patientOccupationalDiseaseManager.CreateAsync(patientOccupationalDiseaseEnt);
                await _patientOccupationalDiseaseRepository.InsertAsync(patientOccupationalDiseaseEnt);

                //毒害因素
                List<PatientPoison> patientPoisons = new List<PatientPoison>();

                foreach (var poisonId in poisonIds)
                {
                    var patientPoisonEnt = new PatientPoison
                    {
                        PatientRegisterId = patientRegister.Id,
                        PoisonId = poisonId
                    };

                    patientPoisonEnt = _patientPoisonManager.CreateAsync(patientPoisonEnt);

                    patientPoisons.Add(patientPoisonEnt);
                }

                await _patientPoisonRepository.InsertManyAsync(patientPoisons);
            }
            #endregion


            await CurrentUnitOfWork.SaveChangesAsync();
        }

        /// <summary>
        /// 导入人员信息从第三方接口（青藏铁路接口）
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        [HttpPost("api/app/patientregister/CreatePatientRegisterFromCustomerOrgInterface")]
        public async Task<ImportPatientRegisterByCustomerOrgRegisterIdDto> CreatePatientRegisterFromCustomerOrgInterfaceAsync(CustomerOrgRegisterIdInputDto input)
        {
            if (input == null)
            {
                throw new UserFriendlyException("input参数不能为空");
            }
            var thirdInterfaces = await _thirdInterfaceRepository.GetListAsync(o => o.ThirdInterfaceType == ThirdInterfaceTypeFlag.ImportPatientRegister);
            foreach (var thirdInterface in thirdInterfaces)
            {
                if (thirdInterface.IsActive != 'Y')
                {
                    continue;
                }
                var parmValue = thirdInterface.ParmValue;
                var configurationBuilder = new ConfigurationBuilder()
                   .AddJsonStream(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(parmValue)));
                var config = configurationBuilder.Build();
                var customerOrgIdStr = config.GetSection("Interface").GetSection("CustomerOrgId").Value;
                if (!Guid.TryParse(customerOrgIdStr, out var customerOrgId))
                {
                    throw new UserFriendlyException("接口配置中的CustomerOrgId无法解析成GUID");
                }
                var customerOrgRegister = (await _customerOrgRegisterRepository.GetQueryableAsync())
                    .Where(o => o.Id == input.CustomerOrgRegisterId).First();
                if (customerOrgRegister.CustomerOrgId != customerOrgId)
                {
                    continue;
                }

                object[] objects = [input.CustomerOrgRegisterId];

                var assemblyName = config.GetSection("Interface").GetSection("AssemblyName").Value;
                var className = config.GetSection("Interface").GetSection("ClassName").Value;

                var pluginsOut = await Utilities.ReflectionHelper.InvokeAsync<ImportPatientRegisterByCustomerOrgRegisterIdDto>(assemblyName,
                    className, [thirdInterface.Id], "ImportPatientRegisterByCustomerOrgRegisterIdAsync", objects);
                return pluginsOut;
            }
            return null;

        }
        [HttpPost("api/app/patientregister/GetSameNamePatient")]
        public async Task<List<GetSameNamePatientDto>> GetSameNamePatientAsync(GetSameNamePatientInputDto getSameNamePatientInputDto)
        {
            var patientQuery = await _patientRepository.GetQueryableAsync();
            var patientRegisterQuery = await Repository.GetQueryableAsync();
            var customerOrgQuery = await _customerOrgRepository.GetQueryableAsync();
            var topCustomerOrgQuery = await _customerOrgRepository.GetQueryableAsync();
            var result = (from patient in patientQuery
                          join patientRegister in patientRegisterQuery
                          on patient.Id equals patientRegister.PatientId
                          join customerOrg in customerOrgQuery
                          on patientRegister.CustomerOrgId equals customerOrg.Id
                          join topCustomerOrg in topCustomerOrgQuery
                          on customerOrg.PathCode.Substring(0, 5) equals topCustomerOrg.PathCode
                          where patient.DisplayName == getSameNamePatientInputDto.Name
                          select new
                          {
                              PatientName = patient.DisplayName,
                              PatientNo = patient.PatientNo,
                              SexId = patient.SexId,
                              NationId = patient.NationId,
                              BirthDate = patient.BirthDate,
                              //SexName = _cacheService.GetSexNameAsync(patient.SexId).Result,
                              //NationName = _cacheService.GetNationNameAsync(patient.NationId).Result,
                              // BirthDate =  ConvertExtr.ToStringByDateOnly( patient.BirthDate),
                              IdNo = patient.IdNo,
                              PostalCode = patient.PostalCode,
                              Email = patient.Email,
                              Telephone = patient.Telephone,
                              MobileTelephone = patient.MobileTelephone,
                              Address = patient.Address,
                              CustomerOrgName = topCustomerOrg.DisplayName,
                              CustomerOrgId = patientRegister.CustomerOrgId,
                              DepartmentName = customerOrg.DisplayName

                          }).Distinct().ToList();
            var getSameNamePatientDtos = new List<GetSameNamePatientDto>();

            foreach (var item in result)
            {
                getSameNamePatientDtos.Add(new GetSameNamePatientDto()
                {
                    PatientName = item.PatientName,
                    PatientNo = item.PatientNo,

                    SexName = _cacheService.GetSexNameAsync(item.SexId).Result,
                    NationName = _cacheService.GetNationNameAsync(item.NationId).Result,
                    BirthDate = DataHelper.ConversionDateToString(item.BirthDate),
                    IdNo = item.IdNo,
                    PostalCode = item.PostalCode,
                    Email = item.Email,
                    Telephone = item.Telephone,
                    MobileTelephone = item.MobileTelephone,
                    Address = item.Address,
                    CustomerOrgName = item.CustomerOrgName,
                    DepartmentName = item.DepartmentName
                });

            }
            return getSameNamePatientDtos;

        }

        [HttpPost("api/app/patientregister/GetCustomerOrgSameNamePatient")]
        public async Task<List<GetSameNamePatientDto>> GetCustomerOrgSameNamePatientAsync(GetCustomerOrgSameNamePatientInputDto getCustomerOrgSameNamePatientInputDto)
        {
            var customerOrgEntity = await _customerOrgManager.GetTopCustomerOrgAsync(getCustomerOrgSameNamePatientInputDto.CustomerOrgId);
            var patientQuery = await _patientRepository.GetQueryableAsync();
            var patientRegisterQuery = await Repository.GetQueryableAsync();
            var customerOrgQuery = await _customerOrgRepository.GetQueryableAsync();
            var topCustomerOrgQuery = await _customerOrgRepository.GetQueryableAsync();
            var result = (from patient in patientQuery
                          join patientRegister in patientRegisterQuery
                          on patient.Id equals patientRegister.PatientId
                          join customerOrg in customerOrgQuery
                          on patientRegister.CustomerOrgId equals customerOrg.Id
                          where patient.DisplayName == getCustomerOrgSameNamePatientInputDto.Name &&
                          customerOrg.PathCode.Substring(0, 5) == customerOrgEntity.PathCode
                          select new
                          {
                              PatientName = patient.DisplayName,
                              PatientNo = patient.PatientNo,
                              SexId = patient.SexId,
                              NationId = patient.NationId,
                              BirthDate = patient.BirthDate,
                              //SexName = _cacheService.GetSexNameAsync(patient.SexId).Result,
                              //NationName = _cacheService.GetNationNameAsync(patient.NationId).Result,
                              // BirthDate =  ConvertExtr.ToStringByDateOnly( patient.BirthDate),
                              IdNo = patient.IdNo,
                              PostalCode = patient.PostalCode,
                              Email = patient.Email,
                              Telephone = patient.Telephone,
                              MobileTelephone = patient.MobileTelephone,
                              Address = patient.Address,
                              CustomerOrgId = patientRegister.CustomerOrgId,
                              DepartmentName = customerOrg.DisplayName

                          }).Distinct().ToList();
            var getSameNamePatientDtos = new List<GetSameNamePatientDto>();

            foreach (var item in result)
            {
                getSameNamePatientDtos.Add(new GetSameNamePatientDto()
                {
                    PatientName = item.PatientName,
                    PatientNo = item.PatientNo,

                    SexName = _cacheService.GetSexNameAsync(item.SexId).Result,
                    NationName = _cacheService.GetNationNameAsync(item.NationId).Result,
                    BirthDate = DataHelper.ConversionDateToString(item.BirthDate),
                    IdNo = item.IdNo,
                    PostalCode = item.PostalCode,
                    Email = item.Email,
                    Telephone = item.Telephone,
                    MobileTelephone = item.MobileTelephone,
                    Address = item.Address,
                    CustomerOrgName = customerOrgEntity.DisplayName,
                    DepartmentName = item.DepartmentName
                });

            }
            return getSameNamePatientDtos;

        }

        /// <summary>
        /// 查询历史登记信息  用做批量导入
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/patientregister/getpatientregisterimportlist")]
        public async Task<List<PatientRegisterOrNoDto>> GetPatientRegisterImportListAsync(GetPatientRegisterImportListRequestDto input)
        {
            var customerOrgList = await _customerOrgRepository.GetListAsync();

            var query = from a in await _repository.GetQueryableAsync()
                        join ab in await _patientRepository.GetQueryableAsync() on a.PatientId equals ab.Id
                        select new
                        {
                            a,
                            ab
                        };


            //找单位下的所有部门ID 包含本身
            var CustomerOrgIds = await _customerOrgManager.GetCustomerOrgChildrenId(input.CustomerOrgId);

            if (CustomerOrgIds.Any())
            {
                query = query.Where(m => CustomerOrgIds.Contains(m.a.CustomerOrgId));
            }
            //体检次数
            if (input.CustomerOrgRegisterId != Guid.Empty)
            {
                query = query.Where(m => m.a.CustomerOrgRegisterId == input.CustomerOrgRegisterId);
            }


            //登记日期
            if (!string.IsNullOrEmpty(input.StartDate) && !string.IsNullOrEmpty(input.EndDate))
            {
                query = query.Where(m => m.a.CreationTime >= Convert.ToDateTime(input.StartDate) &&
             m.a.CreationTime < Convert.ToDateTime(input.EndDate).AddDays(1));

            }



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

            if (input.SexId != null && input.SexId != ForSexFlag.All)
            {
                query = query.Where(m => m.a.SexId == input.SexId);
            }

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



            ////档案号区间
            if (!string.IsNullOrEmpty(input.StartPatientNo) && !string.IsNullOrEmpty(input.EndPatientNo))
            {

                query = query.Where(m => String.Compare(m.ab.PatientNo, input.StartPatientNo, StringComparison.OrdinalIgnoreCase) > 0
                 && String.Compare(m.ab.PatientNo, input.EndPatientNo, StringComparison.OrdinalIgnoreCase) <= 0).AsQueryable();

            }


            var entlist = query.Select(s => new PatientRegisterOrNoDto
            {
                CreationTime = s.a.CreationTime,
                CreatorId = s.a.CreatorId,
                Id = s.a.Id,
                LastModificationTime = s.a.LastModificationTime,
                LastModifierId = s.a.LastModifierId,
                ThirdInfo = s.a.ThirdInfo,
                SummaryDoctorId = s.a.SummaryDoctorId,
                SummaryDate = DataHelper.ConversionDateToString(s.a.SummaryDate),
                SexId = s.a.SexId,
                Age = s.a.Age,
                AuditDate = DataHelper.ConversionDateToString(s.a.AuditDate),
                AuditDoctorId = s.a.AuditDoctorId,
                BirthDate = DataHelper.ConversionDateToString(s.a.BirthDate),
                CompleteFlag = s.a.CompleteFlag,
                CustomerOrgGroupId = s.a.CustomerOrgGroupId,
                CustomerOrgId = s.a.CustomerOrgId,
                CustomerOrgRegisterId = s.a.CustomerOrgRegisterId,
                GuidePrintTimes = s.a.GuidePrintTimes,
                InterposeMeasure = s.a.InterposeMeasure,
                IsAudit = s.a.IsAudit,
                IsLock = s.a.IsLock,
                IsMedicalStart = s.a.IsMedicalStart,
                IsNameHide = s.a.IsNameHide,
                IsPhoneFollow = s.a.IsPhoneFollow,
                IsRecoverGuide = s.a.IsRecoverGuide,
                IsUpload = s.a.IsUpload,
                IsVip = s.a.IsVip,
                JobCardNo = s.a.JobCardNo,
                JobPost = s.a.JobPost,
                JobTitle = s.a.JobTitle,
                MaritalStatusId = s.a.MaritalStatusId,
                MedicalCardNo = s.a.MedicalCardNo,
                MedicalConclusionId = s.a.MedicalConclusionId,
                MedicalPackageId = s.a.MedicalPackageId,
                MedicalStartDate = DataHelper.ConversionDateToString(s.a.MedicalStartDate),
                MedicalTimes = s.a.MedicalTimes,
                MedicalTypeId = s.a.MedicalTypeId,
                MedicalCenterId = s.a.MedicalCenterId,
                PatientId = s.a.PatientId,
                PatientName = s.a.PatientName,
                PatientRegisterNo = s.a.PatientRegisterNo,
                PersonnelTypeId = s.a.PersonnelTypeId,
                Photo = s.a.Photo,
                Remark = s.a.Remark,
                ReportPrintTimes = s.a.ReportPrintTimes,
                Salesman = s.a.Salesman,
                SexHormoneTermId = s.a.SexHormoneTermId,
                CreatorName = "",
                LastModifierName = "",
                Address = s.ab.Address,  //档案表信息
                BirthPlaceId = s.ab.BirthPlaceId,
                DisplayName = s.ab.DisplayName,
                Email = s.ab.Email,
                IdNo = s.ab.IdNo,
                MobileTelephone = s.ab.MobileTelephone,
                NationId = s.ab.NationId,
                PatientNo = s.ab.PatientNo,
                PatientPassword = s.ab.PatientPassword,
                PostalCode = s.ab.PostalCode,
                Telephone = s.ab.Telephone,
                CustomerOrgName = EntityHelper.GetCustomerOrgNameNoSql(customerOrgList, s.a.CustomerOrgId),
                CustomerOrgParentId = EntityHelper.GetParentNoSql(customerOrgList, s.a.CustomerOrgId),
                CustomerOrgParentName = EntityHelper.GetCustomerOrgParentNameNoSql(customerOrgList, s.a.CustomerOrgId)

            }).ToList();



            return entlist;

        }



        /// <summary>
        /// 按历史登记导入体检名单操作
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/patientregister/CreatePatientRegisterFromHistory")]
        public async Task CreatePatientRegisterFromHistoryAsync(CreatePatientRegisterHistoryRequestDto input)
        {
            if (input == null)
            {
                throw new UserFriendlyException("input参数不能为空");
            }
            var oldPatientRegisterEntity = await _repository.FirstOrDefaultAsync(m => m.Id == input.PatientRegisterId);
            if (oldPatientRegisterEntity == null)
            {
                throw new UserFriendlyException("人员登记ID查找人员登记信息不存在");
            }
            var oldPatientEntity = await _patientRepository.FirstOrDefaultAsync(m => m.Id == oldPatientRegisterEntity.PatientId);
            if (oldPatientEntity == null)
            {
                throw new UserFriendlyException("人员档案信息不存在");
            }
            var createPatientRegisterArg = new CreatePatientRegisterArg()
            {
                BirthDate = oldPatientRegisterEntity.BirthDate,
                CompleteFlag = input.CompleteFlag,
                CustomerOrgGroupId = input.CustomerOrgGroupId,
                CustomerOrgId = input.CustomerOrgId,
                CustomerOrgRegisterId = input.CustomerOrgRegisterId,
                IsNameHide = 'N',
                IsVip = 'N',
                JobCardNo = oldPatientRegisterEntity.JobCardNo,
                JobPost = oldPatientRegisterEntity.JobPost,
                JobTitle = oldPatientRegisterEntity.JobTitle,
                MaritalStatusId = oldPatientRegisterEntity.MaritalStatusId,
                MedicalCardNo = oldPatientRegisterEntity.MedicalCardNo,
                MedicalPackageId = null,
                MedicalTypeId = oldPatientRegisterEntity.MedicalTypeId,
                MedicalCenterId = input.MedicalCenterId,
                PatientId = oldPatientRegisterEntity.PatientId,
                PatientName = oldPatientRegisterEntity.PatientName,
                PersonnelTypeId = oldPatientRegisterEntity.PersonnelTypeId,
                SexId = oldPatientRegisterEntity.SexId
            };
            var patientRegister = await _manager.CreateAsync(createPatientRegisterArg);

            await _patientRegisterManager.SetCustomerOrgGroupId(patientRegister, input.CustomerOrgGroupId);

            await _repository.InsertAsync(patientRegister, true);
            //设置分组有关组合项目

            var registerAsbitems = (await _customerOrgGroupDetailRepository.GetQueryableAsync()).Include(x => x.Asbitem)
                    .Where(m => m.CustomerOrgGroupId == input.CustomerOrgGroupId)
                    .Select(s => new RegisterCheckAsbitem
                    {
                        Amount = s.Amount,
                        AsbitemId = s.AsbitemId,
                        ChargePrice = s.Price,
                        IsCharge = 'N',
                        PatientRegisterId = patientRegister.Id,
                        PayTypeFlag = PayTypeFlag.OrgPay,
                        StandardPrice = s.Asbitem.Price
                    }).ToList();

            var createRegisterCheckAsbitemEntity = await _registerAsbitemManager.UpdateManyAsync(patientRegister, registerAsbitems);

            if (createRegisterCheckAsbitemEntity != null)
            {
                await UpdateRegisterChecks(createRegisterCheckAsbitemEntity);
            }

            await CurrentUnitOfWork.SaveChangesAsync();
        }

        #region 调整分组


        /// <summary>
        /// 调整体检人员分组
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/patientregister/updatepatientregistercustomerorggroup_bak")]
        public async Task UpdatePatientRegisterCustomerOrgGroupAsyncBak(UpdatePatientRegisterCustomerOrgGroupDto input)
        {
            //当前人员信息
            var patientRegisterEnt = (await _repository.GetDbSetAsync())
                .Include(x => x.RegisterCheckAsbitems)
                .ThenInclude(x => x.RegisterCheck)
                .Where(m => m.Id == input.PatientRegisterId).FirstOrDefault();
            if (patientRegisterEnt != null)
            {
                if (patientRegisterEnt.CustomerOrgId == null || patientRegisterEnt.CustomerOrgId == Guid.Empty)
                {
                    throw new UserFriendlyException("个人体检不支持调整");
                }
                if (patientRegisterEnt.CompleteFlag == PatientRegisterCompleteFlag.SumCheck)
                {
                    throw new UserFriendlyException("当前体检人员已完成总检");
                }
                if (patientRegisterEnt.CustomerOrgGroupId == input.CustomerOrgGroupId)
                {
                    throw new UserFriendlyException("当前体检人员已在此分组");
                }


                //原有分组下的组合项目
                //var oldGroupAsbitemList = await _customerOrgGroupDetailRepository.GetListAsync(m => m.CustomerOrgGroupId == patientRegisterEnt.CustomerOrgGroupId);
                var oldGroupAsbitemList = (await _customerOrgGroupDetailRepository.GetDbSetAsync())
                    .Include(x => x.Asbitem)
                    .Where(m => m.CustomerOrgGroupId == patientRegisterEnt.CustomerOrgGroupId).ToList();

                //需要调整的分组包含的组合项目
                //var newGroupAsbitemList = await _customerOrgGroupDetailRepository.GetListAsync(m => m.CustomerOrgGroupId == input.CustomerOrgGroupId);
                var newGroupAsbitemList = (await _customerOrgGroupDetailRepository.GetDbSetAsync())
                    .Include(x => x.Asbitem)
                    .Where(m => m.CustomerOrgGroupId == input.CustomerOrgGroupId).ToList();





                var registerAsbitem = patientRegisterEnt.RegisterCheckAsbitems; //当前登记的组合项目
                if (registerAsbitem.Any())
                {
                    //删除操作

                    List<RegisterCheckAsbitem> ReserveList = new List<RegisterCheckAsbitem>();  //保留项目
                    List<RegisterCheckAsbitem> DeleteList = new List<RegisterCheckAsbitem>();  //删除项目

                    foreach (var item in registerAsbitem)
                    {
                        //判断是否为已收费、已检、弃检

                        if (item.IsCharge == 'Y' || item.RegisterCheck.CompleteFlag != RegisterCheckCompleteFlag.UnChecked)
                        {
                            //保留
                            ReserveList.Add(item);
                        }
                        else
                        {

                            if (input.IsReserveAddAsbitem == 'Y')
                            {
                                //保留额外项目
                                if (oldGroupAsbitemList.Where(m => m.AsbitemId == item.AsbitemId).Count() == 0)
                                {
                                    //额外项目
                                    ReserveList.Add(item);
                                }
                                else
                                {
                                    DeleteList.Add(item);
                                }

                            }
                            else
                            {
                                DeleteList.Add(item);
                            }
                        }
                    }

                    await _registerCheckAsbitemRepository.DeleteManyAsync(DeleteList);

                    //遍历查询保留的项目是否存在新分组，如果存在，修改新分组的ID,然后list里面剔除项目
                    ReserveList.ForEach(reserveitem =>
                    {
                        var IsnewGroupAsbitem = newGroupAsbitemList.Find(m => m.AsbitemId == reserveitem.AsbitemId);  //项目是否存在新分组内
                        if (IsnewGroupAsbitem != null)
                        {
                            //新分组内有需要保留的项目
                            reserveitem.GroupPackageId = input.CustomerOrgGroupId;  //修改之前项目的分组ID
                                                                                    //从list里面删除新分组包含的组合项目
                            newGroupAsbitemList.Remove(IsnewGroupAsbitem);
                        }
                        else
                        {
                            reserveitem.GroupPackageId = null;  //不包含，修改为null
                        }
                    });

                    await _registerCheckAsbitemRepository.UpdateManyAsync(ReserveList);  //修改保留项目的分组
                }

                if (newGroupAsbitemList.Any())
                {
                    //需要处理的新分组下的数据   重复的已剔除

                    var newRegisterAsbitemList = newGroupAsbitemList.Select(s => new RegisterCheckAsbitem
                    {
                        Amount = 1,
                        AsbitemId = s.AsbitemId,
                        ChargePrice = s.Price,
                        GroupPackageId = input.CustomerOrgGroupId,
                        IsCharge = 'N',
                        PatientRegisterId = input.PatientRegisterId,
                        PayTypeFlag = input.PayTypeFlag,
                        StandardPrice = s.Asbitem.Price
                    }).ToList();



                    foreach (var item in newRegisterAsbitemList)
                    {
                        await _registerAsbitemManager.CreateAsync(patientRegisterEnt.MedicalCenterId, item, true);
                    }

                }

                patientRegisterEnt.CustomerOrgGroupId = input.CustomerOrgGroupId;
                await _repository.UpdateAsync(patientRegisterEnt);
            }
            else
            {
                throw new UserFriendlyException("人员不存在");
            }
        }


        #endregion

        /// <summary>
        /// 调整体检人员分组
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/patientregister/BatchUpdateCustomerOrgGroup")]
        public async Task BatchUpdateCustomerOrgGroupAsync(UpdatePatientRegisterCustomerOrgGroupDto input)
        {
            DataHelper.CheckCharIsYOrN(input.IsReserveAddAsbitem, "是否保留加做项目");
            //当前人员信息
            var patientRegisterEnt = (await _repository.GetQueryableAsync())
                .Where(m => m.Id == input.PatientRegisterId).AsNoTracking().FirstOrDefault();
            if (patientRegisterEnt == null)
            {
                throw new UserFriendlyException("人员不存在");
            }

            if (patientRegisterEnt.CustomerOrgId == GuidFlag.PersonCustomerOrgId)
            {
                throw new UserFriendlyException("个人体检不支持调整");
            }
            if (patientRegisterEnt.CompleteFlag == PatientRegisterCompleteFlag.SumCheck)
            {
                throw new UserFriendlyException("当前体检人员已完成总检");
            }
            if (patientRegisterEnt.CustomerOrgGroupId == input.CustomerOrgGroupId)
            {
                throw new UserFriendlyException("当前体检人员已在此分组");
            }

            //原有分组下的组合项目

            var oldGroupAsbitemList = (await _customerOrgGroupDetailRepository.GetQueryableAsync())
                .Include(x => x.Asbitem)
                .Where(m => m.CustomerOrgGroupId == patientRegisterEnt.CustomerOrgGroupId).ToList();

            //需要调整的分组包含的组合项目

            var newGroupAsbitemList = (await _customerOrgGroupDetailRepository.GetQueryableAsync())
                .Include(x => x.Asbitem)
                .Where(m => m.CustomerOrgGroupId == input.CustomerOrgGroupId).ToList();

            if (newGroupAsbitemList.Count() == 0)
            {
                throw new UserFriendlyException("分组没有分配组合项目");
            }
            //删除属于原分组而不属于新分组的项目
            var existRegisterChecks = (await _registerCheckRepository.GetQueryableAsync()).Where(o => o.PatientRegisterId == input.PatientRegisterId).AsNoTracking().ToList();
            var existRegisterAsbitems = (await _registerCheckAsbitemRepository.GetQueryableAsync()).Where(o =>
                 existRegisterChecks.Select(x => x.Id).Contains(o.RegisterCheckId)).AsNoTracking().ToList();
            for (var i = existRegisterAsbitems.Count - 1; i >= 0; i--)
            {
                if (oldGroupAsbitemList.Where(o => o.AsbitemId == existRegisterAsbitems[i].AsbitemId).Count() > 0)
                {
                    if (newGroupAsbitemList.Where(o => o.AsbitemId == existRegisterAsbitems[i].AsbitemId).Count() == 0)
                    {
                        existRegisterAsbitems.RemoveAt(i);
                    }
                }
            }
            //如果不保留加做的组合项目则删除不属于新分组的项目
            if (input.IsReserveAddAsbitem != 'Y')
            {
                for (var i = existRegisterAsbitems.Count - 1; i >= 0; i--)
                {

                    if (newGroupAsbitemList.Where(o => o.AsbitemId == existRegisterAsbitems[i].AsbitemId).Count() == 0)
                    {
                        existRegisterAsbitems.RemoveAt(i);
                    }

                }
            }
            //加入新分组中的项目
            foreach (var groupAsbitem in newGroupAsbitemList)
            {
                if (existRegisterAsbitems.Where(o => o.AsbitemId == groupAsbitem.AsbitemId).Count() == 0)
                {
                    var asbitem = await _cacheService.GetAsbitemAsync(groupAsbitem.AsbitemId);
                    var newRegisterCheckAsbitem = new RegisterCheckAsbitem()
                    {
                        AsbitemId = groupAsbitem.AsbitemId,
                        Amount = groupAsbitem.Amount,
                        StandardPrice = asbitem.Price,
                        ChargePrice = groupAsbitem.Price,
                        PayTypeFlag = input.PayTypeFlag,
                        IsCharge = 'N'

                    };
                    existRegisterAsbitems.Add(newRegisterCheckAsbitem);
                }

            }
            patientRegisterEnt.CustomerOrgGroupId = input.CustomerOrgGroupId;
            await _manager.SetCustomerOrgGroupId(patientRegisterEnt, input.CustomerOrgGroupId);
            await _repository.UpdateAsync(patientRegisterEnt);
            var createRegisterCheckAsbitemEntity = await _registerAsbitemManager.UpdateManyAsync(patientRegisterEnt, existRegisterAsbitems);

            if (createRegisterCheckAsbitemEntity != null)
            {
                await UpdateRegisterChecks(createRegisterCheckAsbitemEntity);

            }

            await CurrentUnitOfWork.SaveChangesAsync();

        }


        #region 登记完返回的数据

        private async Task<PatientRegisterOrNoDto> GetPatientRegisterOrNo(Guid PatientRegisterId)
        {
            // var entold = await _repository.GetAsync(PatientRegisterId);
            var ent = (await _repository.GetQueryableAsync()).Include(x => x.Patient).Where(m => m.Id == PatientRegisterId).FirstOrDefault();

            // var entold = await _repository.FindAsync(m=>m.Id== PatientRegisterId);

            var entdto = new PatientRegisterOrNoDto();
            if (ent != null)
            {
                entdto = new PatientRegisterOrNoDto
                {
                    HisPatientId = ent.HisPatientId,
                    Age = ent.Age,
                    AuditDate = DataHelper.ConversionDateToString(ent.AuditDate),
                    Id = ent.Id,
                    AuditDoctorId = ent.AuditDoctorId,
                    BirthDate = DataHelper.ConversionDateToString(ent.BirthDate),
                    CompleteFlag = ent.CompleteFlag,
                    CreationTime = ent.CreationTime,
                    CreatorId = ent.CreatorId,
                    CustomerOrgGroupId = ent.CustomerOrgGroupId,
                    CustomerOrgId = ent.CustomerOrgId,
                    CustomerOrgRegisterId = ent.CustomerOrgRegisterId,
                    GuidePrintTimes = ent.GuidePrintTimes,
                    InterposeMeasure = ent.InterposeMeasure,
                    IsAudit = ent.IsAudit,
                    IsLock = ent.IsLock,
                    IsMedicalStart = ent.IsMedicalStart,
                    IsNameHide = ent.IsNameHide,
                    IsPhoneFollow = ent.IsPhoneFollow,
                    IsRecoverGuide = ent.IsRecoverGuide,
                    IsUpload = ent.IsUpload,
                    IsVip = ent.IsVip,
                    JobCardNo = ent.JobCardNo,
                    JobPost = ent.JobPost,
                    JobTitle = ent.JobTitle,
                    LastModificationTime = ent.LastModificationTime,
                    LastModifierId = ent.LastModifierId,
                    MaritalStatusId = ent.MaritalStatusId,
                    MedicalCardNo = ent.MedicalCardNo,
                    MedicalConclusionId = ent.MedicalConclusionId,
                    MedicalPackageId = ent.MedicalPackageId,
                    MedicalStartDate = DataHelper.ConversionDateToString(ent.MedicalStartDate),
                    MedicalTimes = ent.MedicalTimes,
                    MedicalTypeId = ent.MedicalTypeId,
                    MedicalCenterId = ent.MedicalCenterId,
                    PatientId = ent.PatientId,
                    PatientName = ent.PatientName,
                    PatientRegisterNo = ent.PatientRegisterNo,
                    PersonnelTypeId = ent.PersonnelTypeId,
                    Photo = ent.Photo,
                    Remark = ent.Remark,
                    ReportPrintTimes = ent.ReportPrintTimes,
                    Salesman = ent.Salesman,
                    SexHormoneTermId = ent.SexHormoneTermId,
                    SexId = ent.SexId,
                    SummaryDate = DataHelper.ConversionDateToString(ent.SummaryDate),
                    SummaryDoctorId = ent.SummaryDoctorId,
                    ThirdInfo = ent.ThirdInfo,
                    CreatorName = _cacheService.GetSurnameAsync(ent.CreatorId).GetAwaiter().GetResult(),
                    LastModifierName = _cacheService.GetSurnameAsync(ent.LastModifierId).GetAwaiter().GetResult(),
                    Address = ent.Patient.Address,  //档案表信息
                    BirthPlaceId = ent.Patient.BirthPlaceId,
                    DisplayName = ent.Patient.DisplayName,
                    Email = ent.Patient.Email,
                    IdNo = ent.Patient.IdNo,
                    MobileTelephone = ent.Patient.MobileTelephone,
                    NationId = ent.Patient.NationId,
                    PatientNo = ent.Patient.PatientNo,
                    PatientPassword = ent.Patient.PatientPassword,
                    PostalCode = ent.Patient.PostalCode,
                    Telephone = ent.Patient.Telephone,
                    CustomerOrgName = _cacheService.GetCustomerOrgNameAsync(ent.CustomerOrgId).GetAwaiter().GetResult(),
                    CustomerOrgParentName = _cacheService.GetTopCustomerOrgNameAsync(ent.CustomerOrgId).GetAwaiter().GetResult(),
                    CustomerOrgParentId = _cacheService.GetTopCustomerOrgIdAsync(ent.CustomerOrgId).GetAwaiter().GetResult(),
                    IsPatientOccupationalDisease = _patientOccupationalDiseaseManager.GetPatientRegisterIsOccupationalDisease(ent.Id).GetAwaiter().GetResult()
                };
                var registerCheckAsbitems = (await _registerCheckAsbitemRepository.GetQueryableAsync())
              .Include(x => x.Asbitem)
              .Include(x => x.Asbitem.ItemType)
              .Include(x => x.RegisterCheck)
            .Where(m => m.PatientRegisterId == PatientRegisterId).ToList().OrderByDescending(o => o.GroupPackageId).ThenBy(o => o.Asbitem.DisplayOrder);


                entdto.RegisterCheckAsbitems = registerCheckAsbitems.Select(s => new RegisterCheckAsbitemOrAsbitemDto
                {
                    Discount = s.StandardPrice == 0 ? 100 : Math.Round(Convert.ToDecimal(s.ChargePrice * 100 / s.StandardPrice), 2),
                    IsLock = s.RegisterCheck.IsLock,
                    CreationTime = s.CreationTime,
                    CreatorId = s.CreatorId,
                    Id = s.Id,
                    LastModificationTime = s.LastModificationTime,
                    LastModifierId = s.LastModifierId,
                    Amount = s.Amount,
                    AsbitemId = s.AsbitemId,
                    AsbitemName = s.Asbitem.DisplayName,
                    ChargePrice = s.ChargePrice,
                    IsBelongGroupPackage = 'N',
                    //GroupPackageId = s.GroupPackageId,
                    CheckCompleteFlag = s.RegisterCheck.CompleteFlag,
                    DeviceTypeName = s.Asbitem.DeviceTypeId != null ? _cacheService.GetDeviceTypeNameAsync(s.Asbitem.DeviceTypeId.Value).Result : "",
                    IsCharge = s.IsCharge,
                    ItemTypeName = s.Asbitem.ItemType.DisplayName,
                    LisRequestId = s.LisRequestId,
                    PatientRegisterId = s.PatientRegisterId,
                    PayTypeFlag = s.PayTypeFlag,
                    SexName = _cacheService.GetForSexNameAsync(s.Asbitem.ForSexId).Result,
                    StandardPrice = s.StandardPrice,
                    CreatorName = _cacheService.GetSurnameAsync(s.CreatorId).Result,
                    LastModifierName = _cacheService.GetSurnameAsync(s.LastModifierId).Result
                }).ToList();
                //设置GroupPackageId
                if (entdto.CustomerOrgGroupId != null && entdto.CustomerOrgGroupId != Guid.Empty)
                {
                    var groupDetails = (await _customerOrgGroupDetailRepository.GetQueryableAsync()).Where(o => o.CustomerOrgGroupId == entdto.CustomerOrgGroupId).ToList();
                    entdto.RegisterCheckAsbitems.ForEach(o =>
                    {
                        if (groupDetails.Where(x => x.AsbitemId == o.AsbitemId).Count() > 0)
                        {
                            o.IsBelongGroupPackage = 'Y';
                        }
                    });
                }
                else if (entdto.MedicalPackageId != null && entdto.MedicalPackageId != Guid.Empty)
                {
                    var groupDetails = (await _medicalPackageDetailRepository.GetQueryableAsync()).Where(o => o.MedicalPackageId == entdto.MedicalPackageId).ToList();
                    entdto.RegisterCheckAsbitems.ForEach(o =>
                    {
                        if (groupDetails.Where(x => x.AsbitemId == o.AsbitemId).Count() > 0)
                        {
                            o.IsBelongGroupPackage = 'Y';
                        }
                    });
                }
                entdto.RegisterCheckAsbitems = entdto.RegisterCheckAsbitems.OrderByDescending(o => o.IsBelongGroupPackage).
                    OrderBy(o => o.Id).ToList();


                #region 扩展信息


                var patientRegisterExterEnt = await _patientRegisterExterRepository.FirstOrDefaultAsync(m => m.PatientRegisterId == PatientRegisterId);
                if (patientRegisterExterEnt != null)
                {
                    entdto.QztlIsCw = patientRegisterExterEnt.QztlIsCw;
                    entdto.QztlIsCy = patientRegisterExterEnt.QztlIsCy;
                    entdto.QztlIsFj = patientRegisterExterEnt.QztlIsFj;
                    entdto.QztlIsGt = patientRegisterExterEnt.QztlIsGt;
                    entdto.QztlIsMain = patientRegisterExterEnt.QztlIsMain;
                    entdto.QztlIsWh = patientRegisterExterEnt.QztlIsWh;
                    entdto.QztlType = patientRegisterExterEnt.QztlType;
                    entdto.Remark2 = patientRegisterExterEnt.Remark2;
                    entdto.Remark3 = patientRegisterExterEnt.Remark3;
                    entdto.Remark4 = patientRegisterExterEnt.Remark4;
                    entdto.UploadQztlFlag = patientRegisterExterEnt.UploadQztlFlag;
                    entdto.IsQztlImport = patientRegisterExterEnt.IsQztlImport;
                    entdto.Planuserid = patientRegisterExterEnt.Planuserid;
                }

                #endregion
            }
            return entdto;
        }

        #endregion


        #region 收费、退费、未收费
        /// <summary>
        /// 收费
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/patientregister/getpatientregisterchargelist")]
        public async Task<PagedResultDto<GetPatientRegisterChargeListDto>> GetPatientRegisterChargeListAsync(PatientRegisterChargeRequestDto input)
        {
            PatientRegisterChargeEfCoreDto patientRegisterChargeEfCoreDto = new PatientRegisterChargeEfCoreDto
            {
                EndDate = input.EndDate,
                InvoiceNo = input.InvoiceNo,
                PatientName = input.PatientName,
                PatientNo = input.PatientNo,
                PatientRegisterNo = input.PatientRegisterNo,
                StartDate = input.StartDate
            };
            var patientRegisterChargeList = await _patientRegisterChargeRepository.GetPatientRegisterChargeListAsync(patientRegisterChargeEfCoreDto);

            int totalCount = patientRegisterChargeList.Count;

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


            return new PagedResultDto<GetPatientRegisterChargeListDto>(totalCount, patientRegisterChargeList);

        }



        /// <summary>
        /// 未收费
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/patientregister/getpatientregisternotchargedlist")]
        public async Task<PagedResultDto<GetPatientRegisterNotChargedListDto>> GetPatientRegisterNotChargedListAsync(PatientRegisterChargeRequestDto input)
        {

            var query = from patientRegister in await _repository.GetQueryableAsync()
                        join patient in await _patientRepository.GetQueryableAsync() on patientRegister.PatientId equals patient.Id
                        join registerCheck in await _registerCheckRepository.GetQueryableAsync() on patientRegister.Id equals registerCheck.PatientRegisterId
                        join registerCheckAsbitem in await _registerCheckAsbitemRepository.GetQueryableAsync() on registerCheck.Id equals registerCheckAsbitem.RegisterCheckId
                        where registerCheckAsbitem.IsCharge == 'N' && registerCheckAsbitem.PayTypeFlag == PayTypeFlag.PersonPay
                        orderby patientRegister.Id ascending
                        select new
                        {
                            patientRegister,
                            patient
                        };

            if (!string.IsNullOrEmpty(input.StartDate) && !string.IsNullOrEmpty(input.EndDate))
            {
                query = query.Where(m => m.patientRegister.CreationTime >= Convert.ToDateTime(input.StartDate) &&
              m.patientRegister.CreationTime < Convert.ToDateTime(input.EndDate).AddDays(1));
            }
            if (!string.IsNullOrEmpty(input.PatientName))
            {
                query = query.Where(m => !string.IsNullOrEmpty(m.patientRegister.PatientName) && m.patientRegister.PatientName.Contains(input.PatientName));
            }
            if (!string.IsNullOrEmpty(input.PatientNo))
            {
                query = query.Where(m => m.patient.PatientNo == input.PatientNo);
            }
            if (!string.IsNullOrEmpty(input.PatientRegisterNo))
            {
                query = query.Where(m => m.patientRegister.PatientRegisterNo == input.PatientRegisterNo);
            }

            var patientRegisterGroup = query.ToList().GroupBy(g => g.patientRegister);

            int totalCount = patientRegisterGroup.Count();

            patientRegisterGroup = patientRegisterGroup.Skip(input.SkipCount * input.MaxResultCount).Take(input.MaxResultCount);

            var entListDto = patientRegisterGroup.ToList().Select(s => new GetPatientRegisterNotChargedListDto
            {
                PatientRegisterId = s.Key.Id,
                Address = s.FirstOrDefault().patient.Address,
                Age = s.Key.Age,
                CustomerOrgName = _cacheService.GetCustomerOrgAsync(s.Key.CustomerOrgId).GetAwaiter().GetResult().DisplayName,
                CustomerOrgParentName = _cacheService.GetTopCustomerOrgAsync(s.Key.CustomerOrgId).GetAwaiter().GetResult().DisplayName,
                Email = s.FirstOrDefault().patient.Email,
                IdNo = s.FirstOrDefault().patient.IdNo,
                IsVip = s.Key.IsVip,
                MedicalTimes = s.Key.MedicalTimes,
                MobileTelephone = s.FirstOrDefault().patient.MobileTelephone,
                PatientName = s.Key.PatientName,
                PatientNo = s.FirstOrDefault().patient.PatientNo,
                PatientRegisterNo = s.Key.PatientRegisterNo,
                Salesman = s.Key.Salesman,
                SexId = _cacheService.GetSexNameAsync(s.Key.SexId).GetAwaiter().GetResult(),
                Telephone = s.FirstOrDefault().patient.Telephone
            }).ToList();

            return new PagedResultDto<GetPatientRegisterNotChargedListDto>(totalCount, entListDto);
            //PatientRegisterChargeEfCoreDto patientRegisterChargeEfCoreDto = new PatientRegisterChargeEfCoreDto
            //{
            //    EndDate = input.EndDate,
            //    InvoiceNo = input.InvoiceNo,
            //    PatientName = input.PatientName,
            //    PatientNo = input.PatientNo,
            //    PatientRegisterNo = input.PatientRegisterNo,
            //    StartDate = input.StartDate
            //};
            //var patientRegisterNotChargedList = await _patientRegisterChargeRepository.GetPatientRegisterNotChargedListAsync(patientRegisterChargeEfCoreDto);

            //int totalCount = patientRegisterNotChargedList.Count;

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


            //return new PagedResultDto<GetPatientRegisterNotChargedListDto>(totalCount, patientRegisterNotChargedList);
        }

        /// <summary>
        /// 退费
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/patientregister/getpatientregisterchargebacklist")]
        public async Task<PagedResultDto<GetPatientRegisterChargeBackListDto>> GetPatientRegisterChargeBackListAsync(PatientRegisterChargeRequestDto input)
        {
            PatientRegisterChargeEfCoreDto patientRegisterChargeEfCoreDto = new PatientRegisterChargeEfCoreDto
            {
                EndDate = input.EndDate,
                InvoiceNo = input.InvoiceNo,
                PatientName = input.PatientName,
                PatientNo = input.PatientNo,
                PatientRegisterNo = input.PatientRegisterNo,
                StartDate = input.StartDate
            };
            var patientRegisterChargeBackList = await _patientRegisterChargeRepository.GetPatientRegisterChargeBackListAsync(patientRegisterChargeEfCoreDto);

            int totalCount = patientRegisterChargeBackList.Count;

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


            return new PagedResultDto<GetPatientRegisterChargeBackListDto>(totalCount, patientRegisterChargeBackList);
        }

        #endregion

        #region 查询体检人员项目情况
        /// <summary>
        /// 查询体检人员的项目状况
        /// </summary>
        /// <returns></returns>
        [HttpGet("api/app/patientregister/getpatientregisteritemstatus")]
        public async Task<GetPatientRegisterItemStatusDto> GetPatientRegisterItemStatusAsync(Guid PatientRegisterId)
        {
            //未检组合项目
            var UnCheckedAsbitem = (await _registerCheckAsbitemRepository.GetQueryableAsync())
                .Include(x => x.Asbitem)
                .Include(x => x.RegisterCheck)
                .Where(m => m.PatientRegisterId == PatientRegisterId
                && m.RegisterCheck.CompleteFlag == RegisterCheckCompleteFlag.UnChecked
                && m.Asbitem.IsCheck == 'Y')
                .OrderBy(o => o.Asbitem.DisplayOrder).Select(s => s.Asbitem.DisplayName).ToList();

            //弃检检组合项目
            var GiveUpAsbitem = (await _registerCheckAsbitemRepository.GetQueryableAsync())
              .Include(x => x.Asbitem)
              .Include(x => x.RegisterCheck)
              .Where(m => m.PatientRegisterId == PatientRegisterId && m.RegisterCheck.CompleteFlag == RegisterCheckCompleteFlag.GiveUpChecked).OrderBy(o => o.Asbitem.DisplayOrder).Select(s => s.Asbitem.DisplayName).ToList();


            //组合项目已检，项目无明细的项目
            var registerAsbItemQueryable = await _registerCheckAsbitemRepository.GetQueryableAsync();
            var registerCheckQueryable = await _registerCheckRepository.GetQueryableAsync();
            var registerCheckItemQueryable = await _registerCheckItemRepository.GetQueryableAsync();
            var itemQueryable = await _itemRepository.GetQueryableAsync();

            var checkedNullValueItem = (from a in registerCheckItemQueryable
                                        join b in registerCheckQueryable on a.RegisterCheckId equals b.Id
                                        join d in itemQueryable on a.ItemId equals d.Id into dd
                                        from ad in dd.DefaultIfEmpty()
                                        where (b.PatientRegisterId == PatientRegisterId && string.IsNullOrEmpty(a.Result) && b.CompleteFlag == RegisterCheckCompleteFlag.Checked)
                                        orderby ad.DisplayOrder ascending
                                        select new { ItemName = ad.DisplayName }).Select(s => s.ItemName).ToList();

            //组合项目已检，项目弃检

            var checkedGiveUpItem = (from a in registerCheckItemQueryable
                                     join b in registerCheckQueryable on a.RegisterCheckId equals b.Id
                                     join c in registerAsbItemQueryable on b.Id equals c.RegisterCheckId
                                     join d in itemQueryable on a.ItemId equals d.Id into dd
                                     from ad in dd.DefaultIfEmpty()
                                     where (c.PatientRegisterId == PatientRegisterId && b.CompleteFlag == RegisterCheckCompleteFlag.Checked && !string.IsNullOrEmpty(a.Result) && a.Result.Contains("放弃检查"))
                                     orderby ad.DisplayOrder ascending
                                     select new { ItemName = ad.DisplayName }).Select(s => s.ItemName).ToList();

            var entdto = new GetPatientRegisterItemStatusDto
            {
                GiveUpAsbitem = GiveUpAsbitem,
                CheckedGiveUpItem = checkedGiveUpItem,
                CheckedNullValueItem = checkedNullValueItem,
                UnCheckedAsbitem = UnCheckedAsbitem
            };

            return entdto;

        }

        #endregion

        #region 批量修改人员状态、体检日期 

        /// <summary>
        /// 批量修改人员状态、体检日期    可以同时修改状态跟日期   也可以单独修改某一个  不用修改的传 null
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        [HttpPost("api/app/patientregister/updatepatientregistercompleteflagormedicalstartdate")]
        public async Task UpdatePatientRegisterCompleteFlagOrMedicalStartDateAsync(UpdatePatientRegisterCompleteFlagOrMedicalStartDateDto input)
        {

            if (input.PatientRegisterIds.Any())
            {


                var patientRegisterList = await _repository.GetListAsync(m => input.PatientRegisterIds.Contains(m.Id) &&
                (m.CompleteFlag == PatientRegisterCompleteFlag.PreRegistration || m.CompleteFlag == PatientRegisterCompleteFlag.Registration));

                if (input.CompleteFlag != PatientRegisterCompleteFlag.PreRegistration && input.CompleteFlag != PatientRegisterCompleteFlag.Registration)
                {
                    throw new UserFriendlyException("登记状态只能是预登记或正式登记");
                }


                patientRegisterList.ForEach(f =>
                    {
                        if (f.CompleteFlag == PatientRegisterCompleteFlag.PreRegistration
                        && input.CompleteFlag == PatientRegisterCompleteFlag.Registration)
                        {
                            f.MedicalStartDate = DateTime.Now;
                            f.IsMedicalStart = 'Y';
                            if (f.PatientRegisterNo.StartsWith("P"))
                            {
                                f.PatientRegisterNo = _manager.CreatePatientRegisterNo(f.MedicalCenterId).Result;
                            }
                            #region 预登记转正式登记修改登记者ID

                            string goRegisterIsUpdateRegisterPerson = _sysParmValueManager.GetSysParmValueAsync(Guid.Empty, "go_register_is_update_register_person").GetAwaiter().GetResult();
                            if (goRegisterIsUpdateRegisterPerson == "1")
                            {
                                if (_currentUser.Id != null)
                                {
                                    //判断是预登记转正式登记
                                    f.UpdateCreatorId(_currentUser.Id.Value);
                                }
                            }

                            #endregion
                        }
                        f.CompleteFlag = input.CompleteFlag.Value;
                    }
                );


                if (!string.IsNullOrEmpty(input.MedicalStartDate))
                {
                    patientRegisterList.ForEach(f => f.MedicalStartDate = PageHelper.ConvertDatetimeV(input.MedicalStartDate));

                }


                await _repository.UpdateManyAsync(patientRegisterList);


            }
            else
            {
                throw new UserFriendlyException("参数有误");
            }

        }

        #endregion

        /// <summary>
        /// 修改体检日期
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/PatientRegister/UpdatePatientRegisterMedicalStartDate")]
        public async Task UpdatePatientRegisterMedicalStartDateAsync(UpdatePatientRegisterMedicalStartDateInputDto input)
        {
            if (!input.PatientRegisterIds.Any())
            {
                throw new UserFriendlyException("请选择人员");
            }


            var patientRegisterList = await _repository.GetListAsync(m => input.PatientRegisterIds.Contains(m.Id));

            if (!string.IsNullOrEmpty(input.MedicalStartDate))
            {
                patientRegisterList.ForEach(f => f.MedicalStartDate = PageHelper.ConvertDatetimeV(input.MedicalStartDate));

                await _repository.UpdateManyAsync(patientRegisterList);

            }

        }


        /// <summary>
        /// 修改人员 手机、姓名、身份证   已总检特殊情况修改
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/PatientRegister/UpdatePatientRegisterBaseInfoByPatientRegisterId")]
        public async Task<PatientRegisterOrNoDto> UpdatePatientRegisterBaseInfoByPatientRegisterIdAsync(UpdatePatientRegisterBaseInfoByPatientRegisterIdInputDto input)
        {
            PatientRegisterOrNoDto msg = new PatientRegisterOrNoDto();

            if (input == null ||
                string.IsNullOrWhiteSpace(input.IdNo)
                && string.IsNullOrWhiteSpace(input.PatientName)
                && string.IsNullOrWhiteSpace(input.MobileTelephone))
                throw new UserFriendlyException("请求参数有误");

            var patientRegisterEnt = await _repository.FirstOrDefaultAsync(f => f.Id == input.PatientRegisterId);
            if (patientRegisterEnt == null)
            {
                throw new UserFriendlyException("人员ID不正确");
            }

            var patientEnt = await _patientRepository.FirstOrDefaultAsync(f => f.Id == patientRegisterEnt.PatientId);
            if (patientEnt != null)
            {
                if (!string.IsNullOrWhiteSpace(input.PatientName))
                {
                    patientEnt.DisplayName = input.PatientName;
                    patientRegisterEnt.PatientName = input.PatientName;
                }
                if (!string.IsNullOrWhiteSpace(input.IdNo))
                {
                    patientEnt.IdNo = input.IdNo;
                }
                if (!string.IsNullOrWhiteSpace(input.MobileTelephone))
                {
                    patientEnt.MobileTelephone = input.MobileTelephone;
                }

                await _patientRepository.UpdateAsync(patientEnt, true);
                await _repository.UpdateAsync(patientRegisterEnt, true);
            }

            msg = await GetPatientRegisterOrNo(patientRegisterEnt.Id);
            return msg;
        }

        private async Task UpdateRegisterChecks(CreateRegisterCheckAsbitemEntity createRegisterCheckAsbitemEntity)
        {
            if (createRegisterCheckAsbitemEntity == null)
            {
                throw new UserFriendlyException("createRegisterCheckAsbitemEntity未赋值");
            }

            await _registerCheckItemRepository.DeleteManyAsync(createRegisterCheckAsbitemEntity.DeleteRegisterCheckItems);
            await _registerCheckAsbitemRepository.DeleteManyAsync(createRegisterCheckAsbitemEntity.DeleteRegisterCheckAsbitems);
            await _registerCheckRepository.DeleteManyAsync(createRegisterCheckAsbitemEntity.DeleteRegisterChecks);

            await _registerCheckItemRepository.UpdateManyAsync(createRegisterCheckAsbitemEntity.UpdateRegisterCheckItems);
            await _registerCheckAsbitemRepository.UpdateManyAsync(createRegisterCheckAsbitemEntity.UpdateRegisterCheckAsbitems);
            await _registerCheckRepository.UpdateManyAsync(createRegisterCheckAsbitemEntity.UpdateRegisterChecks);

            await _registerCheckRepository.InsertManyAsync(createRegisterCheckAsbitemEntity.NewRegisterChecks);
            await _registerCheckAsbitemRepository.InsertManyAsync(createRegisterCheckAsbitemEntity.NewRegisterCheckAsbitems);
            await _registerCheckItemRepository.InsertManyAsync(createRegisterCheckAsbitemEntity.NewRegisterCheckItems);
        }

        private async Task<char> GetMaritalStatusIdByName(string name)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                return MaritalStatusFlag.UnKnown;
            }
            var entity = await _maritalStatusRepository.FirstOrDefaultAsync(m => m.DisplayName == name.Trim());
            if (entity != null)
            {
                return entity.Id;
            }
            else
            {
                throw new UserFriendlyException($"{name}是无效婚姻状况名称");
            }

        }

        private async Task<Guid?> GetBirthPlaceIdByName(string name)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                return null;
            }
            var entity = await _birthPlaceRepository.FirstOrDefaultAsync(m => m.DisplayName == name.Trim());
            if (entity != null)
            {
                return entity.Id;
            }
            else
            {
                throw new UserFriendlyException($"{name}是无效出生地名称");
            }

        }

        private async Task<string> GetNationIdByName(string name)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                return null;
            }
            var entity = await _nationRepository.FirstOrDefaultAsync(m => m.DisplayName == name.Trim());
            if (entity != null)
            {
                return entity.Id;
            }
            else
            {
                throw new UserFriendlyException($"{name}是无效民族名称");
            }

        }

        private async Task<char> GetSexIdByName(string name)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                return SexFlag.UnKnown;
            }
            var entity = await _sexRepository.FirstOrDefaultAsync(m => m.DisplayName == name.Trim());
            if (entity != null)
            {
                return entity.Id;
            }
            else
            {
                throw new UserFriendlyException($"{name}是无效性别名称");
            }

        }

        private async Task<Guid?> GetMedicalTypeIdByName(string name)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                return null;
            }
            var entity = await _medicalTypeRepository.FirstOrDefaultAsync(m => m.DisplayName == name.Trim());
            if (entity != null)
            {
                return entity.Id;
            }
            else
            {
                throw new UserFriendlyException($"{name}是无效体检类别名称");
            }

        }

        private async Task<Guid?> GetPersonnelTypeIdByName(string name)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                return null;
            }
            var entity = await _personnelTypeRepository.FirstOrDefaultAsync(m => m.DisplayName == name.Trim());
            if (entity != null)
            {
                return entity.Id;
            }
            else
            {
                throw new UserFriendlyException($"{name}是无效人员类别名称");
            }

        }
        private async Task<Guid?> GetCustomerOrgIdByName(Guid customerOrgId, string name, char IsAutoCreateDepartment = 'N')
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                return null;
            }
            if (customerOrgId == Guid.Empty)
            {
                throw new UserFriendlyException($"单位不能为空");
            }
            var departmentent = await _customerOrgRepository.FirstOrDefaultAsync(m => m.ParentId == customerOrgId && m.DisplayName == name); //当前单位下一级
            if (departmentent != null)
            {
                return departmentent.Id;  //找到部门，单位ID为下级的部门ID
            }
            if (IsAutoCreateDepartment != 'Y')
            {
                throw new UserFriendlyException($"{name}是无效部门名称");
            }
            var parentCustomerOrgEnt = await _customerOrgRepository.FirstOrDefaultAsync(m => m.Id == customerOrgId); //当前单位
            if (parentCustomerOrgEnt == null)
            {
                throw new UserFriendlyException($"根据单位ID未找到单位");
            }
            var customerOrg_Insert = new CustomerOrg
            {
                Accounts = parentCustomerOrgEnt.Accounts,
                Address = parentCustomerOrgEnt.Address,
                Bank = parentCustomerOrgEnt.Bank,
                DisplayName = name,
                Fax = parentCustomerOrgEnt.Fax,
                InvoiceName = parentCustomerOrgEnt.InvoiceName,
                IsActive = parentCustomerOrgEnt.IsActive,
                IsLock = parentCustomerOrgEnt.IsLock,
                MedicalCenterId = parentCustomerOrgEnt.MedicalCenterId,
                OrgTypeId = parentCustomerOrgEnt.OrgTypeId,
                ParentId = parentCustomerOrgEnt.Id,
                PostalCode = parentCustomerOrgEnt.PostalCode,
                Remark = parentCustomerOrgEnt.Remark,
                ShortName = name.Length > 20 ? "" : name,
                Telephone = parentCustomerOrgEnt.Telephone
            };

            var DepartmentEnt = await _customerOrgManager.CreateAsync(customerOrg_Insert);

            var DepartmentReturn = await _customerOrgRepository.InsertAsync(DepartmentEnt, true);

            return DepartmentReturn.Id;
        }

        private async Task<Guid?> GetCustomerOrgGroupIdByName(Guid customerOrgRegisterId, string name)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                return null;
            }
            var CustomerOrgGroupEnt = await _customerOrgGroupRepository.FirstOrDefaultAsync(m => m.DisplayName == name && m.CustomerOrgRegisterId == customerOrgRegisterId);
            if (CustomerOrgGroupEnt == null)
            {
                throw new UserFriendlyException($"{name}是无效分组名称");
            }
            return CustomerOrgGroupEnt.Id;

        }
        private DateTime? GetBirthDateByString(string name)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                return null;
            }
            if (DateTime.TryParse(name, out var date))
            {
                return date;
            }
            return null;

        }
    }
}