WingCloudServer/src/VitalMixtureService/DBService/Service/PatientDBService.cs

using MongoDB.Driver;
using System.Text;
using VitalService.Common;
using WingServerCommon.Mapper;
using VitalService.Entities;
using VitalService.Request;
using WingInterfaceLibrary.Interface.DBVitalInterface;
using WingInterfaceLibrary.Request.DBVitalRequest;
using WingInterfaceLibrary.Enum.VitalEnum;
using WingInterfaceLibrary.DTO.Vital;
using WingInterfaceLibrary.Request;
using System;
using WingServerCommon.Log;
using WingInterfaceLibrary.DB.Request;
using System.Text.RegularExpressions;
using WingInterfaceLibrary.Enum;

namespace VitalService.Service
{
    /// <summary>
    /// 居民数据服务
    /// </summary>
    public partial class VitalDatabaseService : IVitalPatientDBService
    {
        private IEncrypt _encryptInstance = new DBEncryptHelper();
        /// <summary>
        /// 创建居民数据
        /// </summary>
        /// <param name="request">创建请求</param>
        /// <returns></returns>
        public async Task<string> CreatePatientAsync(CreatePatientDBRequest request)
        {
            try
            {
                AddDoctorCode(request.OperationDoctor);
                StringBuilder logBuilder = new StringBuilder();
                var entity = request.MappingTo<PatientEntity>();
                var permissionInfo = await SetPatientRequestCreatedFrom(entity, request.OperationDoctor);
                if (permissionInfo.team == null || string.IsNullOrWhiteSpace(permissionInfo.team.Code))
                {
                    ThrowRpcException(CustomerRpcCode.TeamNotSet, "Team not set");
                }
                if (!string.IsNullOrWhiteSpace(request.Code))
                {
                    var filter = Builders<PatientEntity>.Filter.Eq(x => x.Code, request.Code);
                    var patientInfo = await _patientDBRepository.FindOneAsync(filter, null, false);
                    if (patientInfo != null)
                    {
                        string doctorChange = string.Empty;
                        string orgChange = string.Empty;
                        string teamChange = string.Empty;
                        patientInfo = Decrypt(patientInfo);
                        var patientFilter = Builders<PatientEntity>.Filter.Eq(x => x.Code, request.Code);
                        var patientsUpdate = new List<UpdateDefinition<PatientEntity>>();
                        if (!string.IsNullOrWhiteSpace(request.PatientName) && patientInfo.PatientName != request.PatientName)
                        {
                            logBuilder.AppendLine($"居民姓名从{patientInfo.PatientName}变更为{request.PatientName}");
                            patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.PatientName, _encryptInstance.Encrypt(request.PatientName)));
                        }
                        if (!string.IsNullOrWhiteSpace(request.PatientAddress) && patientInfo.PatientAddress != request.PatientAddress)
                        {
                            logBuilder.AppendLine($"居民地址从{patientInfo.PatientAddress}变更为{request.PatientAddress}");
                            patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.PatientAddress, _encryptInstance.Encrypt(request.PatientAddress)));
                        }
                        if (!string.IsNullOrWhiteSpace(request.PermanentResidenceAddress) && patientInfo.PermanentResidenceAddress != request.PermanentResidenceAddress)
                        {
                            logBuilder.AppendLine($"户籍地址从{patientInfo.PermanentResidenceAddress}变更为{request.PermanentResidenceAddress}");
                            patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.PermanentResidenceAddress, _encryptInstance.Encrypt(request.PermanentResidenceAddress)));
                        }
                        if (!string.IsNullOrWhiteSpace(request.Phone) && patientInfo.Phone != request.Phone)
                        {
                            logBuilder.AppendLine($"居民电话从{patientInfo.Phone}变更为{request.Phone}");
                            patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.Phone, _encryptInstance.Encrypt(request.Phone)));
                        }
                        if (!string.IsNullOrWhiteSpace(request.EmergencyName) && patientInfo.EmergencyName != request.EmergencyName)
                        {
                            logBuilder.AppendLine($"居民紧急联系人从{patientInfo.EmergencyName}变更为{request.EmergencyName}");
                            patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.EmergencyName, _encryptInstance.Encrypt(request.EmergencyName)));
                        }
                        if (!string.IsNullOrWhiteSpace(request.EmergencyPhone) && patientInfo.EmergencyPhone != request.EmergencyPhone)
                        {
                            logBuilder.AppendLine($"居民紧急联系电话从{patientInfo.EmergencyPhone}变更为{request.EmergencyPhone}");
                            patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.EmergencyPhone, _encryptInstance.Encrypt(request.EmergencyPhone)));
                        }
                        if (!string.IsNullOrWhiteSpace(request.Nationality) && patientInfo.Nationality != request.Nationality)
                        {
                            logBuilder.AppendLine($"民族从{patientInfo.Nationality}变更为{request.Nationality}");
                            patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.Nationality, request.Nationality));
                        }
                        if (request.Birthday != null && patientInfo.Birthday != request.Birthday)
                        {
                            logBuilder.AppendLine($"出生日期从{patientInfo.Birthday.ToString("yyyy-MM-dd")}变更为{request.Birthday.ToString("yyyy-MM-dd")}");
                            patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.Birthday, request.Birthday));
                        }
                        if (patientInfo.PatientGender != request.PatientGender)
                        {
                            logBuilder.AppendLine($"性别从{patientInfo.PatientGender}变更为{request.PatientGender}");
                            patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.PatientGender, request.PatientGender));
                        }
                        if (!string.IsNullOrWhiteSpace(entity.CreatedDoctor) && patientInfo.CreatedDoctor != entity.CreatedDoctor)
                        {
                            logBuilder.AppendLine($"建档医生从'{patientInfo.CreatedDoctor}'变更为'{entity.CreatedDoctor}';");
                            patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.CreatedDoctor, entity.CreatedDoctor));
                            AddDoctorCode(patientInfo.CreatedDoctor);
                        }
                        if (!string.IsNullOrWhiteSpace(entity.CreatedOrgCode) && patientInfo.CurrentOrgCode != entity.CreatedOrgCode)
                        {
                            logBuilder.AppendLine($"归档机构从'{patientInfo.CurrentOrgCode}'变更为'{entity.CreatedOrgCode}';");
                            patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.CurrentOrgCode, entity.CreatedOrgCode));
                        }
                        if (!string.IsNullOrWhiteSpace(entity.CreatedTeamCode) && patientInfo.CurrentTeamCode != entity.CreatedTeamCode)
                        {
                            logBuilder.AppendLine($"归档团队从'{patientInfo.CurrentTeamCode}'变更为'{entity.CreatedTeamCode}';");
                            patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.CurrentTeamCode, entity.CreatedTeamCode));
                        }
                        if (!AreEqual(patientInfo.CrowdLabels, entity.CrowdLabels))
                        {
                            logBuilder.AppendLine($"人群分类从'{string.Join(";", patientInfo.CrowdLabels ?? new List<string>())}'变更为'{string.Join(";", entity.CrowdLabels ?? new List<string>())}';");
                            patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.CrowdLabels, entity.CrowdLabels ?? new List<string>()));
                        }
                        if (!string.IsNullOrWhiteSpace(entity.ArchivedDoctorName) && patientInfo.ArchivedDoctorName != entity.ArchivedDoctorName)
                        {
                            patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.ArchivedDoctorName, entity.ArchivedDoctorName));
                        }

                        Logger.WriteLineWarn($"VitalPatientDBService CreatePatientAsync update, request: {Newtonsoft.Json.JsonConvert.SerializeObject(entity)}");
                        patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.IsDelete, false));
                        if (logBuilder.Length > 0)
                        {
                            Logger.WriteLineInfo($"{logBuilder}");
                        }
                        var updateAll = Builders<PatientEntity>.Update.Combine(patientsUpdate);
                        await _patientDBRepository.UpdateOneAsync(patientFilter, updateAll, false);
                        return patientInfo.Code;
                    }
                }
                entity = Encrypt(entity);
                entity.CurrentOrgCode = entity.CreatedOrgCode;
                entity.CurrentTeamCode = entity.CreatedTeamCode;
                Logger.WriteLineWarn($"VitalPatientDBService CreatePatientAsync insert, request: {Newtonsoft.Json.JsonConvert.SerializeObject(entity)}");
                return await _patientDBRepository.InsertOneAsync(entity);
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"VitalPatientDBService CreatePatientAsync failed, ex:{ex}, request: {Newtonsoft.Json.JsonConvert.SerializeObject(request)}");
            }
            return string.Empty;
        }

        /// <summary>
        /// 根据编码获取居民数据
        /// </summary>
        /// <param name="request">获取请求</param>
        /// <returns></returns>
        public async Task<PatientDTO> GetPatientDetailAsync(GetPatientDBRequest request)
        {
            var filter = Builders<PatientEntity>.Filter.Eq(x => x.Code, request.Code);
            if (request.IsValidOperationDoctor)
            {
                filter = await AddPermissionPatientFilter(filter, request.OperationDoctor);
            }
            var result = await _patientDBRepository.FindOneAsync(filter);
            return await ConvertToDTO(result);
        }

        /// <summary>
        /// 根据编码获取居民数据
        /// </summary>
        /// <param name="request">获取请求</param>
        /// <returns></returns>
        public async Task<PatientDTO> GetPatientByCodeAsync(GetPatientByCodeDBRequest request)
        {
            var filter = Builders<PatientEntity>.Filter.Eq(x => x.Code, request.Code);
            var result = await _patientDBRepository.FindOneAsync(filter);
            return await ConvertToDTO(result);
        }

        /// <summary>
        /// 根据编码获取居民数据如非同一团队则迁移人员
        /// </summary>
        /// <param name="request">获取请求</param>
        /// <returns></returns>
        public async Task<PatientDTO> GetPatientDetailOrMoveAsync(GetPatientDBRequest request)
        {
            var filter = Builders<PatientEntity>.Filter.Eq(x => x.Code, request.Code);
            filter = await AddPermissionPatientFilter(filter, request.OperationDoctor);
            var result = await _patientDBRepository.FindOneAsync(filter);
            if (result == null)
            {
                filter = Builders<PatientEntity>.Filter.Eq(x => x.Code, request.Code);
                var patientInfo = await _patientDBRepository.FindOneAsync(filter);
                if (patientInfo != null)
                {
                    string doctorChange = string.Empty;
                    string orgChange = string.Empty;
                    string teamChange = string.Empty;
                    var oldPatientInfo = Decrypt(patientInfo);
                    var newPatientInfo = new PatientEntity();
                    await SetPatientRequestCreatedFrom(newPatientInfo, request.OperationDoctor);
                    var patientFilter = Builders<PatientEntity>.Filter.Eq(x => x.Code, request.Code);
                    var patientsUpdate = new List<UpdateDefinition<PatientEntity>>();
                    if (!string.IsNullOrWhiteSpace(newPatientInfo.CreatedDoctor) && patientInfo.CreatedDoctor != newPatientInfo.CreatedDoctor)
                    {
                        doctorChange = $"建档医生从'{patientInfo.CreatedDoctor}'变更为'{newPatientInfo.CreatedDoctor}';";
                        patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.CreatedDoctor, newPatientInfo.CreatedDoctor));
                    }
                    if (!string.IsNullOrWhiteSpace(newPatientInfo.CreatedOrgCode) && patientInfo.CurrentOrgCode != newPatientInfo.CreatedOrgCode)
                    {
                        orgChange = $"建档机构从'{patientInfo.CurrentOrgCode}'变更为'{newPatientInfo.CreatedOrgCode}';";
                        patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.CurrentOrgCode, newPatientInfo.CreatedOrgCode));
                    }
                    if (!string.IsNullOrWhiteSpace(newPatientInfo.CreatedTeamCode) && patientInfo.CurrentTeamCode != newPatientInfo.CreatedTeamCode)
                    {
                        teamChange = $"建档团队从'{patientInfo.CurrentTeamCode}'变更为'{newPatientInfo.CreatedTeamCode}';";
                        patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.CurrentTeamCode, newPatientInfo.CreatedTeamCode));
                    }
                    if (!string.IsNullOrWhiteSpace(newPatientInfo.ArchivedDoctorName) && patientInfo.ArchivedDoctorName != newPatientInfo.ArchivedDoctorName)
                    {
                        patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.ArchivedDoctorName, newPatientInfo.ArchivedDoctorName));
                    }
                    patientsUpdate.Add(Builders<PatientEntity>.Update.Set(x => x.IsDelete, false));
                    if (!string.IsNullOrWhiteSpace(doctorChange) || !string.IsNullOrWhiteSpace(orgChange) || !string.IsNullOrWhiteSpace(teamChange))
                    {
                        Logger.WriteLineInfo($"{orgChange}{teamChange}{doctorChange}");
                    }
                    var updateAll = Builders<PatientEntity>.Update.Combine(patientsUpdate);
                    if (await _patientDBRepository.UpdateOneAsync(filter, updateAll, false) > 0)
                    {
                        await SetPatientRequestCreatedFrom(patientInfo, request.OperationDoctor);
                        result = patientInfo;
                    }
                }
            }
            return await ConvertToDTO(result);
        }

        /// <summary>
        /// 根据关键字段获取居民数据
        /// </summary>
        /// <param name="request">获取请求</param>
        /// <returns></returns>
        public async Task<PatientDTO> GetPatientDetailByKeyAsync(GetPatientByKeyDBRequest request)
        {
            var filter = Builders<PatientEntity>.Filter.Eq(request.Key, request.Value);
            filter = await AddPermissionPatientFilter(filter, request.OperationDoctor);
            var result = await _patientDBRepository.FindOneAsync(filter);
            return await ConvertToDTO(result);
        }

        /// <summary>
        /// 获取居民数据分页
        /// </summary>
        /// <param name="request">分页请求</param>
        /// <returns></returns>
        public async Task<PageCollection<PatientDTO>> GetPatientPageAsync(PatientPageDBRequest request)
        {
            var filter = await _patientDBRepository.GetPageFilter(request);
            filter = await AddPermissionPatientFilter(filter, request.OperationDoctor);
            if (request.CrowdLabels != null && request.CrowdLabels.Count > 0)
            {
                var crowdLabelsFilter = Builders<PatientEntity>.Filter.AnyIn(f => f.CrowdLabels, request.CrowdLabels);
                filter = Builders<PatientEntity>.Filter.And(filter, crowdLabelsFilter);
            }
            if (request.PatientCodes != null && request.PatientCodes.Count > 0)
            {
                var patientCodesFilter = Builders<PatientEntity>.Filter.In(f => f.Code, request.PatientCodes);
                filter = Builders<PatientEntity>.Filter.And(filter, patientCodesFilter);
            }
            var pageFilter = new DBPageRequest<PatientEntity>
            {
                PageIndex = request.PageIndex,
                PageSize = request.PageSize,
                Filter = filter,
                Sort = Builders<PatientEntity>.Sort.Descending(x => x.UpdateTime)
            };
            var result = await _patientDBRepository.GetPages(pageFilter);
            var data = await ConvertToDTOPage(result);
            return data;
        }


        /// <summary>
        /// 删除居民数据
        /// </summary>
        /// <param name="request">删除请求</param>
        /// <returns></returns>
        public async Task<bool> RemovePatientAsync(RemovePatientDBRequest request)
        {
            AddDoctorCode(request.OperationDoctor);
            var filter2 = Builders<PatientEntity>.Filter.Eq(f => f.Code, request.Code);
            var update = Builders<PatientEntity>.Update
                .Set(f => f.IsDelete, true)
                .Set(f => f.Photos, new List<string>())
                .Set(f => f.UpdateTime, DateTime.UtcNow);
            return await _patientDBRepository.UpdateOneAsync(filter2, update, false) > 0;
        }

        /// <summary>
        /// 删除多个居民数据
        /// </summary>
        /// <param name="request">删除请求</param>
        /// <returns></returns>
        public async Task<long> RemovePatientListAsync(RemovePatientListDBRequest request)
        {
            AddDoctorCode(request.OperationDoctor);
            var filter = new List<(string key, string val)>();
            foreach (var code in request.Codes)
            {
                filter.Add(("Code", code));
            }
            return await _patientDBRepository.DeleteAllAsync(filter);
        }

        /// <summary>
        /// 获取居民数据列表
        /// </summary>
        /// <param name="request">列表请求</param>
        /// <returns></returns>
        public async Task<List<PatientDTO>> GetPatientListAsync(GetPatientListDBRequest request)
        {
            var filter = Builders<PatientEntity>.Filter.In(f => f.Code, request.Codes);
            if (request.IsValidOperationDoctor)
            {
                filter = await AddPermissionPatientFilter(filter, request.OperationDoctor);
            }
            var result = await _patientDBRepository.FindAllAsync(filter, new FindOptions<PatientEntity> { Sort = Builders<PatientEntity>.Sort.Descending(f => f.UpdateTime) });
            return await ConvertToDTOList(result);
        }

        /// <summary>
        /// 根据关键字段获取居民数据列表
        /// </summary>
        /// <param name="request">列表请求</param>
        /// <returns></returns>
        public async Task<List<PatientDTO>> GetPatientListByKeyAsync(GetPatientListByKeyDBRequest request)
        {
            var filter = Builders<PatientEntity>.Filter.Eq(request.Key, request.Value);
            filter = await AddPermissionPatientFilter(filter, request.OperationDoctor);
            var result = await _patientDBRepository.FindAllAsync(filter, new FindOptions<PatientEntity> { Sort = Builders<PatientEntity>.Sort.Descending(f => f.UpdateTime) });
            return await ConvertToDTOList(result);
        }

        /// <summary>
        /// 更新居民数据
        /// </summary>
        /// <param name="request">更新请求</param>
        /// <returns></returns>
        public async Task<bool> UpdatePatientAsync(UpdatePatientDBRequest request)
        {
            AddDoctorCode(request.OperationDoctor);
            var filter = Builders<PatientEntity>.Filter.Eq(f => f.Code, request.Code);
            var updates = new List<UpdateDefinition<PatientEntity>>();
            if (request.PatientName != "-1")
            {
                updates.Add(Builders<PatientEntity>.Update.Set(f => f.PatientName, _encryptInstance.Encrypt(request.PatientName)));
            }
            if (request.Phone != "-1")
            {
                updates.Add(Builders<PatientEntity>.Update.Set(f => f.Phone, _encryptInstance.Encrypt(request.Phone)));
            }
            if (request.EmergencyPhone != "-1")
            {
                updates.Add(Builders<PatientEntity>.Update.Set(f => f.EmergencyPhone, _encryptInstance.Encrypt(request.EmergencyPhone)));
            }
            if (request.EmergencyName != "-1")
            {
                updates.Add(Builders<PatientEntity>.Update.Set(f => f.EmergencyName, _encryptInstance.Encrypt(request.EmergencyName)));
            }
            if (request.CardNo != "-1")
            {
                updates.Add(Builders<PatientEntity>.Update.Set(f => f.CardNo, _encryptInstance.Encrypt(request.CardNo)));
            }
            if (request.Nationality != "-1")
            {
                updates.Add(Builders<PatientEntity>.Update.Set(f => f.Nationality, request.Nationality));
            }
            if (request.PatientAddress != "-1")
            {
                updates.Add(Builders<PatientEntity>.Update.Set(f => f.PatientAddress, _encryptInstance.Encrypt(request.PatientAddress)));
            }
            if (request.PermanentResidenceAddress != "-1")
            {
                updates.Add(Builders<PatientEntity>.Update.Set(f => f.PermanentResidenceAddress, _encryptInstance.Encrypt(request.PermanentResidenceAddress)));
            }
            if (request.TeamRegionCode != "-1")
            {
                updates.Add(Builders<PatientEntity>.Update.Set(f => f.TeamRegionCode, request.TeamRegionCode));
            }
            if (request.ContractedDoctor != "-1")
            {
                updates.Add(Builders<PatientEntity>.Update.Set(f => f.ContractedDoctor, request.ContractedDoctor));
            }
            if (request.PatientGender != null)
            {
                updates.Add(Builders<PatientEntity>.Update.Set(f => f.PatientGender, request.PatientGender));
            }
            if (request.CardType != null)
            {
                updates.Add(Builders<PatientEntity>.Update.Set(f => f.CardType, request.CardType));
            }
            if (request.CrowdLabels != null)
            {
                updates.Add(Builders<PatientEntity>.Update.Set(f => f.CrowdLabels, request.CrowdLabels));
            }
            if (request.Birthday != null)
            {
                updates.Add(Builders<PatientEntity>.Update.Set(f => f.Birthday, request.Birthday));
            }
            updates.Add(Builders<PatientEntity>.Update.Set(f => f.IsDelete, false));
            var update = Builders<PatientEntity>.Update.Combine(updates);
            return await _patientDBRepository.UpdateOneAsync(filter, update) > 0;
        }

        /// <summary>
        /// 更新居民照片数据
        /// </summary>
        /// <param name="request">更新请求</param>
        /// <returns>true</returns>
        public async Task<bool> UpdatePatientPhotosAsync(UpdatePatientPhotosDBRequest request)
        {
            var filter = Builders<PatientEntity>.Filter.Eq(f => f.Code, request.Code);
            var update = Builders<PatientEntity>.Update.Set(s => s.Photos, request.Photos).Set(s => s.UpdateTime, DateTime.UtcNow);
            return await _patientDBRepository.UpdateOneAsync(filter, update) > 0;
        }


        public async Task<PatientStatisticDTO> GetPatientStatisticDBAsync(GetPatientStatisticDBRequest request)
        {
            var filter = Builders<UserEntity>.Filter.Eq(f => f.Code, request.OperationDoctor);
            var user = await _userDBRepository.FindOneAsync(filter);
            var teamCode = user.TeamCode;
            var teamPatientsFilter = Builders<PatientEntity>.Filter.Eq(f => f.CurrentTeamCode, teamCode);
            var teamPatients = await _patientDBRepository.FindAllAsync(teamPatientsFilter, new FindOptions<PatientEntity> { Projection = Builders<PatientEntity>.Projection.Include(p => p.CreateTime).Include(p => p.Code) });
            var dto = new PatientStatisticDTO();
            dto.Count = teamPatients.Count();
            dto.TodayCount = teamPatients.Where(w => w.CreateTime.ToLocalTime().Date == DateTime.Now.Date).Count();
            return dto;
        }

        /// <summary>
        /// 分页查询增量居民信息集合
        /// </summary>
        /// <returns></returns>
        public async Task<PageCollection<PatientDTO>> FindPatientByUpdateTimeDBAsync(FindCollectionByTimeDBRequest request)
        {
            var startTime = request.StartTime;
            var pageIndex = request.PageIndex;
            var pageSize = request.PageSize;

            var builder = Builders<PatientEntity>.Filter;
            var filter = builder.Where(c => c.UpdateTime > startTime);

            var pageFilter = new DBPageRequest<PatientEntity>
            {
                PageIndex = request.PageIndex,
                PageSize = request.PageSize,
                Filter = filter,
                Sort = Builders<PatientEntity>.Sort.Ascending(x => x.UpdateTime)
            };
            var pagedResult = await _patientDBRepository.GetPages(pageFilter, onlyNotDeleted: false);

            var pageData = new List<PatientDTO>();
            if (pagedResult.PageData?.Any() ?? false)
            {
                foreach (var entity in pagedResult.PageData)
                {
                    var dto = entity.MappingTo<PatientDTO>();
                    pageData.Add(dto);
                }
            }
            var result = new PageCollection<PatientDTO>
            {
                DataCount = pagedResult.DataCount,
                CurrentPage = pagedResult.CurrentPage,
                PageSize = pagedResult.PageSize,
                PageData = pageData,
            };
            return result;
        }

        /// <summary>
        /// 保存居民记录
        /// </summary>
        /// <returns></returns>
        public async Task<bool> SavePatientInfoDBAsync(PatientDTO request)
        {
            try
            {
                var code = request.Code;
                var patientDO = request.MappingTo<PatientEntity>();

                var filter = Builders<PatientEntity>.Filter.Eq(f => f.Code, code);
                var entity = await _patientDBRepository.FindOneAsync(filter, onlyNotDeleted: false);
                if (entity != null && !string.IsNullOrWhiteSpace(entity.Code))
                {
                    var filter2 = Builders<PatientEntity>.Filter.Eq(f => f.Code, code);
                    var update = Builders<PatientEntity>.Update
                        .Set(f => f.RecordNo, patientDO.RecordNo)
                        .Set(f => f.PatientName, patientDO.PatientName)
                        .Set(f => f.Phone, patientDO.Phone)
                        .Set(f => f.EmergencyPhone, patientDO.EmergencyPhone)
                        .Set(f => f.EmergencyName, patientDO.EmergencyName)
                        .Set(f => f.CardNo, patientDO.CardNo)
                        .Set(f => f.Nationality, patientDO.Nationality)
                        .Set(f => f.Birthday, patientDO.Birthday)
                        .Set(f => f.CrowdLabels, patientDO.CrowdLabels)
                        .Set(f => f.CardType, patientDO.CardType)
                        .Set(f => f.PatientGender, patientDO.PatientGender)
                        .Set(f => f.PatientAddress, patientDO.PatientAddress)
                        .Set(f => f.PermanentResidenceAddress, patientDO.PermanentResidenceAddress)
                        .Set(f => f.TeamRegionCode, patientDO.TeamRegionCode)
                        .Set(f => f.ContractedDoctor, patientDO.ContractedDoctor)
                        .Set(f => f.Status, patientDO.Status)
                        .Set(f => f.Photos, patientDO.Photos)
                        .Set(f => f.CurrentTeamCode, patientDO.CurrentTeamCode)
                        .Set(f => f.CurrentOrgCode, patientDO.CurrentOrgCode)
                        .Set(f => f.CreatedOrgCode, patientDO.CreatedOrgCode)
                        .Set(f => f.CreatedTeamCode, patientDO.CreatedTeamCode)
                        .Set(f => f.CreatedDoctor, patientDO.CreatedDoctor)
                        .Set(f => f.ArchivedDoctorName, patientDO.ArchivedDoctorName)
                        .Set(f => f.IsDelete, patientDO.IsDelete)
                        .Set(f => f.CreateTime, patientDO.CreateTime)
                        .Set(f => f.UpdateTime, patientDO.UpdateTime);
                    await _patientDBRepository.UpdateOneAsync(filter2, update, false, false);
                }
                else
                {
                    await _patientDBRepository.InsertOneAsync(patientDO, false);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"ExamDBService SavePatientInfoDBAsync failed, ex:{ex}");
            }
            return true;
        }

        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        private PatientEntity Encrypt(PatientEntity entity)
        {
            if (!string.IsNullOrWhiteSpace(entity.CardNo))
            {
                entity.CardNo = _encryptInstance.Encrypt(entity.CardNo);
            }
            if (!string.IsNullOrWhiteSpace(entity.PatientAddress))
            {
                entity.PatientAddress = _encryptInstance.Encrypt(entity.PatientAddress);
            }
            if (!string.IsNullOrWhiteSpace(entity.PermanentResidenceAddress))
            {
                entity.PermanentResidenceAddress = _encryptInstance.Encrypt(entity.PermanentResidenceAddress);
            }
            if (!string.IsNullOrWhiteSpace(entity.PatientName))
            {
                entity.PatientName = _encryptInstance.Encrypt(entity.PatientName);
            }
            if (!string.IsNullOrWhiteSpace(entity.Phone))
            {
                entity.Phone = _encryptInstance.Encrypt(entity.Phone);
            }
            if (!string.IsNullOrWhiteSpace(entity.EmergencyPhone))
            {
                entity.EmergencyPhone = _encryptInstance.Encrypt(entity.EmergencyPhone);
            }
            if (!string.IsNullOrWhiteSpace(entity.EmergencyName))
            {
                entity.EmergencyName = _encryptInstance.Encrypt(entity.EmergencyName);
            }
            return entity;
        }

        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        private PatientDTO Decrypt(PatientDTO dto)
        {
            if (!string.IsNullOrWhiteSpace(dto.CardNo))
            {
                dto.CardNo = _encryptInstance.Decrypt(dto.CardNo);
            }
            if (!string.IsNullOrWhiteSpace(dto.PatientAddress))
            {
                dto.PatientAddress = _encryptInstance.Decrypt(dto.PatientAddress);
            }
            if (!string.IsNullOrWhiteSpace(dto.PermanentResidenceAddress))
            {
                dto.PermanentResidenceAddress = _encryptInstance.Decrypt(dto.PermanentResidenceAddress);
            }
            if (!string.IsNullOrWhiteSpace(dto.PatientName))
            {
                dto.PatientName = _encryptInstance.Decrypt(dto.PatientName);
            }
            if (!string.IsNullOrWhiteSpace(dto.Phone))
            {
                dto.Phone = _encryptInstance.Decrypt(dto.Phone);
            }
            if (!string.IsNullOrWhiteSpace(dto.EmergencyPhone))
            {
                dto.EmergencyPhone = _encryptInstance.Decrypt(dto.EmergencyPhone);
            }
            if (!string.IsNullOrWhiteSpace(dto.EmergencyName))
            {
                dto.EmergencyName = _encryptInstance.Decrypt(dto.EmergencyName);
            }
            return dto;
        }

        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        private PatientEntity Decrypt(PatientEntity entity)
        {
            if (!string.IsNullOrWhiteSpace(entity.CardNo))
            {
                entity.CardNo = _encryptInstance.Decrypt(entity.CardNo);
            }
            if (!string.IsNullOrWhiteSpace(entity.PatientAddress))
            {
                entity.PatientAddress = _encryptInstance.Decrypt(entity.PatientAddress);
            }
            if (!string.IsNullOrWhiteSpace(entity.PermanentResidenceAddress))
            {
                entity.PermanentResidenceAddress = _encryptInstance.Decrypt(entity.PermanentResidenceAddress);
            }
            if (!string.IsNullOrWhiteSpace(entity.PatientName))
            {
                entity.PatientName = _encryptInstance.Decrypt(entity.PatientName);
            }
            if (!string.IsNullOrWhiteSpace(entity.Phone))
            {
                entity.Phone = _encryptInstance.Decrypt(entity.Phone);
            }
            if (!string.IsNullOrWhiteSpace(entity.EmergencyName))
            {
                entity.EmergencyName = _encryptInstance.Decrypt(entity.EmergencyName);
            }
            if (!string.IsNullOrWhiteSpace(entity.EmergencyPhone))
            {
                entity.EmergencyPhone = _encryptInstance.Decrypt(entity.EmergencyPhone);
            }
            return entity;
        }

        private async Task<PatientDTO> ConvertToDTO(PatientEntity entity)
        {
            if (entity == null) return null;
            var dto = entity.MappingTo<PatientDTO>();
            if (!string.IsNullOrWhiteSpace(entity.CurrentOrgCode))
            {
                var filter = Builders<OrganizationEntity>.Filter.Eq(f => f.Code, entity.CurrentOrgCode);
                var org = await _organizationDBRepository.FindOneAsync(filter);
                dto.CreatedOrgName = org?.OrganizationName;
            }
            if (!string.IsNullOrWhiteSpace(entity.CurrentTeamCode))
            {
                var filter = Builders<TeamEntity>.Filter.Eq(f => f.Code, entity.CurrentTeamCode);
                var team = await _teamDBRepository.FindOneAsync(filter);
                dto.CreatedTeamName = team?.TeamName;
            }
            if (!string.IsNullOrWhiteSpace(entity.Code))
            {
                var filter = Builders<ContractRecordEntity>.Filter.Eq(f => f.ContractedPatient, entity.Code);
                var contractRecord = await _contractRecordDBRepository.FindOneAsync(filter);
                if (!string.IsNullOrWhiteSpace(contractRecord?.ContractedDoctor))
                {
                    var filterUser = Builders<UserEntity>.Filter.Eq(f => f.Code, contractRecord?.ContractedDoctor);
                    var userInfo = await _userDBRepository.FindOneAsync(filterUser);
                    dto.ContractedDoctorName = !string.IsNullOrWhiteSpace(userInfo.RealName) ? userInfo.RealName : userInfo.UserName;
                }
            }
            if (!string.IsNullOrWhiteSpace(entity.CreatedDoctor))
            {
                var filter = Builders<UserEntity>.Filter.Eq(f => f.Code, entity.CreatedDoctor);
                var userInfo = await _userDBRepository.FindOneAsync(filter);
                if (userInfo != null && !string.IsNullOrWhiteSpace(userInfo.Code))
                {
                    dto.CreatedDoctorName = !string.IsNullOrWhiteSpace(userInfo.RealName) ? userInfo.RealName : userInfo.UserName;
                }
            }
            if (string.IsNullOrWhiteSpace(dto.CreatedDoctorName))
            {
                dto.CreatedDoctorName = dto.ArchivedDoctorName;
            }
            FillingPersopnType(entity);
            dto.CrowdLabels = entity.CrowdLabels;
            if (entity.CrowdLabels != null && entity.CrowdLabels.Count > 0)
            {
                var filterLabel = Builders<LabelEntity>.Filter.In(f => f.LabelTypeKey, new List<string> { "RQFL", "CJJB", "TSZG" });
                var labels = await _labelDBRepository.FindAllAsync(filterLabel);
                dto.LabelNames = labels?.Where(w => entity.CrowdLabels.Contains(w.Code)).Select(f => f.LabelName).ToList();
            }
            if (!string.IsNullOrWhiteSpace(entity.Code))
            {
                var contractFilter = Builders<ContractRecordEntity>.Filter.Eq(f => f.ContractedPatient, entity.Code);
                var contract = await _contractRecordDBRepository.FindOneAsync(contractFilter, new FindOptions<ContractRecordEntity> { Sort = Builders<ContractRecordEntity>.Sort.Descending(f => f.UpdateTime) });
                dto.ContractState = contract?.ContractState ?? ContractStateEnum.Unsigned;
            }
            return Decrypt(dto);
        }

        private async Task<List<PatientDTO>> ConvertToDTOList(List<PatientEntity> entitys)
        {
            if (entitys == null || entitys.Count == 0) return new List<PatientDTO>();
            var userCodes = entitys.Select(f => f.ContractedDoctor).Union(entitys.Select(f => f.CreatedDoctor)).Distinct();
            var filterUsers = Builders<UserEntity>.Filter.In(f => f.Code, userCodes);
            var usersInfo = await _userDBRepository.FindAllAsync(filterUsers);

            var orgCodes = usersInfo.Select(u => u.OrganizationCode).Union(entitys.Select(f => f.CreatedOrgCode)).Union(entitys.Select(f => f.CurrentOrgCode)).Distinct();
            var filterOrgs = Builders<OrganizationEntity>.Filter.In(f => f.Code, orgCodes);
            var orgsInfo = await _organizationDBRepository.FindAllAsync(filterOrgs);

            var teamCodes = entitys.Select(f => f.CurrentTeamCode).Union(entitys.Select(f => f.CreatedTeamCode)).Union(entitys.Select(f => f.CurrentTeamCode)).Distinct();
            var filterTeams = Builders<TeamEntity>.Filter.In(f => f.Code, teamCodes);
            var teamsInfo = await _teamDBRepository.FindAllAsync(filterTeams);

            var filterLabel = Builders<LabelEntity>.Filter.In(f => f.LabelTypeKey, new List<string> { "RQFL", "CJJB", "TSZG" });
            var labels = await _labelDBRepository.FindAllAsync(filterLabel);

            var patientCodes = entitys.Select(f => f.Code).Distinct();
            var contractFilter = Builders<ContractRecordEntity>.Filter.In(f => f.ContractedPatient, patientCodes);
            var contracts = await _contractRecordDBRepository.FindAllAsync(contractFilter, new FindOptions<ContractRecordEntity> { Projection = Builders<ContractRecordEntity>.Projection.Exclude(f => f.ContractedFileUrl).Exclude(f => f.Photos) });

            var resultList = new List<PatientDTO>();
            foreach (var entity in entitys)
            {
                if (entity == null)
                {
                    continue;
                }
                var record = entity.MappingTo<PatientDTO>();
                if (!string.IsNullOrWhiteSpace(entity.ContractedDoctor))
                {
                    var userInfo = usersInfo.FirstOrDefault(w => w.Code == entity.ContractedDoctor);
                    record.ContractedDoctorName = !string.IsNullOrWhiteSpace(userInfo?.RealName) ? userInfo.RealName : userInfo?.UserName;
                }
                if (!string.IsNullOrWhiteSpace(entity.CreatedDoctor))
                {
                    var userInfo = usersInfo.FirstOrDefault(w => w.Code == entity.CreatedDoctor);
                    record.CreatedDoctorName = !string.IsNullOrWhiteSpace(userInfo?.RealName) ? userInfo.RealName : userInfo?.UserName;
                }
                if (string.IsNullOrWhiteSpace(record.CreatedDoctorName))
                {
                    record.CreatedDoctorName = record.ArchivedDoctorName;
                }
                if (!string.IsNullOrWhiteSpace(entity.CurrentOrgCode))
                {
                    var orgInfo = orgsInfo.FirstOrDefault(w => w.Code == entity.CurrentOrgCode);
                    record.CreatedOrgName = orgInfo?.OrganizationName;
                }
                if (!string.IsNullOrWhiteSpace(entity.CurrentTeamCode))
                {
                    var teamInfo = teamsInfo.FirstOrDefault(w => w.Code == entity.CurrentTeamCode);
                    record.CreatedTeamName = teamInfo?.TeamName;
                }
                FillingPersopnType(entity);
                record.CrowdLabels = entity.CrowdLabels;
                if (entity.CrowdLabels != null && entity.CrowdLabels.Count > 0)
                {
                    record.LabelNames = labels?.Where(w => entity.CrowdLabels?.Contains(w.Code) == true).Select(f => f.LabelName).ToList();
                }
                if (!string.IsNullOrWhiteSpace(entity.Code))
                {
                    record.ContractState = contracts?.Where(w => entity.Code == w.ContractedPatient).OrderByDescending(o => o.UpdateTime).FirstOrDefault()?.ContractState ?? ContractStateEnum.Unsigned;
                }
                resultList.Add(Decrypt(record));
            }
            return resultList;
        }

        private async Task<PageCollection<PatientDTO>> ConvertToDTOPage(PageCollection<PatientEntity> entitys)
        {
            var resultPage = new PageCollection<PatientDTO>
            {
                DataCount = entitys.DataCount,
                CurrentPage = entitys.CurrentPage,
                PageSize = entitys.PageSize,
                PageData = await ConvertToDTOList(entitys.PageData)
            };
            return resultPage;
        }

        private async Task<FilterDefinition<PatientEntity>> AddPermissionPatientFilter(FilterDefinition<PatientEntity> filter, string userCode, bool skipTeamVerify = false)
        {
            var (user, org, team) = await VerifyPermission(userCode, skipTeamVerify);
            if (user.RoleCode != "Role_SystemAdministrator")
            {
                FilterDefinition<PatientEntity> orFilter = null;
                if (user.RoleCode != "Role_HeadOfInstitution")
                {
                    orFilter = Builders<PatientEntity>.Filter.Or(
                        Builders<PatientEntity>.Filter.And(Builders<PatientEntity>.Filter.Eq(x => x.CurrentOrgCode, user.OrganizationCode), Builders<PatientEntity>.Filter.Eq(x => x.CurrentTeamCode, user.TeamCode)),
                        Builders<PatientEntity>.Filter.And(Builders<PatientEntity>.Filter.Exists(x => x.CurrentOrgCode, false), Builders<PatientEntity>.Filter.Exists(x => x.CurrentTeamCode, false)),
                        Builders<PatientEntity>.Filter.And(Builders<PatientEntity>.Filter.Eq(x => x.CurrentOrgCode, null), Builders<PatientEntity>.Filter.Eq(x => x.CurrentTeamCode, null))
                    );
                }
                else
                {
                    orFilter = Builders<PatientEntity>.Filter.Or(
                        Builders<PatientEntity>.Filter.Eq(x => x.CurrentOrgCode, user.OrganizationCode),
                        Builders<PatientEntity>.Filter.And(Builders<PatientEntity>.Filter.Exists(x => x.CurrentOrgCode, false)),
                        Builders<PatientEntity>.Filter.And(Builders<PatientEntity>.Filter.Eq(x => x.CurrentOrgCode, null))
                    );
                }
                List<FilterDefinition<PatientEntity>> filterList = new()
                {
                    filter,
                    orFilter
                };
                return Builders<PatientEntity>.Filter.And(filterList);
            }
            return filter;
        }

        private async Task<(UserEntity user, OrganizationEntity org, TeamEntity team)> SetPatientRequestCreatedFrom(PatientEntity entity, string userCode, bool skipTeamVerify = false)
        {
            var (user, org, team) = await VerifyPermission(userCode, skipTeamVerify);
            entity.CreatedDoctor = user?.Code;
            entity.CreatedOrgCode = org?.Code;
            entity.CreatedTeamCode = team?.Code;
            entity.CurrentOrgCode = org?.Code;
            entity.CurrentTeamCode = team?.Code;
            entity.ArchivedDoctorName = user?.RealName ?? string.Empty;
            return (user, org, team);
        }

        public bool AreEqual(List<string> array1, List<string> array2)
        {
            try
            {
                if (array1 == null || array2 == null)
                    return array1 == array2;

                array1 = array1.OrderBy(x => x).ToList();
                array2 = array2.OrderBy(x => x).ToList();

                return array1.SequenceEqual(array2);
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"PatientDBService AreEqual failed, ex:{ex}");
                return false;
            }
        }

        private void FillingPersopnType(PatientEntity entity)
        {
            try
            {
                entity.CrowdLabels = entity.CrowdLabels?.ToList() ?? new List<string>();
                var idCardNo = entity.Code;
                if (entity.CrowdLabels.Contains("CJJB_TNB") && entity.CrowdLabels.Contains("CJJB_TNB_Suspected"))
                {
                    entity.CrowdLabels = entity.CrowdLabels.Where(x => x != "CJJB_TNB_Suspected")?.ToList() ?? new List<string>();
                }
                if (entity.CrowdLabels.Contains("CJJB_GXY") && entity.CrowdLabels.Contains("CJJB_GXY_Suspected"))
                {
                    entity.CrowdLabels = entity.CrowdLabels.Where(x => x != "CJJB_GXY_Suspected")?.ToList() ?? new List<string>();
                }
                if (!string.IsNullOrWhiteSpace(idCardNo) && Regex.IsMatch(idCardNo, @"^(\d{6})(\d{4})(\d{2})(\d{2})(\d{3})(\d|X)$"))
                {
                    var birthDay = new DateTime(Convert.ToInt32(idCardNo.Substring(6, 4)), Convert.ToInt32(idCardNo.Substring(10, 2)), Convert.ToInt32(idCardNo.Substring(12, 2)));

                    var childDay = DateTime.Now.AddYears(-6);
                    var childLabel = "RQFL_ET";
                    if (birthDay >= childDay)
                    {
                        if (!entity.CrowdLabels.Contains(childLabel))
                        {
                            entity.CrowdLabels.Add(childLabel);
                        }
                    }
                    else
                    {
                        if (entity.CrowdLabels.Contains(childLabel))
                        {
                            entity.CrowdLabels = entity.CrowdLabels.Where(x => x != childLabel)?.ToList() ?? new List<string>();
                        }
                    }
                    var lnrDay = DateTime.Now.AddYears(-65);
                    var lnrLabel = "RQFL_LNR";
                    if (birthDay <= lnrDay)
                    {
                        if (!entity.CrowdLabels.Contains(lnrLabel))
                        {
                            entity.CrowdLabels.Add(lnrLabel);
                        }
                    }
                    else
                    {
                        if (entity.CrowdLabels.Contains(lnrLabel))
                        {
                            entity.CrowdLabels = entity.CrowdLabels.Where(x => x != lnrLabel)?.ToList() ?? new List<string>();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineDebug($"FillingPersopnType error,{entity.CardNo}," + ex);
            }
        }
    }
}