using Microsoft.EntityFrameworkCore;
using NPOI.POIFS.Crypt.Dsig;
using Shentun.Peis.CustomerOrgRegisters;
using Shentun.Peis.CustomerOrgs;
using Shentun.Peis.Enums;
using Shentun.Peis.HelperDto;
using Shentun.Peis.Models;
using Shentun.Peis.OrganizationUnits;
using Shentun.Peis.Patients;
using Shentun.Peis.RegisterAsbitems;
using Shentun.Peis.RegisterCheckCriticalValues;
using Shentun.Peis.RegisterCheckItems;
using Shentun.Peis.RegisterCheckPictures;
using Shentun.Peis.RegisterChecks;
using Shentun.Peis.RegisterCheckSuggestions;
using Shentun.Peis.RegisterCheckSummarys;
using Shentun.Peis.SysParmValues;
using Shentun.Utilities;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Domain.Services;
using Volo.Abp.Guids;
using Volo.Abp.Users;

namespace Shentun.Peis.PatientRegisters
{

    /// <summary>
    /// 人员体检登记
    /// </summary>
    public class PatientRegisterManager : DomainService
    {
        private readonly IRepository<PatientRegister, Guid> _repository;

        private readonly IRepository<CustomerOrg, Guid> _customerOrgRepository;
        private readonly IRepository<CustomerOrgRegister, Guid> _customerOrgRegisterRepository;
        private readonly IRepository<CustomerOrgGroup, Guid> _customerOrgGroupRepository;
        private readonly IRepository<MedicalType, Guid> _medicalTypeRepository;
        private readonly IRepository<PersonnelType, Guid> _personnelTypeRepository;
        private readonly IRepository<MedicalPackage, Guid> _medicalPackageRepository;
        private readonly IRepository<MedicalConclusion, Guid> _medicalConclusionRepository;
        private readonly IRepository<SexHormoneTerm, Guid> _sexHormoneTermRepository;
        private readonly IRepository<PrimarykeyBuilder> _primarykeyBuilderRepository;
        private readonly IRepository<Patient, Guid> _patientRepository;
        private readonly IRepository<RegisterCheckAsbitem, Guid> _registerAsbitemRepository;
        private readonly IRepository<RegisterCheck, Guid> _registerCheckRepository;
        private readonly IRepository<RegisterCheckCriticalValue, Guid> _registerCheckCriticalValueRepository;
        private readonly IRepository<RegisterCheckItem> _registerCheckItemRepository;
        private readonly CurrentUser _currentUser;
        private readonly PeisOrganizationUnitManager _peisOrganizationUnitManager;
        private readonly PatientManager _patientManager;
        private readonly RegisterCheckAsbitemManager _registerAsbitemManager;
        private readonly CustomerOrgManager _customerOrgManager;
        private readonly CustomerOrgRegisterManager _customerOrgRegisterManager;
        private readonly RegisterCheckSuggestionManager _registerCheckSuggestionManager;
        private readonly RegisterCheckSummaryManager _registerCheckSummaryManager;
        private readonly RegisterCheckPictureManager _registerCheckPictureManager;
        private readonly RegisterCheckItemManager _registerCheckItemManager;
        private readonly RegisterCheckCriticalValueManager _registerCheckCriticalValueManager;
        private readonly RegisterCheckManager _registerCheckManager;
        private readonly IRepository<SysParmValue> _sysParmValueRepository;
        private readonly IGuidGenerator _guidGenerator;
        private readonly SysParmValueManager _sysParmValueManager;
        public PatientRegisterManager(
            IRepository<PatientRegister, Guid> repository,
            IRepository<CustomerOrgRegister, Guid> customerOrgRegisterRepository,
            IRepository<CustomerOrgGroup, Guid> customerOrgGroupRepository,
            IRepository<MedicalType, Guid> medicalTypeRepository,
            IRepository<PersonnelType, Guid> personnelTypeRepository,
            IRepository<MedicalPackage, Guid> medicalPackageRepository,
            IRepository<MedicalConclusion, Guid> medicalConclusionRepository,
            IRepository<SexHormoneTerm, Guid> sexHormoneTermRepository,
            IRepository<SysParmValue> sysParmValueRepository,
            IRepository<CustomerOrg, Guid> customerOrgRepository,
            IRepository<PrimarykeyBuilder> primarykeyBuilderRepository,
            IRepository<Patient, Guid> patientRepository,
            IRepository<RegisterCheckAsbitem, Guid> registerAsbitemRepository,
            IRepository<RegisterCheck, Guid> registerCheckRepository,
            IRepository<RegisterCheckCriticalValue, Guid> registerCheckCriticalValueRepository,
            IRepository<RegisterCheckItem> registerCheckItemRepository,
            CurrentUser currentUser,
            PeisOrganizationUnitManager peisOrganizationUnitManager,
            PatientManager patientManager,
            RegisterCheckAsbitemManager registerAsbitemManager,
            CustomerOrgManager customerOrgManager,
            CustomerOrgRegisterManager customerOrgRegisterManager,
            RegisterCheckSuggestionManager registerCheckSuggestionManager,
            RegisterCheckSummaryManager registerCheckSummaryManager,
            RegisterCheckPictureManager registerCheckPictureManager,
            RegisterCheckItemManager registerCheckItemManager,
            RegisterCheckCriticalValueManager registerCheckCriticalValueManager,
            RegisterCheckManager registerCheckManager,
            IGuidGenerator guidGenerator,
            SysParmValueManager sysParmValueManager)
        {
            _repository = repository;
            this._customerOrgRepository = customerOrgRepository;
            _customerOrgRegisterRepository = customerOrgRegisterRepository;
            _customerOrgGroupRepository = customerOrgGroupRepository;
            _medicalTypeRepository = medicalTypeRepository;
            _personnelTypeRepository = personnelTypeRepository;
            _medicalPackageRepository = medicalPackageRepository;
            _medicalConclusionRepository = medicalConclusionRepository;
            _sexHormoneTermRepository = sexHormoneTermRepository;
            this._primarykeyBuilderRepository = primarykeyBuilderRepository;
            this._patientRepository = patientRepository;
            this._registerAsbitemRepository = registerAsbitemRepository;
            this._registerCheckRepository = registerCheckRepository;
            this._registerCheckCriticalValueRepository = registerCheckCriticalValueRepository;
            this._registerCheckItemRepository = registerCheckItemRepository;
            this._currentUser = currentUser;
            _peisOrganizationUnitManager = peisOrganizationUnitManager;
            this._patientManager = patientManager;
            this._registerAsbitemManager = registerAsbitemManager;
            this._customerOrgManager = customerOrgManager;
            this._customerOrgRegisterManager = customerOrgRegisterManager;
            this._registerCheckSuggestionManager = registerCheckSuggestionManager;
            this._registerCheckSummaryManager = registerCheckSummaryManager;
            this._registerCheckPictureManager = registerCheckPictureManager;
            this._registerCheckItemManager = registerCheckItemManager;
            this._registerCheckCriticalValueManager = registerCheckCriticalValueManager;
            this._registerCheckManager = registerCheckManager;
            this._sysParmValueRepository = sysParmValueRepository;
            _guidGenerator = guidGenerator;
            _sysParmValueManager = sysParmValueManager;
        }
        /// <summary>
        /// 创建
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="patientEntity"></param>
        /// <param name="IsMaxMedicalTimes">是否使用最后一次体检次数</param>
        /// <returns></returns>
        public async Task<PatientRegister> CreateAsync(
          PatientRegister entity,
          Patient patientEntity,
          char IsMaxMedicalTimes
         )
        {
            if (entity.PatientId == Guid.Empty)
            {
                //未选档号号，创建档案号

                var ent = new Patient
                {
                    Address = patientEntity.Address,
                    BirthDate = entity.BirthDate,
                    BirthPlaceId = patientEntity.BirthPlaceId,
                    DisplayName = entity.PatientName,
                    Email = patientEntity.Email,
                    IdNo = patientEntity.IdNo,
                    MaritalStatusId = entity.MaritalStatusId,
                    MobileTelephone = patientEntity.MobileTelephone,
                    NationId = patientEntity.NationId,
                    PatientPassword = "",
                    PostalCode = patientEntity.PostalCode,
                    SexId = entity.SexId,
                    Telephone = patientEntity.Telephone
                };
                var patientEnt = await _patientManager.CreateAsync(entity.MedicalCenterId, ent);
                if (patientEnt != null)
                {
                    entity.PatientId = patientEnt.Id;
                }


            }
            else
            {
                //查档案信息
                var oldent = await _patientRepository.GetAsync(entity.PatientId);

                if (oldent != null)
                {
                    oldent.Address = patientEntity.Address;
                    oldent.BirthDate = entity.BirthDate;
                    oldent.BirthPlaceId = patientEntity.BirthPlaceId;
                    oldent.DisplayName = entity.PatientName;
                    oldent.Email = patientEntity.Email;
                    oldent.IdNo = patientEntity.IdNo;
                    oldent.MaritalStatusId = entity.MaritalStatusId;
                    oldent.MobileTelephone = patientEntity.MobileTelephone;
                    oldent.NationId = patientEntity.NationId;
                    //oldent.PatientPassword = "",
                    oldent.PostalCode = patientEntity.PostalCode;
                    oldent.SexId = entity.SexId;
                    oldent.Telephone = patientEntity.Telephone;
                }

                await _patientRepository.UpdateAsync(oldent);  //修改档案


            }

            //暂时如此使用，这段代码以后要废除
            Guid CustomerOrgRegisterId = new Guid();  //最新单位次数ID

            if (IsMaxMedicalTimes == 'Y')
            {

                Guid CustomerOrgParentId = EntityHelper.GetParentNoSql(await _customerOrgRepository.GetListAsync(), entity.CustomerOrgId); //一级单位ID
                if (CustomerOrgParentId != Guid.Empty)
                {
                    var customerOrgRegisterEnt = await _customerOrgRegisterManager.GetMaxAsync(CustomerOrgParentId);
                    if (customerOrgRegisterEnt != null)
                        CustomerOrgRegisterId = customerOrgRegisterEnt.Id;
                }
            }
            else
            {
                CustomerOrgRegisterId = entity.CustomerOrgRegisterId;
            }




            var patientRegisterEnt = new PatientRegister(_guidGenerator.Create())
            {
                Age = entity.Age,
                AuditDate = entity.AuditDate,
                AuditDoctorId = entity.AuditDoctorId,
                BirthDate = entity.BirthDate,
                CompleteFlag = entity.CompleteFlag,
                CustomerOrgGroupId = entity.CustomerOrgGroupId,
                CustomerOrgId = entity.CustomerOrgId,
                CustomerOrgRegisterId = CustomerOrgRegisterId,
                GuidePrintTimes = entity.GuidePrintTimes,
                InterposeMeasure = entity.InterposeMeasure,
                IsAudit = entity.IsAudit,
                IsLock = entity.IsLock,
                IsMedicalStart = entity.IsMedicalStart,
                IsNameHide = entity.IsNameHide,
                IsPhoneFollow = entity.IsPhoneFollow,
                IsRecoverGuide = entity.IsRecoverGuide,
                IsUpload = entity.IsUpload,
                IsVip = entity.IsVip,
                JobCardNo = entity.JobCardNo,
                JobPost = entity.JobPost,
                JobTitle = entity.JobTitle,
                MaritalStatusId = entity.MaritalStatusId,
                MedicalCardNo = entity.MedicalCardNo,
                MedicalConclusionId = entity.MedicalConclusionId,
                MedicalPackageId = entity.MedicalPackageId,
                MedicalStartDate = entity.MedicalStartDate,
                MedicalTimes = entity.PatientId == Guid.Empty ? (short)1 : await GetPatientCount(entity.PatientId),
                MedicalTypeId = entity.MedicalTypeId,
                MedicalCenterId = entity.MedicalCenterId,
                PatientId = entity.PatientId,
                PatientName = entity.PatientName,
                PatientRegisterNo = await CreatePatientRegisterNo(entity.MedicalCenterId),
                PersonnelTypeId = entity.PersonnelTypeId,
                Photo = entity.Photo,
                Remark = entity.Remark,
                ReportPrintTimes = entity.ReportPrintTimes,
                Salesman = entity.Salesman,
                SexHormoneTermId = entity.SexHormoneTermId,
                SexId = entity.SexId,
                SummaryDate = entity.SummaryDate,
                SummaryDoctorId = entity.SummaryDoctorId,
                ThirdInfo = entity.ThirdInfo
            };

            //return patientRegisterEnt;

            return await _repository.InsertAsync(patientRegisterEnt, true);
        }

        public async Task<PatientRegister> CreateAsync(CreatePatientRegisterArg entity)
        {
            await VerifyCreate(entity);
            if (entity.IsVip == default(char))
            {
                entity.IsVip = 'N';
            }
            DataHelper.CheckCharIsYOrN(entity.IsVip, "VIP标志");

            DataHelper.CheckCharIsYOrN(entity.IsNameHide, "姓名隐藏");


            if (entity.CompleteFlag == default(char))
            {
                entity.CompleteFlag = PatientRegisterCompleteFlag.PreRegistration;
            }


            if (entity.CompleteFlag != PatientRegisterCompleteFlag.PreRegistration &&
                entity.CompleteFlag != PatientRegisterCompleteFlag.Registration)
            {
                throw new ArgumentException("完成标志错误");
            }




            var patientRegisterNo = await CreatePatientRegisterNo(entity.MedicalCenterId);
            if (entity.MedicalTimes == 0)
            {
                entity.MedicalTimes = await GetPatientCount(entity.PatientId);
            }
            var patientRegisterEnt = new PatientRegister(_guidGenerator.Create())
            {
                Age = entity.Age,
                AuditDate = null,
                AuditDoctorId = null,
                BirthDate = entity.BirthDate,
                CompleteFlag = entity.CompleteFlag,
                CustomerOrgGroupId = entity.CustomerOrgGroupId,
                CustomerOrgId = entity.CustomerOrgId,
                CustomerOrgRegisterId = entity.CustomerOrgRegisterId,
                GuidePrintTimes = 0,
                InterposeMeasure = null,
                IsAudit = 'N',
                IsLock = entity.IsLock,
                IsMedicalStart = 'N',
                IsNameHide = entity.IsNameHide,
                IsPhoneFollow = 'N',
                IsRecoverGuide = 'N',
                IsUpload = 'N',
                IsVip = entity.IsVip,
                JobCardNo = entity.JobCardNo,
                JobPost = entity.JobPost,
                JobTitle = entity.JobTitle,
                MaritalStatusId = entity.MaritalStatusId,
                MedicalCardNo = entity.MedicalCardNo,
                MedicalConclusionId = null,
                MedicalPackageId = entity.MedicalPackageId,
                MedicalStartDate = DateTime.Now,
                MedicalTimes = entity.MedicalTimes,
                MedicalTypeId = entity.MedicalTypeId,
                MedicalCenterId = entity.MedicalCenterId,
                PatientId = entity.PatientId,
                PatientName = entity.PatientName,
                PatientRegisterNo = patientRegisterNo,
                PersonnelTypeId = entity.PersonnelTypeId,
                Remark = entity.Remark,
                ReportPrintTimes = 0,
                Salesman = entity.Salesman,
                SexHormoneTermId = entity.SexHormoneTermId,
                SexId = entity.SexId,
                SummaryDate = null,
                SummaryDoctorId = null,
                ThirdInfo = entity.ThirdInfo
            };

            if (patientRegisterEnt.CustomerOrgGroupId != Guid.Empty && patientRegisterEnt.CustomerOrgGroupId != null)
            {
                await SetCustomerOrgGroupId(patientRegisterEnt, (Guid)patientRegisterEnt.CustomerOrgGroupId);
            }
            return patientRegisterEnt;
        }
        private async Task VerifyCreate(CreatePatientRegisterArg entity)
        {
            DataHelper.CheckEntityIsNull(entity);
            DataHelper.CheckGuidIsDefaultValue(entity.PatientId, "病人ID");
            DataHelper.CheckStringIsNull(entity.PatientName, "姓名");
            DataHelper.CheckGuidIsDefaultValue(entity.MedicalCenterId, "单位ID");
            DataHelper.CheckGuidIsDefaultValue(entity.CustomerOrgId, "客户单位ID");
            DataHelper.CheckSex(entity.SexId);
            DataHelper.CheckMaritalStatus(entity.MaritalStatusId);
            if (entity.MedicalTimes < 0)
            {
                throw new UserFriendlyException("体检次数必须大于等于0");
            }
            if (entity.Age <= 0)
            {
                throw new UserFriendlyException("年龄不能小于等于0");
            }



            if (entity.CustomerOrgGroupId != Guid.Empty && entity.CustomerOrgGroupId != null)
            {
                if ((await _customerOrgGroupRepository.GetQueryableAsync()).
                     Where(o => o.CustomerOrgRegisterId == entity.CustomerOrgRegisterId &&
                     o.Id == entity.CustomerOrgGroupId).Count() == 0)
                {
                    throw new UserFriendlyException("单位分组ID不存在");
                }
            }

            if (entity.MedicalPackageId != Guid.Empty && entity.MedicalPackageId != null)
            {
                if (await _medicalPackageRepository.GetQueryableAsync().Result.
                     Where(o => o.Id == entity.MedicalPackageId).CountAsync() == 0)
                {
                    throw new UserFriendlyException("套餐ID不存在");
                }
            }

            if (entity.MedicalTypeId != Guid.Empty && entity.MedicalTypeId != null)
            {
                if (await _medicalTypeRepository.GetQueryableAsync().Result.
                     Where(o => o.Id == entity.MedicalTypeId).CountAsync() == 0)
                {
                    throw new UserFriendlyException("体检类别ID不存在");
                }
            }
            if (entity.PersonnelTypeId != Guid.Empty && entity.PersonnelTypeId != null)
            {
                if (await _personnelTypeRepository.GetQueryableAsync().Result.
                     Where(o => o.Id == entity.PersonnelTypeId).CountAsync() == 0)
                {
                    throw new UserFriendlyException("人员类别ID不存在");
                }
            }



            if (entity.SexHormoneTermId != Guid.Empty && entity.SexHormoneTermId != null)
            {
                if (await _sexHormoneTermRepository.GetQueryableAsync().Result.
                     Where(o => o.Id == entity.SexHormoneTermId).CountAsync() == 0)
                {
                    throw new UserFriendlyException("性激素期限ID不存在");
                }
            }

            if (!await _peisOrganizationUnitManager.IsPeis(entity.MedicalCenterId))
            {
                throw new UserFriendlyException("组织单位ID不是体检中心");
            }
            var customerOrg = await _customerOrgRepository.FindAsync(o => o.Id == entity.CustomerOrgId);
            if (customerOrg == null)
            {
                throw new UserFriendlyException("客户单位ID不存在");
            }
            if (customerOrg.Id == GuidFlag.PersonCustomerOrgId)
            {
                if (entity.CustomerOrgGroupId != Guid.Empty && entity.CustomerOrgGroupId != null)
                {
                    throw new UserFriendlyException("个人体检不能选单位分组");
                }
            }
            else
            {
                if (entity.MedicalPackageId != Guid.Empty && entity.MedicalPackageId != null)
                {
                    throw new UserFriendlyException("单位体检不能选套餐");
                }
            }
            var customerOrgRegister = await _customerOrgRegisterRepository.FindAsync(o => o.Id == entity.CustomerOrgRegisterId);
            if (customerOrgRegister == null)
            {
                throw new UserFriendlyException("客户登记单位次数不存在");
            }
            if (customerOrgRegister.CustomerOrgId != customerOrg.Id)
            {
                var topCustomerOrg = await _customerOrgManager.GetTopCustomerOrgAsync(customerOrg.Id);
                var topCustomerOrgRegisterOrg = await _customerOrgManager.GetTopCustomerOrgAsync(customerOrgRegister.CustomerOrgId);
                if (topCustomerOrg.Id != topCustomerOrgRegisterOrg.Id)
                {
                    throw new UserFriendlyException("登记单位和登记单位体检次数不一致");
                }
            }

            if ((entity.Age == 0 || entity.Age == null))
            {
                if (entity.BirthDate != null && entity.BirthDate > new DateTime(1900, 1, 1))
                {
                    entity.Age = (short)ConvertExtr.ToAge(((DateTime)entity.BirthDate));
                };

            }

            if (entity.BirthDate == null || entity.BirthDate <= new DateTime(1900, 1, 1))
            {
                if (entity.Age != null && entity.Age > 0)
                {
                    entity.BirthDate = ConvertExtr.ToBirthDateByAge((short)entity.Age);
                }
            }
        }
        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="sourceEntity">Dto实体映射数据</param>
        /// <param name="targetEntity">原始数据</param>
        /// <returns></returns>
        public async Task UpdateAsync(
           UpdatePatientRegisterArg sourceEntity,
           PatientRegister targetEntity
          )
        {

            DataHelper.CheckStringIsNull(sourceEntity.PatientName, "姓名");
            DataHelper.CheckGuidIsDefaultValue(sourceEntity.MedicalCenterId, "单位ID");
            DataHelper.CheckGuidIsDefaultValue(sourceEntity.CustomerOrgId, "客户单位ID");
            DataHelper.CheckSex(sourceEntity.SexId);
            DataHelper.CheckMaritalStatus(sourceEntity.MaritalStatusId);

            DataHelper.CheckCharIsYOrN(sourceEntity.IsVip, "VIP标志");


            DataHelper.CheckCharIsYOrN(sourceEntity.IsNameHide, "姓名隐藏");

            if (sourceEntity.CompleteFlag != PatientRegisterCompleteFlag.PreRegistration &&
                sourceEntity.CompleteFlag != PatientRegisterCompleteFlag.Registration &&
                sourceEntity.CompleteFlag != PatientRegisterCompleteFlag.PartCheck)
            {
                throw new ArgumentException("完成标志错误");
            }

            //if (sourceEntity.MedicalTimes < 1)
            //{
            //    throw new UserFriendlyException("体检次数必须大于0");
            //}
            //if (sourceEntity.MedicalTimes != targetEntity.MedicalTimes)
            //{
            //    var cnt = (await _repository.GetQueryableAsync()).Where(o => o.Id != targetEntity.Id &&
            //    o.PatientId == sourceEntity.PatientId &&
            //     o.MedicalTimes == sourceEntity.MedicalTimes).Count();
            //    if (cnt > 0)
            //    {
            //        throw new UserFriendlyException("体检次数已经使用过");
            //    }
            //}
            if (sourceEntity.Age <= 0)
            {
                throw new UserFriendlyException("年龄不能小于等于0");
            }



            if (sourceEntity.CustomerOrgGroupId != targetEntity.CustomerOrgGroupId &&
                sourceEntity.CustomerOrgGroupId != Guid.Empty && sourceEntity.CustomerOrgGroupId != null)
            {
                if ((await _customerOrgGroupRepository.GetQueryableAsync()).
                     Where(o => o.CustomerOrgRegisterId == sourceEntity.CustomerOrgRegisterId &&
                     o.Id == sourceEntity.CustomerOrgGroupId).Count() == 0)
                {
                    throw new UserFriendlyException("单位分组ID不存在");
                }
            }

            if (sourceEntity.MedicalPackageId != targetEntity.MedicalPackageId && sourceEntity.MedicalPackageId != Guid.Empty && sourceEntity.MedicalPackageId != null)
            {
                if (await _medicalPackageRepository.GetQueryableAsync().Result.
                     Where(o => o.Id == sourceEntity.MedicalPackageId).CountAsync() == 0)
                {
                    throw new UserFriendlyException("套餐ID不存在");
                }
            }

            if (sourceEntity.MedicalTypeId != targetEntity.MedicalTypeId && sourceEntity.MedicalTypeId != Guid.Empty && sourceEntity.MedicalTypeId != null)
            {
                if (await _medicalTypeRepository.GetQueryableAsync().Result.
                     Where(o => o.Id == sourceEntity.MedicalTypeId).CountAsync() == 0)
                {
                    throw new UserFriendlyException("体检类别ID不存在");
                }
            }
            if (sourceEntity.PersonnelTypeId != targetEntity.PersonnelTypeId && sourceEntity.PersonnelTypeId != Guid.Empty && sourceEntity.PersonnelTypeId != null)
            {
                if (await _personnelTypeRepository.GetQueryableAsync().Result.
                     Where(o => o.Id == sourceEntity.PersonnelTypeId).CountAsync() == 0)
                {
                    throw new UserFriendlyException("人员类别ID不存在");
                }
            }

            //if (sourceEntity.MedicalConclusionId != targetEntity.MedicalConclusionId && sourceEntity.MedicalConclusionId != Guid.Empty && sourceEntity.MedicalConclusionId != null)
            //{
            //    if (await _medicalConclusionRepository.GetQueryableAsync().Result.
            //         Where(o => o.Id == sourceEntity.MedicalConclusionId).CountAsync() == 0)
            //    {
            //        throw new UserFriendlyException("体检结论ID不存在");
            //    }
            //}

            if (sourceEntity.SexHormoneTermId != targetEntity.SexHormoneTermId && sourceEntity.SexHormoneTermId != Guid.Empty && sourceEntity.SexHormoneTermId != null)
            {
                if (await _sexHormoneTermRepository.GetQueryableAsync().Result.
                     Where(o => o.Id == sourceEntity.SexHormoneTermId).CountAsync() == 0)
                {
                    throw new UserFriendlyException("性激素期限ID不存在");
                }
            }

            if (sourceEntity.MedicalCenterId != targetEntity.MedicalCenterId && !await _peisOrganizationUnitManager.IsPeis(sourceEntity.MedicalCenterId))
            {
                throw new UserFriendlyException("组织单位ID不是体检中心");
            }
            CustomerOrg customerOrg = null;
            if (sourceEntity.CustomerOrgId != targetEntity.CustomerOrgId)
            {
                customerOrg = await _customerOrgRepository.FindAsync(o => o.Id == sourceEntity.CustomerOrgId);
                if (customerOrg == null)
                {
                    throw new UserFriendlyException("客户单位ID不存在");
                }
            }
            CustomerOrgRegister customerOrgRegister = null;
            if (sourceEntity.CustomerOrgRegisterId != targetEntity.CustomerOrgRegisterId)
            {
                customerOrgRegister = await _customerOrgRegisterRepository.FindAsync(o => o.Id == sourceEntity.CustomerOrgRegisterId);
                if (customerOrgRegister == null)
                {
                    throw new UserFriendlyException("客户登记单位次数不存在");
                }
            }
            if (sourceEntity.CustomerOrgId != targetEntity.CustomerOrgId || sourceEntity.CustomerOrgRegisterId != targetEntity.CustomerOrgRegisterId)
            {
                if (customerOrg == null)
                {
                    customerOrg = await _customerOrgRepository.FindAsync(o => o.Id == sourceEntity.CustomerOrgId);
                }
                if (customerOrg == null)
                {
                    throw new UserFriendlyException("客户单位ID不存在");
                }
                if (customerOrgRegister == null)
                {
                    customerOrgRegister = await _customerOrgRegisterRepository.FindAsync(o => o.Id == sourceEntity.CustomerOrgRegisterId);
                }
                if (customerOrgRegister == null)
                {
                    throw new UserFriendlyException("客户登记单位次数不存在");
                }

                if (customerOrgRegister.CustomerOrgId != customerOrg.Id)
                {
                    var topCustomerOrg = await _customerOrgManager.GetTopCustomerOrgAsync(customerOrg.Id);
                    var topCustomerOrgRegisterOrg = await _customerOrgManager.GetTopCustomerOrgAsync(customerOrgRegister.CustomerOrgId);
                    if (topCustomerOrg.Id != topCustomerOrgRegisterOrg.Id)
                    {
                        throw new UserFriendlyException("登记单位和登记单位体检次数不一致");
                    }
                }
            }

            if (sourceEntity.CustomerOrgId == GuidFlag.PersonCustomerOrgId)
            {
                if (sourceEntity.CustomerOrgGroupId != Guid.Empty && sourceEntity.CustomerOrgGroupId != null)
                {
                    throw new UserFriendlyException("个人体检不能选单位分组");
                }
            }
            else
            {
                if (sourceEntity.MedicalPackageId != Guid.Empty && sourceEntity.MedicalPackageId != null)
                {
                    throw new UserFriendlyException("单位体检不能选套餐");
                }
            }


            if ((sourceEntity.Age == 0 || sourceEntity.Age == null))
            {
                if (sourceEntity.BirthDate != null && sourceEntity.BirthDate > new DateTime(1900, 1, 1))
                {
                    sourceEntity.Age = (short)ConvertExtr.ToAge(((DateTime)sourceEntity.BirthDate));
                };

            }

            if (sourceEntity.BirthDate == null || sourceEntity.BirthDate <= new DateTime(1900, 1, 1))
            {
                if (sourceEntity.Age != null && sourceEntity.Age > 0)
                {
                    sourceEntity.BirthDate = ConvertExtr.ToBirthDateByAge((short)sourceEntity.Age);
                }
            }

            if (targetEntity.PatientName != sourceEntity.PatientName && targetEntity.SexId != sourceEntity.SexId)
            {
                throw new UserFriendlyException("人员信息姓名和性别和原来的信息都不一致，禁止修改");
            }

            //预登记改正式登记  修改体检日期跟状态
            if (targetEntity.CompleteFlag == PatientRegisterCompleteFlag.PreRegistration 
                && sourceEntity.CompleteFlag == PatientRegisterCompleteFlag.Registration)
            {
                targetEntity.MedicalStartDate = DateTime.Now;
                targetEntity.IsMedicalStart = 'Y';
            }


            //targetEntity.AuditDate = sourceEntity.AuditDate;
            //targetEntity.AuditDoctor = sourceEntity.AuditDoctor;
            targetEntity.BirthDate = sourceEntity.BirthDate;
            targetEntity.Age = sourceEntity.Age;
            targetEntity.CompleteFlag = sourceEntity.CompleteFlag;
            targetEntity.CustomerOrgGroupId = sourceEntity.CustomerOrgGroupId;
            targetEntity.CustomerOrgId = sourceEntity.CustomerOrgId;
            targetEntity.CustomerOrgRegisterId = sourceEntity.CustomerOrgRegisterId;
            //targetEntity.GuidePrintTimes = sourceEntity.GuidePrintTimes;
            //targetEntity.InterposeMeasure = sourceEntity.InterposeMeasure;
            //targetEntity.IsAudit = sourceEntity.IsAudit;
            targetEntity.IsLock = sourceEntity.IsLock;
            //targetEntity.IsMedicalStart = sourceEntity.IsMedicalStart;
            targetEntity.IsNameHide = sourceEntity.IsNameHide;
            //targetEntity.IsPhoneFollow = sourceEntity.IsPhoneFollow;
            //targetEntity.IsRecoverGuide = sourceEntity.IsRecoverGuide;
            //targetEntity.IsUpload = sourceEntity.IsUpload;
            targetEntity.IsVip = sourceEntity.IsVip;
            targetEntity.JobCardNo = sourceEntity.JobCardNo;
            targetEntity.JobPost = sourceEntity.JobPost;
            targetEntity.JobTitle = sourceEntity.JobTitle;
            targetEntity.MaritalStatusId = sourceEntity.MaritalStatusId;
            targetEntity.MedicalCardNo = sourceEntity.MedicalCardNo;
            //targetEntity.MedicalConclusionId = sourceEntity.MedicalConclusionId;
            targetEntity.MedicalPackageId = sourceEntity.MedicalPackageId;
            //targetEntity.MedicalStartDate = sourceEntity.MedicalStartDate;
            //targetEntity.MedicalTimes = sourceEntity.MedicalTimes;
            targetEntity.MedicalTypeId = sourceEntity.MedicalTypeId;
            targetEntity.MedicalCenterId = sourceEntity.MedicalCenterId;
            //targetEntity.PatientId = sourceEntity.PatientId;
            targetEntity.PatientName = sourceEntity.PatientName;
            //targetEntity.PatientRegisterNo = sourceEntity.PatientRegisterNo;
            targetEntity.PersonnelTypeId = sourceEntity.PersonnelTypeId;
            targetEntity.Remark = sourceEntity.Remark;
            //targetEntity.ReportPrintTimes = sourceEntity.ReportPrintTimes;
            targetEntity.Salesman = sourceEntity.Salesman;
            targetEntity.SexHormoneTermId = sourceEntity.SexHormoneTermId;
            targetEntity.SexId = sourceEntity.SexId;
            //targetEntity.SummaryDate = sourceEntity.SummaryDate;
            //targetEntity.SummaryDoctor = sourceEntity.SummaryDoctor;
            targetEntity.ThirdInfo = sourceEntity.ThirdInfo;

            if (sourceEntity.CustomerOrgGroupId != Guid.Empty && sourceEntity.CustomerOrgGroupId != null)
            {
                await SetCustomerOrgGroupId(targetEntity, (Guid)sourceEntity.CustomerOrgGroupId);
            }
            //targetEntity.MedicalTimes = sourceEntity.MedicalTimes;
            //targetEntity.PatientId = sourceEntity.PatientId;
            //targetEntity.PatientRegisterNo = sourceEntity.PatientRegisterNo;
            //if (isUpdateCheck)
            //{
            //    //有更新性别或者年龄，需要更新check表数据
            //    await _registerAsbitemManager.UpdateCheckReferenceRange(targetEntity.Id);
            //}

        }


        public async Task SetCustomerOrgGroupId(PatientRegister patientRegister, Guid customerOrgGroupId)
        {
            var customerOrgGroup = await _customerOrgGroupRepository.GetAsync(customerOrgGroupId);
            if ((customerOrgGroup.ForSexId == ForSexFlag.Male && patientRegister.SexId != SexFlag.Male && patientRegister.SexId != SexFlag.UnKnown)
                || (customerOrgGroup.ForSexId == ForSexFlag.Female && patientRegister.SexId != SexFlag.Female && patientRegister.SexId != SexFlag.UnKnown))
            {
                throw new UserFriendlyException("分组和人员性别不一致");
            }

            if ((customerOrgGroup.MaritalStatusId == MaritalStatusFlag.UnMarried && patientRegister.MaritalStatusId != MaritalStatusFlag.UnMarried && patientRegister.MaritalStatusId != MaritalStatusFlag.UnKnown)
                || (customerOrgGroup.MaritalStatusId == MaritalStatusFlag.Married && patientRegister.MaritalStatusId == MaritalStatusFlag.UnMarried))
            {
                throw new UserFriendlyException("分组和人员婚姻状况不一致");
            }

            if (patientRegister.Age < customerOrgGroup.AgeLowerLimit)
            {
                throw new UserFriendlyException("年龄不能小于分组年龄下限");
            }
            if (patientRegister.Age > customerOrgGroup.AgeUpperLimit)
            {
                throw new UserFriendlyException("年龄不能大于于分组年龄上限");
            }
            patientRegister.CustomerOrgGroupId = customerOrgGroupId;
        }
        /// <summary>
        /// 生成条码号(规则，先找体检中心的配置，如未找到，就直接使用全局的)
        /// 模式（0 日期+尾号   1.顺序递增）
        /// </summary>
        /// <param name="medicalCenterId">体检中心ID</param>
        /// <returns></returns>
        public async Task<string> CreatePatientRegisterNo(Guid medicalCenterId)
        {
            string PatientRegisterNo = "";  //条码号

            List<SysParmValue> spvlist = await _sysParmValueRepository.GetListAsync();

            var spv_tjzx = spvlist.Where(m => m.MedicalCenterId == medicalCenterId); //体检中心配置
            var spv_global = spvlist.Where(m => m.MedicalCenterId == Guid.Empty);  //全局配置

            var patient_register_no_rule_coding = "";  // 模式（0 日期+尾号   1.顺序递增）
            var patient_register_no_rule_tail_len = "";  //尾号长度
            var patient_register_no_rule_prefix = ""; //前缀

            patient_register_no_rule_coding = await _sysParmValueManager.GetSysParmValueAsync(medicalCenterId, "patient_register_no_rule_coding");
            patient_register_no_rule_tail_len = await _sysParmValueManager.GetSysParmValueAsync(medicalCenterId, "patient_register_no_rule_tail_len");
            patient_register_no_rule_prefix = await _sysParmValueManager.GetSysParmValueAsync(medicalCenterId, "patient_register_no_rule_prefix");


            if (string.IsNullOrWhiteSpace(patient_register_no_rule_tail_len))
            {
                throw new UserFriendlyException("人员条码号尾号长度不能为空");
            }
            int tailLen;
            if (!int.TryParse(patient_register_no_rule_tail_len, out tailLen))
            {
                throw new UserFriendlyException("人员条码号尾号长度必须是数字");
            };
            if (tailLen < 4)
            {
                throw new UserFriendlyException("人员条码号尾号长度必须大于等于4");
            }



            var primarykeyBuilderEnt = await _primarykeyBuilderRepository.FirstOrDefaultAsync(f => f.PrimarykeyBuilderId == "patient_register_no");




            string maxnum = "1";
            string date = DateTime.Now.ToString("yyMMdd");// 当天

            if (patient_register_no_rule_coding == "0")
            {
                //日期+尾号    
                #region 模式0  日期+尾号

                if (primarykeyBuilderEnt != null)
                {
                    if (primarykeyBuilderEnt.DateString != date)
                    {
                        //新的日期  为1  maxnum
                        primarykeyBuilderEnt.DateString = date;
                        maxnum = "1";
                    }
                    else
                    {
                        maxnum = (Convert.ToInt32(primarykeyBuilderEnt.SerialNo) + 1).ToString();
                    }

                    primarykeyBuilderEnt.SerialNo = maxnum; //更新新的序列号

                    PatientRegisterNo = patient_register_no_rule_prefix + date + maxnum.PadLeft(Convert.ToInt32(patient_register_no_rule_tail_len), '0');

                    await _primarykeyBuilderRepository.UpdateAsync(primarykeyBuilderEnt);
                }
                else
                {
                    //初始写入

                    PatientRegisterNo = patient_register_no_rule_prefix + date + maxnum.PadLeft(Convert.ToInt32(patient_register_no_rule_tail_len), '0');

                    primarykeyBuilderEnt = new PrimarykeyBuilder
                    {
                        PrimarykeyBuilderId = "patient_register_no",
                        DateString = date,
                        SerialNo = maxnum
                    };

                    await _primarykeyBuilderRepository.InsertAsync(primarykeyBuilderEnt,true);
                }
                #endregion
            }
            else
            {
                //模式1  顺序递增   

                #region 模式1  顺序递增

                if (primarykeyBuilderEnt != null)
                {
                    maxnum = (Convert.ToInt32(primarykeyBuilderEnt.SerialNo) + 1).ToString();
                    primarykeyBuilderEnt.SerialNo = maxnum;  //更新num
                    await _primarykeyBuilderRepository.UpdateAsync(primarykeyBuilderEnt);
                }
                else
                {
                    //初始写入

                    primarykeyBuilderEnt = new PrimarykeyBuilder
                    {
                        PrimarykeyBuilderId = "patient_register_no",
                        DateString = "",
                        SerialNo = maxnum
                    };

                    await _primarykeyBuilderRepository.InsertAsync(primarykeyBuilderEnt,true);
                }


                PatientRegisterNo = patient_register_no_rule_prefix + maxnum.PadLeft(Convert.ToInt32(patient_register_no_rule_tail_len), '0');
                #endregion

            }

            return PatientRegisterNo;

        }

        public async Task<string> CreatePrePatientRegisterNo()
        {
            string maxnum = "1";
            string date = DateTime.Now.ToString("yyMMdd");// 当天
            var primarykeyBuilderEnt = await _primarykeyBuilderRepository.FirstOrDefaultAsync(f => f.PrimarykeyBuilderId == "pre_patient_register_no");
            string prePatientRegisterNo;
            if (primarykeyBuilderEnt != null)
            {
                if (primarykeyBuilderEnt.DateString != date)
                {
                    //新的日期  为1  maxnum
                    primarykeyBuilderEnt.DateString = date;
                }

                maxnum = (Convert.ToInt32(primarykeyBuilderEnt.SerialNo) + 1).ToString();
                primarykeyBuilderEnt.SerialNo = maxnum; //更新新的序列号

                prePatientRegisterNo =  date + maxnum.PadLeft(Convert.ToInt32(5), '0');

                await _primarykeyBuilderRepository.UpdateAsync(primarykeyBuilderEnt);
            }
            else
            {
                //初始写入

                prePatientRegisterNo = date + maxnum.PadLeft(Convert.ToInt32(5), '0');

                primarykeyBuilderEnt = new PrimarykeyBuilder
                {
                    PrimarykeyBuilderId = "patient_register_no",
                    DateString = date,
                    SerialNo = maxnum
                };

                await _primarykeyBuilderRepository.InsertAsync(primarykeyBuilderEnt, true);
            }
            return prePatientRegisterNo;
        }
        ///// <summary>
        ///// 生成条码号(规则，先找体检中心的配置，如未找到，就直接使用全局的)
        ///// 模式（0 日期+尾号   1.顺序递增）
        ///// </summary>
        ///// <param name="OrganizationUnitId">体检中心ID</param>
        ///// <returns></returns>
        //public async Task<string> CreatePatientNo(Guid OrganizationUnitId)
        //{
        //    string PatientNo = "";

        //    string prefix = "";  //前缀
        //    int lastLength = 0;
        //    string mode = "0";
        //    string beginValue = "0";

        //    List<SysParmValue> spvlist = await _sysParmValueRepository.GetListAsync();

        //    if (CustomerOrgId == null || CustomerOrgId == Guid.Empty)
        //    {
        //        //个人
        //        spvlist = spvlist.Where(m => m.OrganizationUnitId == Guid.Empty).ToList();
        //    }
        //    else
        //    {
        //        var OrganizationUnitId = (await _customerOrgRepository.FindAsync(m => m.Id == CustomerOrgId)).OrganizationUnitId;
        //        if (OrganizationUnitId == null || OrganizationUnitId == Guid.Empty)
        //        {
        //            spvlist = spvlist.Where(m => m.OrganizationUnitId == Guid.Empty).ToList();
        //        }
        //        else
        //        {
        //            spvlist = spvlist.Where(m => m.OrganizationUnitId == OrganizationUnitId).ToList();
        //        }
        //    }

        //    var org_barcode_no_begin_value = spvlist.Where(m => m.SysParmId == "org_barcode_no_begin_value").FirstOrDefault(); //条码号建立规则--单位登记条码号开始值
        //    var barcode_no_build_rule_mode = spvlist.Where(m => m.SysParmId == "barcode_no_build_rule_mode").FirstOrDefault(); //条码号建立规则--编码方式
        //    var barcode_no_build_rule_length = spvlist.Where(m => m.SysParmId == "barcode_no_build_rule_length").FirstOrDefault(); //条码号建立规则--尾号长度
        //    var barcode_no_build_rule_prefix = spvlist.Where(m => m.SysParmId == "barcode_no_build_rule_prefix").FirstOrDefault(); //条码号建立规则--条码号前缀

        //    if (barcode_no_build_rule_mode != null)
        //    {
        //        mode = barcode_no_build_rule_mode.ParmValue;  //编码方式
        //    }

        //    if (org_barcode_no_begin_value != null)
        //    {
        //        beginValue = org_barcode_no_begin_value.ParmValue;  //单位起始值
        //    }

        //    if (barcode_no_build_rule_length != null)
        //    {
        //        lastLength = Convert.ToInt32(barcode_no_build_rule_length.ParmValue);  //尾号长度
        //    }

        //    if (barcode_no_build_rule_prefix != null)
        //    {
        //        prefix = barcode_no_build_rule_prefix.ParmValue;  //前缀
        //    }


        //    var primarykeyBuilderEnt = await _primarykeyBuilderRepository.FindAsync(f => f.PrimarykeyBuilderId == "patient_register");



        //    string writenum = "0";
        //    string maxnum = "0";
        //    string date = DateTime.Now.ToString("yyyyMMdd");// 当天

        //    if (mode == "0")
        //    {
        //        //日期+尾号   区分个人跟单位  个人1开始   单位未设置的单位起始值开始    
        //        #region 模式0  日期+尾号

        //        if (primarykeyBuilderEnt != null)
        //        {


        //            if (primarykeyBuilderEnt.DateString == date)
        //            {
        //                //当天
        //                if (CustomerOrgId == null || CustomerOrgId == Guid.Empty)
        //                {
        //                    //个人
        //                    maxnum = (Convert.ToInt32(primarykeyBuilderEnt.SerialNo) + 1).ToString();

        //                }
        //                else
        //                {
        //                    maxnum = (Convert.ToInt32(beginValue) + Convert.ToInt32(primarykeyBuilderEnt.SerialNo) + 1).ToString();
        //                }

        //                writenum = (Convert.ToInt32(primarykeyBuilderEnt.SerialNo) + 1).ToString();

        //                PatientNo = prefix + date + maxnum.PadLeft(lastLength, '0');


        //            }
        //            else
        //            {
        //                //已更换日期 重新初始化
        //                if (CustomerOrgId == null || CustomerOrgId == Guid.Empty)
        //                {
        //                    //个人
        //                    maxnum = (Convert.ToInt32(maxnum) + 1).ToString();

        //                }
        //                else
        //                {
        //                    maxnum = (Convert.ToInt32(beginValue) + Convert.ToInt32(maxnum) + 1).ToString();
        //                }

        //                writenum = (Convert.ToInt32(maxnum) + 1).ToString();

        //                PatientNo = prefix + date + maxnum.PadLeft(lastLength, '0');
        //            }




        //            primarykeyBuilderEnt.DateString = date;
        //            primarykeyBuilderEnt.SerialNo = writenum;
        //            await _primarykeyBuilderRepository.UpdateAsync(primarykeyBuilderEnt);
        //        }
        //        else
        //        {
        //            //初始写入

        //            //  maxnum = (Convert.ToInt32(maxnum) + 1).ToString();

        //            writenum = (Convert.ToInt32(maxnum) + 1).ToString();


        //            if (CustomerOrgId == null || CustomerOrgId == Guid.Empty)
        //            {
        //                //个人
        //                maxnum = (Convert.ToInt32(maxnum) + 1).ToString();

        //            }
        //            else
        //            {
        //                maxnum = (Convert.ToInt32(beginValue) + Convert.ToInt32(maxnum) + 1).ToString();
        //            }


        //            PatientNo = prefix + date + maxnum.PadLeft(lastLength, '0');

        //            primarykeyBuilderEnt = new PrimarykeyBuilder
        //            {
        //                PrimarykeyBuilderId = "patient_register",
        //                DateString = date,
        //                SerialNo = writenum
        //            };

        //            await _primarykeyBuilderRepository.InsertAsync(primarykeyBuilderEnt);
        //        }
        //        #endregion
        //    }
        //    else
        //    {
        //        //模式1  顺序递增  不区分个人跟单位

        //        #region 模式1  顺序递增

        //        if (primarykeyBuilderEnt != null)
        //        {
        //            maxnum = (Convert.ToInt32(primarykeyBuilderEnt.SerialNo) + 1).ToString();

        //        }
        //        else
        //        {
        //            //初始写入

        //            maxnum = (Convert.ToInt32(maxnum) + 1).ToString();



        //            primarykeyBuilderEnt = new PrimarykeyBuilder
        //            {
        //                PrimarykeyBuilderId = "patient_register",
        //                DateString = "",
        //                SerialNo = maxnum
        //            };

        //            await _primarykeyBuilderRepository.InsertAsync(primarykeyBuilderEnt);
        //        }


        //        PatientNo = prefix + maxnum.PadLeft(lastLength, '0');
        //        #endregion

        //    }


        //    return PatientNo;

        //}

        /// <summary>
        /// 获取体检次数  最后一次加一
        /// </summary>
        /// <param name="PatientId"></param>
        /// <returns></returns>
        private async Task<short> GetPatientCount(Guid PatientId)
        {
            short MaxMedicalTimes = 0;

            var patientRegisterEntList = await _repository.GetListAsync(m => m.PatientId == PatientId);
            if (patientRegisterEntList.Count > 0)
                MaxMedicalTimes = patientRegisterEntList.Max(m => m.MedicalTimes);

            return (short)(MaxMedicalTimes + 1);

        }

        /// <summary>
        /// 获取体检次数  不加一
        /// </summary>
        /// <param name="PatientId"></param>
        /// <returns></returns>
        public short GetPatientCountNoAsync(Guid PatientId)
        {
            short MaxMedicalTimes = 0;

            var patientRegisterEntList = _repository.GetListAsync(m => m.PatientId == PatientId).Result;
            if (patientRegisterEntList.Count > 0)
                MaxMedicalTimes = patientRegisterEntList.Max(m => m.MedicalTimes);

            return MaxMedicalTimes;

        }


        /// <summary>
        /// 获取最后登记时间 
        /// </summary>
        /// <param name="PatientId"></param>
        /// <returns></returns>
        public DateTime? GetPatientRegisterLastTime(Guid PatientId)
        {
            DateTime? LastTime = null;

            var patientRegisterEntList = _repository.GetListAsync(m => m.PatientId == PatientId).Result;
            if (patientRegisterEntList.Count > 0)
                LastTime = patientRegisterEntList.OrderByDescending(o => o.CreationTime).First().CreationTime;

            return LastTime;

        }

        /// <summary>
        /// 回收表格
        /// </summary>
        /// <param name="PatientRegisterId">登记表ID</param>
        /// <returns></returns>
        public async Task<PatientRegister> UpdateRecoverGuideAsync(Guid PatientRegisterId)
        {
            var entity = await _repository.FindAsync(f => f.Id == PatientRegisterId);
            if (entity != null)
            {
                entity.IsRecoverGuide = 'Y';
                return await _repository.UpdateAsync(entity);
            }
            else
            {
                return entity;
            }
        }

        private bool IsParmNotNUll(object obj)
        {
            if (obj == null)
                return false;
            else return true;
        }


        /// <summary>
        /// 删除  已废弃
        /// </summary>
        /// <param name="PatientRegisterId">人员登记表ID</param>
        /// <returns></returns>
        public async Task IsDelete(Guid PatientRegisterId)
        {
            //体检开始不能删  有一项收费了不能删

            var ent = await _repository.GetAsync(PatientRegisterId);
            if (ent != null)
            {
                if (ent.IsMedicalStart == 'Y')
                {
                    throw new UserFriendlyException($"体检已开始，不能删除");
                }
                else
                {
                    var registerAsbitemList = await _registerAsbitemRepository.GetListAsync(m => m.PatientRegisterId == PatientRegisterId);
                    if (registerAsbitemList.Count > 0)
                    {
                        foreach (var item in registerAsbitemList)
                        {
                            await _registerAsbitemManager.DeleteAsync(item.Id);  //删除登记组合项目  
                        }
                    }

                    await _repository.DeleteAsync(ent);  //执行删除
                }

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


        }



        /// <summary>
        /// 1.已有已检组合项目的不允许删除。
        /// 2.已有收费的不允许删除。
        /// 3.删除的时候，同步删除(组合项目（register_asbitem）,
        /// 登记检查(register_check)，register_check_critical_value（危急值），
        /// register_check_item，register_check_picture，register_check_suggestion，register_check_summary)
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        public async Task CheckAndDeleteAsync(Guid id)
        {
            //var patientRegisterEnt = await _repository.FindAsync(m => m.Id == id);

            var patientRegisterEnt = (await _repository.GetDbSetAsync())
                .Include(x => x.RegisterCheckAsbitems)
                .Where(m => m.Id == id)
                .FirstOrDefault();
            if (patientRegisterEnt != null)
            {
                if (patientRegisterEnt.IsLock == 'Y')
                {
                    throw new UserFriendlyException("已加锁，不能删除");
                }

                var patientRegisterQueryable = (from a in await _repository.GetQueryableAsync()
                                                join b in await _registerAsbitemRepository.GetQueryableAsync() on a.Id equals b.PatientRegisterId
                                                join c in await _registerCheckRepository.GetQueryableAsync() on b.RegisterCheckId equals c.Id
                                                where a.Id == id
                                                select new
                                                {
                                                    RegisterAsbitemId = b.Id,
                                                    RegisterCheckId = c.Id,
                                                    IsCharge = b.IsCharge,
                                                    PatientName = a.PatientName,
                                                    CompleteFlag = c.CompleteFlag,
                                                }).AsQueryable();

                if (patientRegisterQueryable.Where(m => m.IsCharge == 'Y').Count() > 0)
                {
                    throw new UserFriendlyException($"人员\"{patientRegisterEnt.PatientName}\"已有项目收费，不能删除");
                }

                if (patientRegisterQueryable.Where(m => m.CompleteFlag == RegisterCheckCompleteFlag.Checked).Count() > 0)
                {
                    throw new UserFriendlyException($"人员\"{patientRegisterEnt.PatientName}\"已有项目检查，不能删除");
                }


                //删除逻辑


                var RegisterCheckIds = patientRegisterQueryable.Select(s => s.RegisterCheckId);
                var RegisterAsbitemIds = patientRegisterQueryable.Select(s => s.RegisterAsbitemId);


                if (RegisterCheckIds.Any())
                {
                    //删除registerCheckSuggestion
                    await _registerCheckSuggestionManager.CheckAndDeleteAsync(RegisterCheckIds.ToList());


                    //删除registerCheckSummary
                    await _registerCheckSummaryManager.CheckAndDeleteAsync(RegisterCheckIds.ToList());

                    //删除registerCheckPicture
                    await _registerCheckPictureManager.CheckAndDeleteAsync(RegisterCheckIds.ToList());

                    //删除registerCheckItem
                    await _registerCheckItemManager.CheckAndDeleteAsync(RegisterCheckIds.ToList());


                    //删除registerCheckCriticalValue危警值
                    await _registerCheckCriticalValueManager.CheckAndDeleteAsync(RegisterCheckIds.ToList());



                    //删除registerCheck
                    await _registerCheckManager.CheckAndDeleteAsync(RegisterCheckIds.ToList());

                }
                if (RegisterAsbitemIds.Any())
                    //删除registerAsbitem
                    await _registerAsbitemManager.DeleteManyAsync(RegisterAsbitemIds.ToList());

                //var registerAsbitemList = await _registerAsbitemRepository.GetListAsync(m => RegisterAsbitemIds.Contains(m.Id));
                //if (registerAsbitemList.Any())
                //{
                //    await _registerAsbitemRepository.DeleteManyAsync(registerAsbitemList);
                //}

                //删除登记表数据
                await _repository.DeleteAsync(id);

            }
            else
            {
                throw new UserFriendlyException("数据不存在");
            }

        }


        /// <summary>
        /// 更改总检审核医生信息（保存时，医生跟日期不传时取默认登录的用户跟当前时间；取消时，如果不传就不更新医生跟日期，只更新状态）
        /// </summary>
        /// <param name="entitydto"></param>
        /// <param name="entity"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        public async Task<PatientRegister> UpdatePatientRegisterAuditorDoctorAsync(
            PatientRegister entitydto,
            PatientRegister entity)
        {
            if (entity == null)
            {
                throw new UserFriendlyException("请求参数有误");
            }
            VerifyUpdate(entity);
            if (entitydto.IsAudit == 'Y')
            {

                if (entitydto.AuditDoctorId == null || entitydto.AuditDoctorId == Guid.Empty)
                    entity.AuditDoctorId = _currentUser.Id != null ? _currentUser.Id : null;
                else
                    entity.AuditDoctorId = entitydto.AuditDoctorId;
                if (entitydto.AuditDate == null)
                    entity.AuditDate = DateTime.Now;
                else
                    entity.AuditDate = entitydto.AuditDate;
            }

            entity.IsAudit = entitydto.IsAudit;

            return await _repository.UpdateAsync(entity);
        }


        /// <summary>
        /// 更改总检检查医生信息（保存时，医生跟日期不传时取默认登录的用户跟当前时间；取消时，如果不传就不更新医生跟日期，只更新状态）
        /// </summary>
        /// <param name="entitydto"></param>
        /// <param name="entity"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        public async Task<PatientRegister> UpdatePatientRegisterSummaryDoctorAsync(
            PatientRegister entitydto,
            PatientRegister entity)
        {
            if (entity == null)
            {
                throw new UserFriendlyException("请求参数有误");
            }

            VerifyUpdate(entity);

            if (entitydto.SummaryDoctorId == null || entitydto.SummaryDoctorId == Guid.Empty)
                entity.SummaryDoctorId = _currentUser.Id != null ? _currentUser.Id : null;
            else
                entity.SummaryDoctorId = entitydto.SummaryDoctorId;

            if (entitydto.SummaryDate == null)
                entity.SummaryDate = DateTime.Now;
            else
                entity.SummaryDate = entitydto.SummaryDate;

            entity.CompleteFlag = PatientRegisterCompleteFlag.SumCheck;

            entity.MedicalConclusionId = entitydto.MedicalConclusionId;

            return await _repository.UpdateAsync(entity);
        }


        public void VerifyUpdate(PatientRegister entity)
        {
            if (entity.IsLock == 'Y')
            {
                throw new UserFriendlyException("已加锁，不能更新");
            }
        }
    }
}