WingLiveConsultationService/LiveConsultationService.Reservation.cs

using System.Threading.Tasks;
using System.Collections.Concurrent;
using WingInterfaceLibrary.DB.Request;
using WingInterfaceLibrary.DTO.Consultation;
using WingInterfaceLibrary.DTO.Organization;
using WingInterfaceLibrary.DTO.Patient;
using WingInterfaceLibrary.DTO.User;
using WingInterfaceLibrary.Enum;
using WingInterfaceLibrary.LiveConsultation;
using WingInterfaceLibrary.LiveConsultation.Consultation;
using WingInterfaceLibrary.Notifications;
using WingInterfaceLibrary.Notifications.Consultation;
using WingInterfaceLibrary.Request;
using WingInterfaceLibrary.Request.DBRequest;
using WingInterfaceLibrary.Request.User;
using WingInterfaceLibrary.Result;
using WingServerCommon.Interfaces.Cache;
using WingServerCommon.Log;
using WingServerCommon.Mapper;
using WingServerCommon.Service;
using WingServerCommon.Utilities;
using WingInterfaceLibrary.Request.Patient;
using Newtonsoft.Json.Linq;
using WingInterfaceLibrary.DTO.Common;
using WingInterfaceLibrary.LiveConsultation.Enums;
using WingInterfaceLibrary.DTO.Schedule;
using WingInterfaceLibrary.Internal.Request;
using WingInterfaceLibrary.DTO.Record;

namespace WingLiveConsultationService
{
    public partial class LiveConsultationService : JsonRpcService, ILiveConsultationService
    {
        private Mutex sendNotificationLocker = new Mutex();
        /// <summary>
        /// 查询上级机构集合
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<IList<OrganizationBaseDTO>> FindParentOrganizationsAsync(FindHigherOrganizationsRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userInfoDTO = await _userDBService.FindUserByCodeAsync(userCode);
            var dbRequest = new GetOrganizationDBRequest { OrganizationCode = userInfoDTO.RootOrganizationCode };
            var organization = await _organizationDBService.GetOrganizationDetailAsync(dbRequest);
            var organizationList = organization.ReferralOrganizations.Where(x => x.OrganizationCode != userInfoDTO.RootOrganizationCode && x.OrganizationName.Contains(request.OrganizationName)).ToList();
            var result = organizationList.Select(c => new OrganizationBaseDTO()
            {
                OrganizationCode = c.OrganizationCode,
                OrganizationName = c.OrganizationName,
            }).ToList();
            return result;
        }

        /// <summary>
        /// 查询基层机构组织
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<IList<OrganizationBaseDTO>> FindGrassRootsOrganizationsAsync(FindGrassRootsOrganizationsRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userInfoDTO = await _userDBService.FindUserByCodeAsync(userCode);
            var organization = CacheMaintenance.Instance.Get<IOrganizationsManager>().Get(userInfoDTO.RootOrganizationCode);
            var organizationList = new List<OrganizationDTO>();
            GetAllChildOrganizationDTO(organization.Code, ref organizationList);
            organizationList = organizationList.Where(x => x.OrganizationCode != userInfoDTO.RootOrganizationCode && x.OrganizationName.Contains(request.OrganizationName)).ToList();
            var result = organizationList.Select(c => new OrganizationBaseDTO()
            {
                OrganizationCode = c.OrganizationCode,
                OrganizationName = c.OrganizationName,
            }).ToList();
            return result;
        }

        /// <summary>
        /// 取该医院组织的子孙医院
        /// </summary>
        /// <param name="organizations">全部组织</param>
        /// <param name="organizationCode">当前组织Code</param>
        /// <param name="needOrganizations">全部子孙组织</param>
        /// <returns></returns>
        private void GetAllChildOrganizationDTO(string organizationCode, ref List<OrganizationDTO> needOrganizations)
        {
            //查到父级为此机构的机构列表
            var organizationFilter = new Dictionary<string, string>();
            organizationFilter.Add("ParentCode", organizationCode);
            organizationFilter.Add("OrganizationType", OrganizationTypeEnum.Corporation.ToString());
            var organizations = _organizationDBService.GetOrganizationPageAsync((new PageFilterRequest { CurrentPage = 1, PageSize = 999999, Filter = organizationFilter, IsFuzzy = false })).Result;
            var childList = organizations.PageData.Where(o => o.ParentCode == organizationCode && o.OrganizationCode != organizationCode);
            if (childList != null && childList.Count() > 0)
            {
                var intersectedList = needOrganizations.Select(n => n.OrganizationCode).Intersect(childList.Select(c => c.OrganizationCode));
                //避免循环设置上级：a->b->c->a
                if (intersectedList.Count() == 0)
                {
                    needOrganizations.AddRange(childList);
                    foreach (var item in childList)
                    {
                        GetAllChildOrganizationDTO(item.OrganizationCode, ref needOrganizations);
                    }
                }

            }
        }

        /// <summary>
        /// 查询机构专家集合
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<IList<OrganizationExpertDTO>> FindOrganizationExpertsAsync(FindOrganizationExpertsRequest request)
        {
            var userList = await FindOrganizationAssistantsAsync(request.OrganizationCode, "Role_CertifiedExpert");
            userList = userList.Where(x => x.FullName.Contains(request.ExpertName) || x.UserName.Contains(request.ExpertName)).ToList();
            var resultData = userList.MappingTo<IList<OrganizationExpertDTO>>();
            foreach (var user in resultData)
            {
                user.UserStatus = GetUserStatus(user.UserCode);
            }
            return resultData;
        }

        /// <summary>查询助理服务专家集合</summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<IList<OrganizationExpertDTO>> FindAssistantExpertsAsync(FindAssistantExpertsRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userInfoDTO = await _userDBService.FindUserByCodeAsync(userCode);
            if (!userInfoDTO.RoleCodes.Contains("Role_ExpertAssistant") && !userInfoDTO.IsDirector)
            {
                return new List<OrganizationExpertDTO>();
            }
            var resultData = new List<OrganizationExpertDTO>();
            var bindExperts = await _userDBService.GetBindExpertsAsync(userCode);
            if (bindExperts.Any())
            {
                bindExperts = bindExperts.Where(x => x.FullName.Contains(request.ExpertName) || x.UserName.Contains(request.ExpertName)).ToList();
                resultData = bindExperts.MappingTo<IList<OrganizationExpertDTO>>().ToList();
            }
            else
            {
                var userList = await FindOrganizationAssistantsAsync(userInfoDTO.RootOrganizationCode, "Role_CertifiedExpert");//认证专家
                userList = userList.Where(x => x.FullName.Contains(request.ExpertName) || x.UserName.Contains(request.ExpertName)).ToList();
                resultData = userList.MappingTo<IList<OrganizationExpertDTO>>().ToList();
            }
            foreach (var user in resultData)
            {
                user.UserStatus = GetUserStatus(user.UserCode);
            }
            return resultData;
        }

        /// <summary>
        /// 申请会诊
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<string> ApplyConsultationAsync(ApplyConsultationRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userInfoDTO = await _userDBService.FindUserByCodeAsync(userCode);
            //验证用户是否为空
            if (userInfoDTO == null || string.IsNullOrWhiteSpace(userInfoDTO.UserCode))
            {
                ThrowRpcException(CustomerRpcCode.UserNotFind, "User not find");
            }
            //病人列表必填项验证
            if (string.IsNullOrEmpty(request.PatientCode))
            {
                ThrowRpcException(CustomerRpcCode.PatientCodeIsEmpty, "Patient code is empty");
            }
            request.ConsultationTime = request.ConsultationTime.ToUniversalTime();
            //会诊设备、会诊时间、会诊机构
            if (string.IsNullOrEmpty(request.DeviceCode))
            {
                //会诊设备不存在
                ThrowRpcException(CustomerRpcCode.DeviceCodeIsEmpty, "DeviceCode is empty");
            }
            if (request.ConsultationTime == DateTime.MinValue)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationTimeIsEmpty, "Consultation time is empty");
            }
            if (request.ConsultationTime < DateTime.Today.ToUniversalTime())
            {
                //会诊时间不存在
                ThrowRpcException(CustomerRpcCode.ConsultationTimeGreaterThanCurrentTime, "ConsultationTime must greater than current time");
            }
            if (string.IsNullOrEmpty(request.ExpertOrganizationCode))
            {
                //会诊机构不存在
                ThrowRpcException(CustomerRpcCode.ExpertOrganizationCodeIsEmpty, "ExpertOrganizationCode is empty");
            }
            var dbRequest = new CreateConsultationRecordDBRequest();
            dbRequest.Data = new ConsultationDetailDTO();
            //会诊专家为空，验证申请人，区分申请人为专家助理 或者 其他，如果是助理，且申请专家为空，则直接分配到助理上面
            UserDTO expertUserInfoDTO = null;
            if (!string.IsNullOrEmpty(request.ExpertUserCode))
            {
                expertUserInfoDTO = await _userDBService.FindUserByCodeAsync(request.ExpertUserCode);
                if (expertUserInfoDTO == null || string.IsNullOrEmpty(expertUserInfoDTO.UserCode))
                {
                    //会诊专家不存在
                    ThrowRpcException(CustomerRpcCode.ConsultationExpertNotExist, "Consultation expert information not exist");
                }
            }
            //操作人是  专家助理或机构负责人，找对应的专家
            if (userInfoDTO.RoleCodes.Contains("Role_ExpertAssistant") || userInfoDTO.IsDirector)
            {
                if (string.IsNullOrEmpty(request.ApplyUserCode))
                {
                    //申请人不存在
                    ThrowRpcException(CustomerRpcCode.ApplyUserCodeIsEmpty, "ApplyUserCode is empty");
                }
                var resultData = await GetOrganizationBindExpertsByUserCodeAsync(userInfoDTO.UserCode);
                if (resultData?.Count > 0)
                {
                    var existExpert = resultData.ToList().Exists(c => c.UserCode == request.ApplyUserCode);
                    if (!existExpert)
                    {
                        //申请人不存在
                        ThrowRpcException(CustomerRpcCode.ConsultationExpertNotExist, "Consultation expert information not exist");
                    }
                }
            }
            else
            {
                if (string.IsNullOrEmpty(request.ApplyUserCode))
                {
                    request.ApplyUserCode = userInfoDTO.UserCode;
                }
                else
                {
                    //不是助理，申请人必须跟操作人保持一致
                    if (request.ApplyUserCode != userInfoDTO.UserCode)
                    {
                        ThrowRpcException(CustomerRpcCode.ConsultationApplyUserIllegal, "ApplyUserCode and operateUserCode are illegal");
                    }
                }
            }
            var applyUserInfoDTO = await _userDBService.FindUserByCodeAsync(request.ApplyUserCode);
            dbRequest.Data.ApplyUserCode = request.ApplyUserCode;
            if (applyUserInfoDTO.OrganizationCode != applyUserInfoDTO.RootOrganizationCode)
            {
                dbRequest.Data.ApplyDepartmentCode = applyUserInfoDTO.OrganizationCode;
            }
            else
            {
                dbRequest.Data.ApplyDepartmentCode = "";
            }
            dbRequest.Data.ApplyOrganizationCode = applyUserInfoDTO.RootOrganizationCode;
            //验证用户是手动新增，还是选择，如果是新增，则要保存，并验证重复
            var organization = CacheMaintenance.Instance.Get<IOrganizationsManager>().Get(userInfoDTO.RootOrganizationCode);
            var patientResult = await UpdatePatientInfo(request);//, userInfoDTO, (OrganizationPatientTypeEnum)organization.PatientType, dbRequest);
            if (!patientResult)
            {
                ThrowRpcException(CustomerRpcCode.UpdatePatientInfoFail, "Update patient information fail");
            }
            if (expertUserInfoDTO != null)
            {
                dbRequest.Data.ExpertUserCode = expertUserInfoDTO.UserCode;
                dbRequest.Data.ExpertOrganizationCode = expertUserInfoDTO.RootOrganizationCode;
                if (expertUserInfoDTO.OrganizationCode != expertUserInfoDTO.RootOrganizationCode)
                {
                    dbRequest.Data.ExpertDepartmentCode = expertUserInfoDTO.OrganizationCode;
                }
                else
                {
                    dbRequest.Data.ExpertDepartmentCode = "";
                }
            }
            else
            {
                dbRequest.Data.ExpertUserCode = request.ExpertUserCode;
                dbRequest.Data.ExpertOrganizationCode = request.ExpertOrganizationCode;
            }
            dbRequest.Data.PatientCode = request.PatientCode;
            dbRequest.Data.ConsultationTime = request.ConsultationTime;
            dbRequest.Data.ScanUserCode = request.ScanUserCode;
            dbRequest.Data.OperateUserCode = userInfoDTO.UserCode;
            dbRequest.Data.DeviceCode = request.DeviceCode;
            dbRequest.Data.ScanPosition = request.ScanPosition;
            dbRequest.Data.PrimaryDiagnosis = request.PrimaryDiagnosis;
            dbRequest.Data.PatientType = (OrganizationPatientTypeEnum)organization.PatientType;
            dbRequest.Data.CreateTime = DateTime.UtcNow;
            dbRequest.Data.Diseases = request.Diseases;
            var patientInfo = await _patientInfoDBService.FindPatientByCodeAsync(request.PatientCode);
            dbRequest.Data.PatientDatas = patientInfo?.PatientData;
            var result = await _consultationRecordDBService.InsertConsultationRecordAsync(dbRequest);
            var patientName = GetPatientName(patientInfo.PatientData);
            //获取通知人
            var clientIds = await GetNotifyUsers(expertUserInfoDTO, dbRequest.Data.ExpertOrganizationCode);
            clientIds = clientIds?.Where(x => x != userCode)?.ToList() ?? new List<string>();
            if (clientIds != null && clientIds.Any())
            {

                //申请通知 
                var applyConsultationNotification = new ApplyConsultationNotification
                {
                    PatientName = patientName,
                    OperatorName = applyUserInfoDTO.FullName,
                    ApplicationTime = dbRequest.Data.CreateTime.ToUniversalTime(),
                    ConsultationCode = result,
                    ApplyOrganizationName = organization.OrganizationName,
                    ConsultationTime = request.ConsultationTime.ToUniversalTime(),
                    IsResponse = true
                };
                var broadcastNotificationRequest = new BroadcastNotificationRequest()
                {
                    ClientIds = clientIds,
                    Message = applyConsultationNotification,
                    JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(applyConsultationNotification),
                    NotificationType = applyConsultationNotification.NotificationType,
                    TransactionType = TransactionTypeEnum.Consultion,
                    RelevanceCode = result,
                    ReceiverType = ApplicantTypeEnum.Client
                };
                await _notificationService.BroadcastMessageAsync(broadcastNotificationRequest);
                //通知申请人们
                await SendSmsSubmitApplyConsultationAsync(clientIds, applyUserInfoDTO.FullName, patientName, applyConsultationNotification.ConsultationTime, organization.OrganizationName);
            }

            return result;
        }

        private async Task<List<string>> GetNotifyUsers(UserDTO? expertUserInfoDTO, string rootOrganizationCode)
        {
            var notifyUsers = new List<string>();
            //机构负责人
            var getOrganizationDBRequest = new GetOrganizationDBRequest { OrganizationCode = rootOrganizationCode };
            var rootOrganization = await _organizationDBService.GetOrganizationDetailAsync(getOrganizationDBRequest);
            if (rootOrganization.Directors != null && rootOrganization.Directors.Count > 0)
            {
                notifyUsers.AddRange(rootOrganization.Directors);
            }
            //有选择专家
            if (expertUserInfoDTO != null && !string.IsNullOrWhiteSpace(expertUserInfoDTO.UserCode))
            {
                notifyUsers.Add(expertUserInfoDTO.UserCode);
                if (!string.IsNullOrWhiteSpace(expertUserInfoDTO.BindAssistantUserCode))
                {
                    notifyUsers.Add(expertUserInfoDTO.BindAssistantUserCode);
                }
            }
            else//没选择专家 发给助理
            {

                var assistants = await FindOrganizationAssistantsAsync(rootOrganizationCode, "Role_ExpertAssistant");
                if (assistants != null && assistants.Count > 0)
                {
                    notifyUsers.AddRange(assistants.Select(x => x.UserCode).ToList());
                }
            }
            notifyUsers = notifyUsers.Distinct().ToList();
            return notifyUsers;
        }

        /// <summary>
        /// 处理会诊病人信息
        /// </summary>
        /// <param name="request"></param>
        /// <param name="userInfoDTO"></param>
        /// <param name="patientType"></param>
        /// <param name="dbRequest"></param>
        /// <returns>是否成功</returns>
        private async Task<bool> UpdatePatientInfo(ApplyConsultationRequest request)
        {
            if (request.PatientDatas == null || request.PatientDatas.Count == 0)
            {
                return true;
            }
            var req = new UpdatePatientRequest()
            {
                Token = request.Token,
                Code = request.PatientCode,
                PatientData = request.PatientDatas,
            };
            var result = await _patientService.UpdatePatientAsync(req);
            return result;
        }

        /// <summary>
        /// 修改会诊信息
        /// </summary>
        /// <param name="request">申请会诊请求实体</param>
        /// <returns>是否成功</returns>
        /// <value>true</value>
        /// <errorCodes></errorCodes>
        public async Task<bool> UpdateConsultationAsync(UpdateConsultationRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userInfoDTO = await _userDBService.FindUserByCodeAsync(userCode);
            //验证用户是否为空
            if (userInfoDTO == null || string.IsNullOrWhiteSpace(userInfoDTO.UserCode))
            {
                ThrowRpcException(CustomerRpcCode.UserNotFind, "User Not Find");
            }
            var consultation = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(new ConsultationRecordCodeDBRequest { Code = request.ConsultationCode });
            var applyUser = new UserDTO();
            if (!string.IsNullOrWhiteSpace(consultation.ApplyUserCode))
            {
                applyUser = await _userDBService.FindUserByCodeAsync(consultation.ApplyUserCode);
            }
            if (applyUser.BindAssistantUserCode != userCode && userCode != consultation.ApplyUserCode && userCode != consultation.OperateUserCode && !((consultation.ApplyOrganizationCode == userInfoDTO.RootOrganizationCode) && userInfoDTO.IsDirector))
            {
                ThrowRpcException(CustomerRpcCode.ConsultationNorightError, "Consultation Noright Error");
            }
            if (consultation.ConsultationStatus != TransactionStatusEnum.Withdrawn && consultation.ConsultationStatus != TransactionStatusEnum.Rejected)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationStatusError, "Consultation Noright Error");
            }
            //会诊设备、会诊时间、会诊机构
            if (string.IsNullOrEmpty(request.DeviceCode))
            {
                //会诊设备不存在
                ThrowRpcException(CustomerRpcCode.DeviceCodeIsEmpty, "Device Code Is Empty");
            }
            request.ConsultationTime = request.ConsultationTime.ToUniversalTime();
            if (request.ConsultationTime == DateTime.MinValue || request.ConsultationTime < DateTime.Today.ToUniversalTime())
            {
                //会诊时间不存在
                ThrowRpcException(CustomerRpcCode.ConsultationTimeGreaterThanCurrentTime, "Consultation Time Greater Than Current Time");
            }
            if (string.IsNullOrEmpty(request.ExpertOrganizationCode))
            {
                //会诊机构不存在
                ThrowRpcException(CustomerRpcCode.ExpertOrganizationCodeIsEmpty, "Expert Organization Code Is Empty");
            }
            //会诊专家为空，验证申请人，区分申请人为专家助理 或者 其他，如果是助理，且申请专家为空，则直接分配到助理上面
            UserDTO expertUserInfoDTO = null;
            if (!string.IsNullOrEmpty(request.ExpertUserCode))
            {
                expertUserInfoDTO = await _userDBService.FindUserByCodeAsync(request.ExpertUserCode);
                if (expertUserInfoDTO == null || string.IsNullOrEmpty(expertUserInfoDTO.UserCode))
                {
                    //会诊专家不存在
                    ThrowRpcException(CustomerRpcCode.ConsultationExpertNotExist, "Consultation Expert Not Exist");
                }
            }

            //操作人是  专家助理或机构负责人，找对应的专家
            if (userInfoDTO.RoleCodes.Contains("Role_ExpertAssistant") || userInfoDTO.IsDirector)
            {
                if (string.IsNullOrEmpty(request.ApplyUserCode))
                {
                    //申请人不存在
                    ThrowRpcException(CustomerRpcCode.ApplyUserCodeIsEmpty, "ApplyUser Code Is Empty");
                }
                var resultData = await GetOrganizationBindExpertsByUserCodeAsync(userInfoDTO.UserCode);
                if (resultData?.Count > 0)
                {
                    var existExpert = resultData.ToList().Exists(c => c.UserCode == request.ApplyUserCode);
                    if (!existExpert)
                    {
                        //申请人不存在
                        ThrowRpcException(CustomerRpcCode.ConsultationExpertNotExist, "Consultation Expert Not Exist");
                    }
                }
            }
            else
            {
                //不是助理，申请人必须跟操作人保持一致
                if (request.ApplyUserCode != userInfoDTO.UserCode)
                {
                    ThrowRpcException(CustomerRpcCode.ConsultationApplyUserIllegal, "Consultation Apply User Illegal");
                }
            }

            var organization = CacheMaintenance.Instance.Get<IOrganizationsManager>().Get(userInfoDTO.RootOrganizationCode);
            if (expertUserInfoDTO != null)
            {
                consultation.ExpertUserCode = expertUserInfoDTO.UserCode;
                consultation.ExpertOrganizationCode = expertUserInfoDTO.RootOrganizationCode;
                if (expertUserInfoDTO.OrganizationCode != expertUserInfoDTO.RootOrganizationCode)
                {
                    consultation.ExpertDepartmentCode = expertUserInfoDTO.OrganizationCode;
                }
                else
                {
                    consultation.ExpertDepartmentCode = "";
                }
            }
            else
            {
                consultation.ExpertUserCode = request.ExpertUserCode;
            }

            var applyUserInfoDTO = await _userDBService.FindUserByCodeAsync(request.ApplyUserCode);
            consultation.ApplyUserCode = request.ApplyUserCode;
            if (applyUserInfoDTO.OrganizationCode != applyUserInfoDTO.RootOrganizationCode)
            {
                consultation.ApplyDepartmentCode = applyUserInfoDTO.OrganizationCode;
            }
            else
            {
                consultation.ApplyDepartmentCode = "";
            }
            consultation.ApplyOrganizationCode = applyUserInfoDTO.RootOrganizationCode;
            consultation.ApplyUserCode = request.ApplyUserCode;
            consultation.ConsultationTime = request.ConsultationTime;
            consultation.ScanUserCode = request.ScanUserCode;
            consultation.OperateUserCode = userInfoDTO.UserCode;
            consultation.DeviceCode = request.DeviceCode;
            consultation.PrimaryDiagnosis = request.PrimaryDiagnosis;
            consultation.ScanPosition = request.ScanPosition;
            consultation.PatientType = (OrganizationPatientTypeEnum)organization.PatientType;
            consultation.Diseases = request.Diseases;
            consultation.ConsultationStatus = TransactionStatusEnum.Applied;
            consultation.RejectReason = string.Empty;
            var result = await _consultationRecordDBService.UpdateConsultationRecordAsync(consultation, true);
            var patientName = GetPatientName(consultation.PatientDatas);
            //获取通知人 
            var clientIds = await GetNotifyUsers(expertUserInfoDTO, consultation.ExpertOrganizationCode);
            clientIds = clientIds?.Where(x => x != userCode)?.ToList() ?? new List<string>();
            if (clientIds != null && clientIds.Any())
            {
                //申请通知 
                var applyConsultationNotification = new ApplyConsultationNotification
                {
                    PatientName = patientName,
                    OperatorName = applyUserInfoDTO.FullName,
                    ApplicationTime = DateTime.UtcNow,
                    ConsultationCode = consultation.ConsultationCode,
                    ApplyOrganizationName = organization.OrganizationName,
                    ConsultationTime = request.ConsultationTime.ToUniversalTime(),
                    IsResponse = true
                };
                var broadcastNotificationRequest = new BroadcastNotificationRequest()
                {
                    ClientIds = clientIds,
                    Message = applyConsultationNotification,
                    JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(applyConsultationNotification),
                    NotificationType = applyConsultationNotification.NotificationType,
                    TransactionType = TransactionTypeEnum.Consultion,
                    RelevanceCode = consultation.ConsultationCode,
                    ReceiverType = ApplicantTypeEnum.Client
                };
                await _notificationService.BroadcastMessageAsync(broadcastNotificationRequest);
                //通知申请人们
                await SendSmsSubmitApplyConsultationAsync(clientIds, applyUserInfoDTO.FullName, patientName, applyConsultationNotification.ConsultationTime, organization.OrganizationName);
            }
            return result;
        }

        /// <summary>
        /// 查询会诊列表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<PageResult<ConsultationPageDTO>> FindConsultationsByPageAsync(FindConsultationByPageRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            if (string.IsNullOrEmpty(userCode))
            {
                ThrowRpcException(CustomerRpcCode.UserNotFind, "User not find");
            }
            if (request.StartDate > Convert.ToDateTime("2000-1-1") && request.EndDate > Convert.ToDateTime("2000-1-1"))
            {
                if (request.StartDate > request.EndDate)
                {
                    //会诊时间不存在
                    ThrowRpcException(CustomerRpcCode.ConsultationStartTimeGreaterThanEndTime, "StartDate must greater than EndDate");
                }
                // var timeDiff = request.EndDate - request.StartDate;
                // if (timeDiff.TotalDays > (365 * 3))
                // {
                //     ThrowRpcException(CustomerRpcCode.ConsultationQueryTimeRangeToLarge, "Consultation query time range to large");
                // }
            }
            var dbRequest = new GetConsultationRecordPagesDBRequest();
            dbRequest.CurrentPage = request.PageIndex;
            dbRequest.PageSize = request.PageSize;
            dbRequest.UserCode = userCode;
            dbRequest.Keyword = request.Keyword;
            dbRequest.StartDate = request.StartDate;
            dbRequest.EndDate = request.EndDate;
            dbRequest.ConsultationStatus = request.ConsultationStatus;
            dbRequest.ConsultationQueryType = request.ConsultationQueryType;
            dbRequest.EvaluateGrade = request.EvaluateGrade;
            dbRequest.ExpertCodes = request.ExpertCodes;
            dbRequest.ApplyOrganizationCodes = request.ApplyOrganizationCodes;
            dbRequest.ExpertOrganizationCodes = request.ExpertOrganizationCodes;
            dbRequest.PatientSex = request.PatientSex;
            dbRequest.PatientAgeLimit = request.PatientAgeLimit;
            dbRequest.PatientDiseases = request.PatientDiseases;
            dbRequest.PatientPrimaryDiagnosis = request.PatientPrimaryDiagnosis;
            var result = await _consultationRecordDBService.FindConsultationRecordPagesAsync(dbRequest);
            var consultationPages = new PageResult<ConsultationPageDTO>();
            if (result == null)
            {
                return consultationPages;
            }
            List<ConsultationPageDTO> pages = new List<ConsultationPageDTO>();
            consultationPages.TotalCount = result.TotalCount;
            consultationPages.PageSize = result.PageSize;
            consultationPages.PageIndex = result.PageIndex;
            if (result.PageData != null && result.PageData.Count > 0)
            {
                var userDTO = await _userDBService.FindUserByCodeAsync(userCode);
                var rootOrg = await _organizationDBService.GetOrganizationDetailAsync(new GetOrganizationDBRequest { OrganizationCode = userDTO.RootOrganizationCode });
                var expertUserCodes = result.PageData.Select(x => x.ExpertUserCode).Where(e => !string.IsNullOrWhiteSpace(e)).ToList();
                var expertUsers = new List<UserDTO>();
                if (expertUserCodes.Count > 0)
                {
                    expertUsers = await _userDBService.FindUserListByUserCodesAsync(expertUserCodes);
                }
                //评价
                var evaluateList = await _consultationRecordDBService.GetAllConsultationEvaluatesByCodesAsync(result.PageData.Select(x => x.ConsultationCode).ToList());
                foreach (var item in result.PageData)
                {
                    if (!string.IsNullOrEmpty(item.ApplyOrganizationCode))
                    {
                        var organization = CacheMaintenance.Instance.Get<IOrganizationsManager>().Get(item.ApplyOrganizationCode);
                        if (organization != null)
                        {
                            item.ApplyOrganizationName = organization.OrganizationName;
                        }
                    }

                    var expertUser = expertUsers.FirstOrDefault(x => x.UserCode == item.ExpertUserCode);
                    var evaluate = evaluateList.FirstOrDefault(x => x.ConsultationRecordCode == item.ConsultationCode);
                    var consultationPageDTO = new ConsultationPageDTO()
                    {
                        ConsultationCode = item.ConsultationCode,
                        PatientName = (item.PatientDatas == null || item.PatientDatas.Count == 0) ? GetNotFilled(request.Language) : CryptionHelper.NameEncrypt(GetPatientValue(item.PatientDatas, "Name"), rootOrg.IsEncryptedShow),
                        Phone = (item.PatientDatas == null || item.PatientDatas.Count == 0) ? "" : CryptionHelper.PhoneEncrypt(GetPatientValue(item.PatientDatas, "Phone"), rootOrg.IsEncryptedShow),
                        PatientAge = (item.PatientDatas == null || item.PatientDatas.Count == 0) ? "" : GetPatientAge(item.PatientDatas, request.Language),
                        Sex = (item.PatientDatas == null || item.PatientDatas.Count == 0) ? "" : GetPatientGender(item.PatientDatas, request.Language),
                        ConsultationTime = item.ConsultationTime.ToUniversalTime(),
                        ConsultationTimeEnd = item.ConsultationTimeEnd.ToUniversalTime(),
                        ApplyOrganizationName = item.ApplyOrganizationName,
                        ExpertUserName = !string.IsNullOrWhiteSpace(expertUser?.FullName) ? expertUser?.FullName : expertUser?.UserName,
                        ConsultationStatus = item.ConsultationStatus,
                        ConsultationEvaluate = evaluate == null ? EvaluateGradeEnum.UnSet : evaluate.EvaluateGrade,
                        IsEmergency = item.IsEmergency,
                        EmergencyCode = item.EmergencyCode
                    };
                    pages.Add(consultationPageDTO);
                }
                consultationPages.PageData = pages;
            }
            return consultationPages;
        }

        /// <summary>
        /// 获取未填写
        /// </summary>
        /// <param name="patientInfo"></param>
        /// <returns></returns>
        private string GetNotFilled(string language)
        {
            if (language == "zh-CN")
            {
                return "未填写";
            }
            else if (language == "en-US")
            {
                return "NotFilled";
            }
            else
            {
                return "";
            }
        }

        /// <summary>
        /// 获取年龄
        /// </summary>
        /// <param name="patientInfo"></param>
        /// <returns></returns>
        private string GetPatientAge(List<DataItemDTO> patientData, string language)
        {
            var agestrCN = "";
            var agestrEN = "";
            var ageYear = GetPatientValue(patientData, "AgeYear");
            var ageMonth = GetPatientValue(patientData, "AgeMonth");
            var ageWeek = GetPatientValue(patientData, "AgeWeek");
            var ageDay = GetPatientValue(patientData, "AgeDay");
            var ageUnits = GetPatientValue(patientData, "AgeUnits");
            if (!string.IsNullOrEmpty(ageYear))
            {
                agestrCN += ageYear + "岁";
                agestrEN += ageYear + "Year";
            }
            if (!string.IsNullOrEmpty(ageMonth))
            {
                agestrCN += ageMonth + "月";
                agestrEN += ageMonth + "Month";
            }
            if (!string.IsNullOrEmpty(ageWeek))
            {
                agestrCN += ageWeek + "周";
                agestrEN += ageWeek + "Week";
            }
            if (!string.IsNullOrEmpty(ageDay))
            {
                agestrCN += ageDay + "天";
                agestrEN += ageDay + "Day";
            }
            if (string.IsNullOrEmpty(agestrCN) && string.IsNullOrEmpty(agestrEN))//兼容老数据
            {
                var oldAge = GetPatientValue(patientData, "Age");
                agestrCN += oldAge;
                agestrEN = agestrCN;
            }
            if (language == "zh-CN")
            {
                return agestrCN;
            }
            else if (language == "en-US")
            {
                return agestrEN;
            }
            else
            {
                return "";
            }
        }

        private string GetPatientGender(List<DataItemDTO> patientData, string language)
        {
            var genderCN = string.Empty;
            var genderEN = string.Empty;
            var gender = GetPatientValue(patientData, "Sex");
            if (gender == PatientGenderEnum.Male.ToString())
            {
                genderCN = "男";
                genderEN = "Male";
            }
            else if (gender == PatientGenderEnum.Female.ToString())
            {
                genderCN = "女";
                genderEN = "Female";
            }
            else
            {
                genderCN = "未填写";
                genderEN = "NotFilled";
            }
            if (language == "zh-CN")
            {
                return genderCN;
            }
            else if (language == "en-US")
            {
                return genderEN;
            }
            else
            {
                return "";
            }
        }

        private string GetPatientValue(List<DataItemDTO> source, string key)
        {
            var dataItem = source.FirstOrDefault(x => x.Key == key);
            return dataItem?.Value ?? string.Empty;
        }

        /// <summary>
        /// 查询会诊图像接口
        /// </summary>
        /// <param name="request">查询图像请求实体</param>
        /// <returns></returns>
        public async Task<IList<ConsultationImagesDTO>> GetConsultationFilesAsync(FindConsultationDetailRequest request)
        {
            var consultationCode = request.ConsultationCode;
            var dbRequest = new ConsultationRecordCodeDBRequest();
            dbRequest.Code = consultationCode;
            var result = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(dbRequest);
            var consultationFileList = result.ConsultationFileList;
            IList<ConsultationImagesDTO> dataList = new List<ConsultationImagesDTO>();
            if (result != null && consultationFileList?.Count > 0)
            {
                var remedicalInfos = await _remedicalDBService.GetRecordRemedicalAsync(consultationCode);
                var getRemedicalMeasuredInfosByRecordCodeDBRequest = new GetRemedicalMeasuredInfosByRecordCodeDBRequest { RecordCode = consultationCode };
                var remedicalMeasuredInfos = await _remedicalMeasuredInfoDBService.GetRemedicalMeasuredInfosByRecordCodeAsync(getRemedicalMeasuredInfosByRecordCodeDBRequest);
                var imgDateList = consultationFileList.Select(c => c.CreateTime.ToUniversalTime().Date).Distinct().ToList();
                if (imgDateList?.Count > 0)
                {
                    foreach (var imgDate in imgDateList)
                    {
                        var consultationImagesDTO = new ConsultationImagesDTO { ImageDate = imgDate };
                        var tempList = consultationFileList.FindAll(d => d.CreateTime.ToUniversalTime().Date == imgDate);
                        var consultationTypeImageList = tempList.Select(x => x.ConsultationFileType).Distinct();
                        foreach (var item in tempList)
                        {
                            if (!string.IsNullOrWhiteSpace(item.CreatorCode))
                            {
                                var userInfo = CacheMaintenance.Instance.Get<IUserInfoManager>().Get(item.CreatorCode) ?? new CacheUserDTO();
                                item.CreatorName = string.IsNullOrEmpty(userInfo.FullName) ? userInfo.UserName : userInfo.FullName;
                            }
                        }
                        //超声图像
                        var usConsultationFileList = tempList.Where(x => x.ConsultationFileType == ConsultationFileTypeEnum.UltrasoundImage);
                        if (usConsultationFileList != null && usConsultationFileList.Count() > 0)
                        {
                            List<string> remedicalCodes = usConsultationFileList.Where(x => !string.IsNullOrWhiteSpace(x.RemedicalCode)).Select(x => x.RemedicalCode).ToList();
                            var ultrasoundDatas = remedicalInfos.Where(x => remedicalCodes.Contains(x.RemedicalCode)).ToList();
                            foreach (var remedical in ultrasoundDatas)
                            {
                                if (remedical.TerminalImages != null)
                                {
                                    remedical.TerminalImages.RecommendedDownloadMode = GetRecommendedDownloadMode(remedical.DeviceCode, remedical.TerminalImages.ImageSize);
                                }
                                if (remedical.CarotidResult != null)
                                {
                                    remedical.CarotidResult.RecommendedDownloadMode = RecommendedDownloadModeEnum.Origin;
                                }
                            }
                            consultationImagesDTO.UltrasoundImageList = ultrasoundDatas;
                        }
                        //测量图像
                        var measureConsultationFileList = tempList.Where(x => x.ConsultationFileType == ConsultationFileTypeEnum.MeasurementImage);
                        if (measureConsultationFileList != null && measureConsultationFileList.Count() > 0)
                        {
                            List<string> remedicalMeasureCodes = measureConsultationFileList.Where(x => !string.IsNullOrWhiteSpace(x.RemedicalMeasureCode)).Select(x => x.RemedicalMeasureCode).ToList();
                            var measureDatas = remedicalMeasuredInfos.Where(x => remedicalMeasureCodes.Contains(x.RemedicalMeasuredInfoCode)).ToList();
                            consultationImagesDTO.MeasurementImageList = measureDatas;
                        }
                        //会诊截图
                        var screenshotConsultationFileList = tempList.Where(x => x.ConsultationFileType == ConsultationFileTypeEnum.Screenshot);
                        if (screenshotConsultationFileList != null && screenshotConsultationFileList.Count() > 0)
                        {
                            var screenshotConsultationDatas = screenshotConsultationFileList.ToList();
                            consultationImagesDTO.ScreenshotList = screenshotConsultationDatas;
                        }
                        dataList.Add(consultationImagesDTO);
                    }
                }
            }
            return dataList;
        }

        /// <summary>
        /// 获取推荐下载模式
        /// </summary>
        /// <param name="deviceCode"></param>
        /// <returns></returns>
        private RecommendedDownloadModeEnum GetRecommendedDownloadMode(string deviceCode, long fileSize)
        {
            RecommendedDownloadModeEnum recommendedDownloadMode = RecommendedDownloadModeEnum.Origin;
            var deviceInfo = CacheMaintenance.Instance.Get<IDeviceInfosManager>().Get(deviceCode);
            if (deviceInfo != null)
            {
                var downloadModeSetting = deviceInfo.DownloadModeSetting;
                if (downloadModeSetting == (int)DownloadModeSettingEnum.Auto)
                {
                    if (fileSize >= 0 && fileSize < _downloadOriginalLowestValue)
                    {
                        recommendedDownloadMode = RecommendedDownloadModeEnum.CDN;
                    }
                }
                else
                {
                    recommendedDownloadMode = (RecommendedDownloadModeEnum)Enum.Parse(typeof(RecommendedDownloadModeEnum), downloadModeSetting.ToString());
                }
            }
            return recommendedDownloadMode;
        }

        /// <summary>
        /// 查询会诊详情
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<ConsultationDetailDTO> FindConsultationDetailAsync(FindConsultationDetailRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var consultationCode = request.ConsultationCode;
            //用户
            var userDTO = await _userDBService.FindUserByCodeAsync(userCode);
            if (userDTO == null)
            {
                ThrowRpcException(CustomerRpcCode.UserNotExistError, "User does not exist");
            }
            var dbRequest = new ConsultationRecordCodeDBRequest();
            dbRequest.Code = consultationCode;
            var rootOrg = await _organizationDBService.GetOrganizationDetailAsync(new GetOrganizationDBRequest { OrganizationCode = userDTO.RootOrganizationCode });
            var result = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(dbRequest);
            result.PatientName = CryptionHelper.NameEncrypt(result.PatientName, rootOrg.IsEncryptedShow);
            //操作按钮判断逻辑
            var status = result.ConsultationStatus;
            var isApplyDirector = userDTO.IsDirector && userDTO.RootOrganizationCode == result.ApplyOrganizationCode;//是否申请机构的负责人
            var isExpertDirector = userDTO.IsDirector && userDTO.RootOrganizationCode == result.ExpertOrganizationCode;//是否会诊机构的负责人
            var isApplyUser = userCode == result.ApplyUserCode;//是否申请医生
            var isExpertUser = userCode == result.ExpertUserCode;//是否会诊专家
            var isApplyAssistant = false;//是否申请医生的助理
            var isExpertAssistant = false;//是否会诊专家的助理
            var isExpertAssistantDoctor = false;//是否会诊专家的助理医师
            var isJoiner = false;//是否参与人
            var isAcceptedInvitation = 0;//接收邀请状态  0-待处理，1-已同意，2-已拒绝
            if (userDTO.RoleCodes.Contains("Role_ExpertAssistant"))//专家助理
            {
                //获取当前助理绑定的专家
                var resultData = await _userDBService.GetBindExpertsAsync(userCode);
                if (resultData?.Count > 0)
                {
                    //当前人是申请人的助理
                    isApplyAssistant = resultData.ToList().Exists(c => c.UserCode == result.ApplyUserCode);
                }
                //如果会诊单没有选择会诊专家,则所有的专家助理都可以处理这个单
                if (string.IsNullOrWhiteSpace(result.ExpertUserCode))
                {
                    isExpertAssistant = userDTO.RootOrganizationCode == result.ExpertOrganizationCode;
                }
                else
                {
                    if (resultData?.Count > 0)
                    {
                        isExpertAssistant = resultData.ToList().Exists(c => c.UserCode == result.ExpertUserCode);
                    }
                }
            }
            if (!string.IsNullOrWhiteSpace(result.ExpertUserCode))
            {
                var expertUser = await _userDBService.FindUserByCodeAsync(result.ExpertUserCode);
                if (!string.IsNullOrWhiteSpace(expertUser.BindAssistantDoctorUserCode))
                {
                    if(expertUser.BindAssistantDoctorUserCode == userCode)
                    {
                        isExpertAssistantDoctor = true;
                    }
                    var assistantDoctorUser = await _userDBService.FindUserByCodeAsync(expertUser.BindAssistantDoctorUserCode);
                    result.AssistantDoctorUserCode = expertUser.BindAssistantDoctorUserCode;
                    result.AssistantDoctorUserName = assistantDoctorUser.UserName;
                }
                //对外显示过滤助理医师
                result.ConsultationMembers = result.ConsultationMembers.Where(x => x.MemberCode != expertUser.BindAssistantDoctorUserCode).ToList();
            }
            if (result.ConsultationMembers != null && result.ConsultationMembers.Count > 0)
            {
                var memberCodes = result.ConsultationMembers.Select(x => x.MemberCode).ToList();
                if (memberCodes.Contains(userCode))
                {
                    isJoiner = true;
                    var joinerModel = result.ConsultationMembers.FirstOrDefault(x => x.MemberCode == userCode);
                    if (joinerModel?.MemberStatus == LiveConsultationMemberStatus.Accepted)
                    {
                        isAcceptedInvitation = 1;
                    }
                    else if (joinerModel?.MemberStatus == LiveConsultationMemberStatus.Rejected)
                    {
                        isAcceptedInvitation = 2;
                    }
                }
                var memberUsers = await _userDBService.FindUsersByUserCodesAsync(result.ConsultationMembers.Select(x => x.MemberCode).ToList());
                foreach (var item in result.ConsultationMembers)
                {
                    //参与人名称、头像
                    var itemMemberUser = memberUsers.FirstOrDefault(x => x.UserCode == item.MemberCode);
                    item.Name = string.IsNullOrWhiteSpace(itemMemberUser?.FullName) ? itemMemberUser?.UserName : itemMemberUser?.FullName;
                    item.HeadImageToken = itemMemberUser?.HeadImageUrl;
                }
            }
            if (status == TransactionStatusEnum.Applied)//已申请待审核状态
            {
                if (isApplyDirector || isApplyUser || isApplyAssistant)
                {
                    result.IsRevokeShow = true;
                }
                if (isExpertDirector || isExpertUser || isExpertAssistant)
                {
                    result.IsApprovalShow = true;
                    result.IsRejectShow = true;
                    result.IsAddInviterShow = true;
                }
            }
            else if (status == TransactionStatusEnum.Withdrawn || status == TransactionStatusEnum.Rejected)//撤回或拒绝状态
            {
                if (isApplyDirector || isApplyUser || isApplyAssistant)
                {
                    result.IsUpdateConsultationShow = true;
                }
            }
            else if (status == TransactionStatusEnum.ToStart)//待开始
            {
                if (isExpertUser)
                {
                    result.IsInitiateShow = true;
                }
                if (isJoiner)
                {
                    if (isAcceptedInvitation == 0)
                    {
                        result.IsAcceptInvitationShow = true;
                        result.IsRejectInvitationShow = true;
                    }
                    else if (isAcceptedInvitation == 1)
                    {
                        result.IsAcceptInvitationShow = false;
                        result.IsRejectInvitationShow = true;
                    }
                    else if (isAcceptedInvitation == 2)
                    {
                        result.IsAcceptInvitationShow = true;
                        result.IsRejectInvitationShow = false;
                    }
                }
            }
            else if (status == TransactionStatusEnum.InProgress)//进行中
            {
                if (isApplyUser || isExpertUser || isJoiner || isExpertAssistantDoctor)
                {
                    result.IsJoinInShow = true;
                }
                //进行中可以写报告
                if (isExpertUser || isExpertAssistantDoctor)
                {
                    var reportRequest = new GetReportByRecordCodeDBRequest { RecordCode = consultationCode };
                    var report = await _reportDBService.GetReportByRecordCodeAsync(reportRequest);
                    if (report != null && report.Count > 0)
                    {
                        result.IsEditReportShow = true;
                    }
                    else
                    {
                        result.IsReportShow = true;
                    }
                }
            }
            else if (status == TransactionStatusEnum.PendingReport)//待报告
            {
                if (isExpertUser)
                {
                    result.IsInitiateShow = true;
                }
                if (isExpertUser || isExpertAssistantDoctor)
                {
                    result.IsReportShow = true;
                }
            }
            else if (status == TransactionStatusEnum.End)//已结束
            {
                if (isApplyUser)
                {
                    //评价
                    var evaluateList = await _consultationRecordDBService.GetAllConsultationEvaluatesByCodesAsync(new List<string> { result.ConsultationCode });
                    if (evaluateList == null || evaluateList.Count == 0)
                    {
                        result.IsEvaluateShow = true;
                    }
                }
                if (isExpertUser || isExpertAssistantDoctor)
                {
                    result.IsEditReportShow = true;
                }
                result.IsFollowUpShow = true;
            }
            if (result.IsEmergency && result.ConsultationStatus != TransactionStatusEnum.End)
            {
                if (isExpertDirector || isExpertUser || isExpertAssistant)
                {
                    result.IsImproveShow = true;
                }
            }
            if (isExpertDirector || isApplyDirector)
            {
                result.IsDeleteShow = true;
            }
            SetEncryptedShow(result.PatientDatas, rootOrg.IsEncryptedShow);
            return result;
        }

        /// <summary>
        /// 批准会诊
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> ApprovalConsultationAsync(ApprovalConsultationRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userInfoDTO = await _userDBService.FindUserByCodeAsync(userCode);
            //必填项验证
            if (userInfoDTO == null || string.IsNullOrWhiteSpace(userInfoDTO.UserCode))
            {
                ThrowRpcException(CustomerRpcCode.UserNotFind, "User not find");
            }
            request.ConsultationTime = request.ConsultationTime.ToUniversalTime();
            request.ConsultationTimeEnd = request.ConsultationTimeEnd.ToUniversalTime();
            if (request.ConsultationTime == DateTime.MinValue || request.ConsultationTime <= DateTime.UtcNow || request.ConsultationTimeEnd == DateTime.MinValue || request.ConsultationTimeEnd <= DateTime.UtcNow)
            {
                //会诊时间不存在
                ThrowRpcException(CustomerRpcCode.ConsultationTimeGreaterThanCurrentTime, "Consultation time greater than current time");
            }
            if (string.IsNullOrEmpty(request.ExpertUserCode))
            {
                ThrowRpcException(CustomerRpcCode.ConsultationExpertNotExist, "Consultation expert not exist");
            }
            var expertUserInfoDTO = await _userDBService.FindUserByCodeAsync(request.ExpertUserCode);
            if (expertUserInfoDTO == null || string.IsNullOrEmpty(expertUserInfoDTO.UserCode))
            {
                //会诊专家不存在
                ThrowRpcException(CustomerRpcCode.ConsultationExpertNotExist, "Consultation expert not exist");
            }
            //职位验证，机构负责人可以看到全部
            bool isExpertOrAssistant = false;
            //角色验证，主管专家和专家助理
            if (userInfoDTO.RoleCodes.Contains("Role_ExpertAssistant") || userInfoDTO.RoleCodes.Contains("Role_CertifiedExpert"))
            {
                isExpertOrAssistant = true;
            }
            if (!userInfoDTO.IsDirector && !isExpertOrAssistant)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationNorightError, "Consultation noright error");
            }
            //状态验证
            var dbRequest = new ConsultationRecordCodeDBRequest()
            {
                Code = request.ConsultationCode
            };
            var consultationRecord = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(dbRequest);
            if (consultationRecord.ExpertOrganizationCode != userInfoDTO.RootOrganizationCode)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationNorightError, "Consultation noright error");
            }
            if (consultationRecord.ConsultationStatus != TransactionStatusEnum.Applied)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationStatusError, "Consultation status error");
            }

            //人员关系验证，当前助理是否有这个专家，
            if (!userInfoDTO.IsDirector)
            {//机构负责人，不做任何验证
                //这里逻辑为非机构负责人
                if (!string.IsNullOrEmpty(consultationRecord.ExpertUserCode))
                {
                    if (userInfoDTO.RoleCodes.Contains("Role_ExpertAssistant"))
                    {
                        var resultData = await GetOrganizationBindExpertsByUserCodeAsync(userInfoDTO.UserCode);
                        if (resultData?.Count > 0)
                        {
                            var existExpert = resultData.ToList().Exists(c => c.UserCode == request.ExpertUserCode);
                            if (!existExpert)
                            {
                                //当前助理跟专家的关系不存在，不能处理
                                ThrowRpcException(CustomerRpcCode.ConsultationNorightError, "Consultation noright error");
                            }
                        }
                    }
                    else if (userInfoDTO.RoleCodes.Contains("Role_CertifiedExpert"))
                    {
                        if (consultationRecord.ExpertUserCode != userInfoDTO.UserCode)
                        {
                            //当前专家和申请单中的专家不一致
                            ThrowRpcException(CustomerRpcCode.ConsultationNorightError, "Consultation noright error");
                        }
                    }
                }
                else
                //如果申请专家的没填，则只有机构的助理和机构负责人可以看到，专家看不到
                {
                    if (userInfoDTO.RoleCodes.Contains("Role_CertifiedExpert"))
                    {
                        //当前专家和申请单中的专家不一致
                        ThrowRpcException(CustomerRpcCode.ConsultationNorightError, "Consultation noright error");
                    }
                    else if (!userInfoDTO.RoleCodes.Contains("Role_ExpertAssistant"))
                    {
                        ThrowRpcException(CustomerRpcCode.ConsultationNorightError, "Consultation noright error");
                    }
                }
            }
            if (request.ConsultationReminders != null && request.ConsultationReminders.Count > 0)
            {
                foreach (var item in request.ConsultationReminders)
                {
                    item.IsExecuted = false;
                }
            }
            //查询参与人的机构和部门 ，相关数据存储
            var consultationMemberCodes = request.ConsultationMemberCodes ?? new List<string>();
            //获取参与人员列表
            var members = new List<ConsultationMemberDTO>();
            //自动把助理医师加到参与人里面
            if (!string.IsNullOrWhiteSpace(expertUserInfoDTO.BindAssistantDoctorUserCode))
            {
                var assistantDoctorUser = await _userDBService.FindUserByCodeAsync(expertUserInfoDTO.BindAssistantDoctorUserCode);
                var addMemberDTO = new ConsultationMemberDTO()
                {
                    MemberCode = assistantDoctorUser.UserCode,
                    MemberOrganizationCode = assistantDoctorUser.RootOrganizationCode,
                    MemberDepartmentCode = assistantDoctorUser.OrganizationCode,
                    MemberStatus = LiveConsultationMemberStatus.Accepted
                };
                members.Add(addMemberDTO);
            }
            if (consultationMemberCodes?.Count > 0)
            {
                foreach (var code in consultationMemberCodes)
                {
                    //去重处理
                    //助理医师会自动加，不用选加进来
                    if (code == expertUserInfoDTO.BindAssistantDoctorUserCode)
                    {
                        continue;
                    }
                    //基层和会诊专家不用加进来
                    if (code == expertUserInfoDTO.UserCode || code == consultationRecord.ApplyUserCode)
                    {
                        continue;
                    }
                    var tempMemberInfo = await _userDBService.FindUserByCodeAsync(code);
                    var addMemberDTO = new ConsultationMemberDTO()
                    {
                        MemberCode = tempMemberInfo.UserCode,
                        MemberOrganizationCode = tempMemberInfo.RootOrganizationCode,
                        MemberDepartmentCode = tempMemberInfo.OrganizationCode
                    };
                    members.Add(addMemberDTO);
                }
            }
            consultationRecord.Location = request.Location;
            consultationRecord.Description = request.Description;
            //如果之前未选择会诊专家，由助理选择了会诊专家且该专家没有设置助理则将该助理设置为该专家的专家助理
            if (userInfoDTO.RoleCodes.Contains("Role_ExpertAssistant") && string.IsNullOrWhiteSpace(consultationRecord.ExpertUserCode) && string.IsNullOrWhiteSpace(expertUserInfoDTO.BindAssistantUserCode))
            {
                expertUserInfoDTO.BindAssistantUserCode = userInfoDTO.UserCode;
                await _userDBService.UpdateUserAsync(expertUserInfoDTO.UserCode, expertUserInfoDTO.MappingTo<UserPasswordDTO>(), null);
            }
            //会诊专家赋值
            consultationRecord.ExpertUserCode = expertUserInfoDTO.UserCode;
            consultationRecord.ExpertOrganizationCode = expertUserInfoDTO.RootOrganizationCode;
            if (expertUserInfoDTO.OrganizationCode != expertUserInfoDTO.RootOrganizationCode)
            {
                consultationRecord.ExpertDepartmentCode = expertUserInfoDTO.OrganizationCode;
            }
            else
            {
                consultationRecord.ExpertDepartmentCode = "";
            }
            //参与人员列表
            consultationRecord.ConsultationMembers = members;
            consultationRecord.ConsultationTime = request.ConsultationTime;
            consultationRecord.ConsultationTimeEnd = request.ConsultationTimeEnd;
            consultationRecord.ConsultationReminders = request.ConsultationReminders?.ToList();
            consultationRecord.ApproverCode = userCode;
            consultationRecord.ConsultationStatus = TransactionStatusEnum.ToStart;
            //通知用字段 ExpertUserName PatientName 未落库
            consultationRecord.ExpertUserName = expertUserInfoDTO.FullName;
            consultationRecord.PatientName = GetPatientName(consultationRecord.PatientDatas);
            var result = await _consultationRecordDBService.UpdateConsultationRecordAsync(consultationRecord);
            var patientName = GetPatientName(consultationRecord.PatientDatas);
            //批准通知申请方
            var approvalApplyConsultationNotification = new ApprovalApplyConsultationNotification
            {
                OperatorName = userInfoDTO.FullName,
                PatientName = patientName,
                ConsultationTime = consultationRecord.ConsultationTime.ToUniversalTime(),
                ConsultationTimeEnd = consultationRecord.ConsultationTimeEnd.ToUniversalTime(),
                ConsultationCode = consultationRecord.ConsultationCode,
                ExpertName = consultationRecord.ExpertUserName
            };
            var clientIds = new List<string> { consultationRecord.ApplyUserCode };
            if (consultationRecord.ApplyUserCode != consultationRecord.OperateUserCode)
            {
                clientIds.Add(consultationRecord.OperateUserCode);
            }
            var broadcastNotificationRequest = new BroadcastNotificationRequest()
            {
                ClientIds = clientIds,
                Message = approvalApplyConsultationNotification,
                JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(approvalApplyConsultationNotification),
                NotificationType = approvalApplyConsultationNotification.NotificationType,
                TransactionType = TransactionTypeEnum.Consultion,
                RelevanceCode = consultationRecord.ConsultationCode,
                ReceiverType = ApplicantTypeEnum.Client
            };
            await _notificationService.BroadcastMessageAsync(broadcastNotificationRequest);
            if (consultationMemberCodes != null && consultationMemberCodes.Count > 0)
            {
                consultationMemberCodes = consultationMemberCodes.Where(x => !clientIds.Contains(x)).ToList();
                if (consultationMemberCodes.Count > 0)
                {
                    //批准通知参与方
                    var inviteeConsultationNotification = new InviteeConsultationNotification
                    {
                        OperatorName = userInfoDTO.FullName,
                        PatientName = GetPatientName(consultationRecord.PatientDatas),
                        ConsultationTime = consultationRecord.ConsultationTime.ToUniversalTime(),
                        ConsultationTimeEnd = consultationRecord.ConsultationTimeEnd.ToUniversalTime(),
                        ConsultationCode = consultationRecord.ConsultationCode,
                    };
                    if (consultationRecord.ApplyUserCode != consultationRecord.OperateUserCode)
                    {
                        clientIds.Add(consultationRecord.OperateUserCode);
                    }
                    var inviteeBroadcastNotificationRequest = new BroadcastNotificationRequest()
                    {
                        ClientIds = consultationMemberCodes.ToList(),
                        Message = inviteeConsultationNotification,
                        JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(inviteeConsultationNotification),
                        NotificationType = inviteeConsultationNotification.NotificationType,
                        TransactionType = TransactionTypeEnum.Consultion,
                        RelevanceCode = consultationRecord.ConsultationCode,
                        ReceiverType = ApplicantTypeEnum.Client
                    };
                    await _notificationService.BroadcastMessageAsync(inviteeBroadcastNotificationRequest);
                    //发送参与人邀请短信
                    await SendSmsInviteConsultationAsync(consultationMemberCodes.ToList(),
                            inviteeConsultationNotification.OperatorName,
                            inviteeConsultationNotification.PatientName,
                            inviteeConsultationNotification.ConsultationTime,
                            inviteeConsultationNotification.ConsultationTimeEnd);
                }
            }
            //更新日程
            var userCodes = new List<string>();
            var expertUserCode = consultationRecord.ExpertUserCode;
            if (!string.IsNullOrWhiteSpace(expertUserCode) && !userCodes.Contains(expertUserCode))
            {
                userCodes.Add(expertUserCode);
            }
            var applyUserCode = consultationRecord.ApplyUserCode;
            if (!string.IsNullOrWhiteSpace(applyUserCode) && !userCodes.Contains(applyUserCode))
            {
                userCodes.Add(applyUserCode);
            }
            var addScheduleDBRequest = new AddScheduleDBRequest();
            addScheduleDBRequest.Data = new ScheduleDTO()
            {
                Title = patientName,
                StartTime = consultationRecord.ConsultationTime,
                EndTime = consultationRecord.ConsultationTimeEnd,
                Status = TransactionStatusEnum.ToStart,
                ScheduleType = ScheduleTypeEnum.Consultation,
                RelevanceCode = consultationRecord.ConsultationCode,
                UserCodes = userCodes
            };
            var room = await CreateLiveRoomAsync(consultationRecord.ConsultationCode);
            var resultRoomInfo = await _rtcService.AddOrUpdateLiveRoomAsync(new AddOrUpdateLiveRoomRequest
            {
                LiveRoom = room
            });
            Logger.WriteLineInfo($"LiveConsultationService ApprovalConsultationAsync CreateLiveRoom, data:{Newtonsoft.Json.JsonConvert.SerializeObject(resultRoomInfo)}");     
            await _userDBService.AddScheduleDBAsync(addScheduleDBRequest);
            return result;
        }

        private string GetPatientName(List<DataItemDTO> patientDatas)
        {
            var name = patientDatas.FirstOrDefault(x => x.Key == "Name")?.Value;
            if (string.IsNullOrWhiteSpace(name))
            {
                name = patientDatas.FirstOrDefault(x => x.Key == "AnimalInfoName")?.Value;
            }
            return CryptionHelper.NameEncrypt(name, false);
        }

        /// <summary>
        /// 撤销会诊
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> RevokeConsultationAsync(RevokeConsultationRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userInfoDTO = await _userDBService.FindUserByCodeAsync(userCode);
            var dbRequest = new ConsultationRecordCodeDBRequest();
            dbRequest.Code = request.ConsultationCode;
            var consultationRecord = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(dbRequest);
            if (consultationRecord.ConsultationStatus != TransactionStatusEnum.Applied)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationStatusError, "ConsultationStatusError");
            }
            if (consultationRecord.ApplyOrganizationCode != userInfoDTO.RootOrganizationCode)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationNorightError, "ConsultationNorightError");
            }
            var isApplyAssistant = false;//是否是申请专家的助理
            if (userInfoDTO.RoleCodes.Contains("Role_ExpertAssistant"))
            {
                var resultData = await GetOrganizationBindExpertsByUserCodeAsync(userCode);
                if (resultData?.Count > 0)
                {
                    isApplyAssistant = resultData.ToList().Exists(c => c.UserCode == consultationRecord.ApplyUserCode);
                }
            }
            if (consultationRecord.ApplyUserCode != userInfoDTO.UserCode && !userInfoDTO.IsDirector && !isApplyAssistant)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationNorightError, "ConsultationNorightError");
            }
            consultationRecord.ConsultationStatus = TransactionStatusEnum.Withdrawn;
            var result = await _consultationRecordDBService.UpdateConsultationRecordAsync(consultationRecord);
            return result;
        }

        /// <summary>
        /// 删除会诊
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> DeleteConsultationAsync(DeleteConsultationRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userInfoDTO = await _userDBService.FindUserByCodeAsync(userCode);
            var dbRequest = new ConsultationRecordCodeDBRequest();
            dbRequest.Code = request.ConsultationCode;
            var consultationRecord = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(dbRequest);
            if (consultationRecord.ApplyOrganizationCode != userInfoDTO.RootOrganizationCode &&
            consultationRecord.ExpertOrganizationCode != userInfoDTO.RootOrganizationCode)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationNorightError, "ConsultationNorightError");
            }
            if (!userInfoDTO.IsDirector)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationNorightError, "ConsultationNorightError");
            }
            var result = await _consultationRecordDBService.DeleteConsultationRecordByCodeAsync(dbRequest);
            return result;
        }

        /// <summary>
        /// 保存预约会诊图像
        /// 累加保存
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> UpdateConsultationFilesInfoAsync(UpdateConsultationFilesInfoRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userInfoDTO = await _userDBService.FindUserByCodeAsync(userCode);
            var files = request.FileInfos;
            if (files == null || files.Count <= 0)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationUploadFileInfoIsEmpty, "ConsultationUploadFileInfoIsEmpty");
            }
            if (string.IsNullOrEmpty(request.ConsultationCode))
            {
                ThrowRpcException(CustomerRpcCode.ConsultationCodeIsEmpty, "ConsultationCodeIsEmpty");
            }
            var dbRequest = new ConsultationRecordCodeDBRequest();
            dbRequest.Code = request.ConsultationCode;
            var consultationRecord = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(dbRequest);
            if (consultationRecord.ConsultationFileList == null)
            {
                consultationRecord.ConsultationFileList = new List<ConsultationFileDTO>();
            }
            foreach (var item in files)
            {
                var consultationFileDTO = new ConsultationFileDTO
                {
                    SourceUrl = item.SourceUrl,
                    CoverImageUrl = item.CoverImageUrl,
                    PreviewImageUrl = item.PreviewImageUrl,
                    FileDataType = item.FileDataType,
                    CreateTime = DateTime.UtcNow,
                    CreatorCode = userCode,
                    ConsultationFileType = item.ConsultationFileType
                };
                consultationRecord.ConsultationFileList.Add(consultationFileDTO);
            }
            var result = await _consultationRecordDBService.UpdateConsultationRecordAsync(consultationRecord);
            return result;
        }

        /// <summary>
        /// 拒绝申请的会诊请求
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> RejectApplyConsultationAsync(RejectApplyConsultationRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userInfoDTO = await _userDBService.FindUserByCodeAsync(userCode);
            var dbRequest = new ConsultationRecordCodeDBRequest();
            dbRequest.Code = request.ConsultationCode;
            var consultationRecord = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(dbRequest);
            if (consultationRecord.ConsultationStatus != TransactionStatusEnum.Applied)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationStatusError, "ConsultationStatusError");
            }
            if (consultationRecord.ExpertOrganizationCode != userInfoDTO.RootOrganizationCode)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationNorightError, "ConsultationNorightError");
            }
            var isExpertAssistant = false;//是否会诊专家的助理
            if (userInfoDTO.RoleCodes.Contains("Role_ExpertAssistant"))
            {
                //如果会诊单没有选择会诊专家则所有该会诊机构的专家助理都可以操作
                if (string.IsNullOrWhiteSpace(consultationRecord.ExpertUserCode))
                {
                    isExpertAssistant = true;
                }
                else
                {
                    var resultData = await GetOrganizationBindExpertsByUserCodeAsync(userCode);
                    if (resultData?.Count > 0)
                    {
                        isExpertAssistant = resultData.ToList().Exists(c => c.UserCode == consultationRecord.ExpertUserCode);
                    }
                }
            }
            if (!userInfoDTO.IsDirector && consultationRecord.ExpertUserCode != userCode && !isExpertAssistant)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationNorightError, "ConsultationNorightError");
            }
            if (string.IsNullOrWhiteSpace(request.Reason))
            {
                ThrowRpcException(CustomerRpcCode.RejectReasonIsEmpty, "RejectReasonIsEmpty");
            }
            consultationRecord.ConsultationStatus = TransactionStatusEnum.Rejected;
            consultationRecord.RejectReason = request.Reason;
            var result = await _consultationRecordDBService.UpdateConsultationRecordAsync(consultationRecord);
            if (result)
            {
                //拒绝申请通知 
                var rejectApplyConsultationNotification = new RejectApplyConsultationNotification
                {
                    OperatorName = userInfoDTO.FullName,
                    RejectReason = request.Reason,
                    ConsultationCode = request.ConsultationCode,
                    PatientName = GetPatientName(consultationRecord.PatientDatas),
                };
                var clientIds = new List<string> { consultationRecord.ApplyUserCode };
                if (consultationRecord.ApplyUserCode != consultationRecord.OperateUserCode)
                {
                    clientIds.Add(consultationRecord.OperateUserCode);
                }
                var broadcastNotificationRequest = new BroadcastNotificationRequest()
                {
                    ClientIds = clientIds,
                    Message = rejectApplyConsultationNotification,
                    JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(rejectApplyConsultationNotification),
                    NotificationType = rejectApplyConsultationNotification.NotificationType,
                    TransactionType = TransactionTypeEnum.Consultion,
                    RelevanceCode = request.ConsultationCode,
                    ReceiverType = ApplicantTypeEnum.Client
                };
                await _notificationService.BroadcastMessageAsync(broadcastNotificationRequest);
            }
            return result;
        }


        /// <summary>
        /// 查询自己所在的机构专家助理集合
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<IList<ConsultationAssistantDTO>> FindOrganizationAssistantsAsync(FindOrganizationAssistantsRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userInfoDTO = await _userDBService.FindUserByCodeAsync(userCode);
            var result = await FindOrganizationAssistantsAsync(userInfoDTO.RootOrganizationCode, "Role_ExpertAssistant");
            result = result.Where(x => x.FullName.Contains(request.AssistantName) || x.UserName.Contains(request.AssistantName)).ToList();
            var assistants = result.MappingTo<List<ConsultationAssistantDTO>>();
            return assistants;
        }

        /// <summary>
        /// 查询自己所在的机构认证医师集合
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<IList<ConsultationAssistantDoctorDTO>> FindOrganizationAssistantDoctorsAsync(FindOrganizationAssistantDoctorsRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userInfoDTO = await _userDBService.FindUserByCodeAsync(userCode);
            var result = await FindOrganizationAssistantsAsync(userInfoDTO.RootOrganizationCode, "Role_CertifiedPhysician");
            result = result.Where(x => x.FullName.Contains(request.AssistantDoctorName) || x.UserName.Contains(request.AssistantDoctorName)).ToList();
            var assistantDoctors = result.MappingTo<List<ConsultationAssistantDoctorDTO>>();
            return assistantDoctors;
        }

        /// <summary>
        /// 查询自己所在的机构对应的角色用户集合
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private async Task<IList<UserDTO>> FindOrganizationAssistantsAsync(string rootOrganizationCode, string roleCode)
        {
            List<UserDTO> result = new List<UserDTO>();
            if (string.IsNullOrWhiteSpace(rootOrganizationCode))
            {
                return result;
            }
            var dbRequest = new GetUserListDBRequest
            {
                OrganizationCode = rootOrganizationCode,
                OrganizationQueryType = OrganizationQueryTypeEnum.All,
                RankCode = "",
                PositionCode = "",
                RoleCodes = new List<string> { roleCode },
                ExceptUsers = new List<string>()
            };
            var users = await _userDBService.GetUserListAsync(dbRequest);
            if (users != null && users.Count > 0)
            {
                result = users;
            }
            return result;
        }

        /// <summary>
        /// 更新设置自己的专家助理
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> UpdateMyOrganizationAssistantAsync(UpdateMyOrganizationAssistantRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userInfoDTO = await _userDBService.FindUserByCodeAsync(userCode);
            if (!userInfoDTO.RoleCodes.Contains("Role_CertifiedExpert"))
            {
                ThrowRpcException(CustomerRpcCode.NoExpertFeature, "NoExpertFeature");
            }
            if (!string.IsNullOrWhiteSpace(request.AssistantUserCode))
            {
                var assistant = await _userDBService.FindUserByCodeAsync(request.AssistantUserCode);
                if (assistant != null && !string.IsNullOrWhiteSpace(assistant.UserCode))
                {
                    if (!assistant.RoleCodes.Contains("Role_ExpertAssistant"))
                    {
                        ThrowRpcException(CustomerRpcCode.NotExpertAssistant, "NotExpertAssistant");
                    }
                }
            }
            if (!string.IsNullOrWhiteSpace(request.AssistantDoctorUserCode))
            {
                var assistantDoctor = await _userDBService.FindUserByCodeAsync(request.AssistantDoctorUserCode);
                if (assistantDoctor != null && !string.IsNullOrWhiteSpace(assistantDoctor.UserCode))
                {
                    if (!assistantDoctor.RoleCodes.Contains("Role_CertifiedPhysician"))
                    {
                        ThrowRpcException(CustomerRpcCode.NotCertifiedPhysician, "NotCertifiedPhysician");
                    }
                }
            }
            userInfoDTO.BindAssistantUserCode = request.AssistantUserCode;
            userInfoDTO.BindAssistantDoctorUserCode = request.AssistantDoctorUserCode;
            return await _userDBService.UpdateUserAsync(userCode, userInfoDTO.MappingTo<UserPasswordDTO>(), string.Empty, true);
        }


        /// <summary>
        ///查询已创建已登记的病人
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<PageResult<ClientPatientInfoBaseDTO>> FindConsultationPatientAsync(FindConsultationPatientPageRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            if (request.StartDate > DateTime.MinValue && request.EndDate > DateTime.MinValue)
            {
                if (request.StartDate > request.EndDate)
                {
                    ThrowRpcException((int)CustomerRpcCode.StartTimeGreaterThanEndTime, "StartTime Greater Than EndTime error");
                }
            }
            //用户
            var userDTO = await _userDBService.FindUserByCodeAsync(userCode);
            if (userDTO == null)
            {
                ThrowRpcException(CustomerRpcCode.UserNotExistError, "User does not exist");
            }
            var result = new PageResult<ClientPatientInfoBaseDTO>();
            var keywordfilter = new Dictionary<string, string>();
            if (!string.IsNullOrWhiteSpace(request.Keyword))
            {
                var tempKeyWord = CryptionHelper.EncryptOneByOne(request.Keyword.Trim());
                keywordfilter.Add("Name", tempKeyWord);
                keywordfilter.Add("Phone", tempKeyWord);
            }
            var pageFilterRequest = new GetPatientsByOrgPageRequest()
            {
                RootOrganizationCode = userDTO.RootOrganizationCode,
                KeywordOrFilter = keywordfilter,
                CurrentPage = request.PageIndex,
                PageSize = request.PageSize,
                IsFuzzy = true
            };
            pageFilterRequest.StartTime = request.StartDate;
            pageFilterRequest.EndTime = request.EndDate;
            pageFilterRequest.IsValid = PatientValidStatusEnum.CheckIn;
            pageFilterRequest.UserCode = userCode;
            var filter = new Dictionary<string, string>();
            var data = await _patientInfoDBService.GetPatientsAsync(pageFilterRequest);
            result.PageIndex = request.PageIndex;
            result.PageSize = request.PageSize;
            result.TotalCount = data.DataCount;
            var rootOrg = await _organizationDBService.GetOrganizationDetailAsync(new GetOrganizationDBRequest { OrganizationCode = userDTO.RootOrganizationCode });
            foreach (var item in data.PageData)
            {
                SetEncryptedShow(item, rootOrg.IsEncryptedShow);
                result.PageData.Add(item.MappingTo<ClientPatientInfoBaseDTO>());
            }
            return result;
        }
        private void SetEncryptedShow(PatientInfoDTO patientInfo, bool isEncryptedShow)
        {

            if (patientInfo.PatientData.FirstOrDefault(x => x.Key == "AnimalInfoName") != null && !string.IsNullOrWhiteSpace(patientInfo.PatientData.FirstOrDefault(x => x.Key == "AnimalInfoName").Value))
            {
                patientInfo.PatientData.FirstOrDefault(x => x.Key == "AnimalInfoName").Value = CryptionHelper.NameEncrypt(patientInfo.Name, isEncryptedShow);
            }
            if (patientInfo.PatientData.FirstOrDefault(x => x.Key == "AnimalInfoPhone") != null && !string.IsNullOrWhiteSpace(patientInfo.PatientData.FirstOrDefault(x => x.Key == "AnimalInfoPhone").Value))
            {
                patientInfo.PatientData.FirstOrDefault(x => x.Key == "AnimalInfoPhone").Value = CryptionHelper.PhoneEncrypt(patientInfo.Phone, isEncryptedShow);
            }
            if (patientInfo.PatientData.FirstOrDefault(x => x.Key == "AnimalInfoIdentityCard") != null && !string.IsNullOrWhiteSpace(patientInfo.PatientData.FirstOrDefault(x => x.Key == "AnimalInfoIdentityCard").Value))
            {
                patientInfo.PatientData.FirstOrDefault(x => x.Key == "AnimalInfoIdentityCard").Value = CryptionHelper.IDNumberEncrypt(patientInfo.IdentityCard, isEncryptedShow);
            }
            if (patientInfo.PatientData.FirstOrDefault(x => x.Key == "Name") != null && !string.IsNullOrWhiteSpace(patientInfo.PatientData.FirstOrDefault(x => x.Key == "Name").Value))
            {
                patientInfo.PatientData.FirstOrDefault(x => x.Key == "Name").Value = CryptionHelper.NameEncrypt(patientInfo.Name, isEncryptedShow);
            }
            if (patientInfo.PatientData.FirstOrDefault(x => x.Key == "Phone") != null && !string.IsNullOrWhiteSpace(patientInfo.PatientData.FirstOrDefault(x => x.Key == "Phone").Value))
            {
                patientInfo.PatientData.FirstOrDefault(x => x.Key == "Phone").Value = CryptionHelper.PhoneEncrypt(patientInfo.Phone, isEncryptedShow);
            }
            if (patientInfo.PatientData.FirstOrDefault(x => x.Key == "IdentityCard") != null && !string.IsNullOrWhiteSpace(patientInfo.PatientData.FirstOrDefault(x => x.Key == "IdentityCard").Value))
            {
                patientInfo.PatientData.FirstOrDefault(x => x.Key == "IdentityCard").Value = CryptionHelper.IDNumberEncrypt(patientInfo.IdentityCard, isEncryptedShow);
            }
            if (patientInfo.PatientData.FirstOrDefault(x => x.Key == "InsuranceCode") != null && !string.IsNullOrWhiteSpace(patientInfo.PatientData.FirstOrDefault(x => x.Key == "InsuranceCode").Value))
            {
                patientInfo.PatientData.FirstOrDefault(x => x.Key == "InsuranceCode").Value = CryptionHelper.SSNumberEncrypt(patientInfo.InsuranceCode, isEncryptedShow);
            }
            patientInfo.Name = CryptionHelper.NameEncrypt(patientInfo.Name, isEncryptedShow);
            patientInfo.Phone = CryptionHelper.PhoneEncrypt(patientInfo.Phone, isEncryptedShow);
            patientInfo.IdentityCard = CryptionHelper.IDNumberEncrypt(patientInfo.IdentityCard, isEncryptedShow);
            patientInfo.InsuranceCode = CryptionHelper.SSNumberEncrypt(patientInfo.InsuranceCode, isEncryptedShow);
        }

        private void SetEncryptedShow(List<DataItemDTO> patientData, bool isEncryptedShow)
        {
            if (patientData.FirstOrDefault(x => x.Key == "AnimalInfoName") != null && !string.IsNullOrWhiteSpace(patientData.FirstOrDefault(x => x.Key == "AnimalInfoName").Value))
            {
                patientData.FirstOrDefault(x => x.Key == "AnimalInfoName").Value = CryptionHelper.NameEncrypt(patientData.FirstOrDefault(x => x.Key == "AnimalInfoName").Value, isEncryptedShow);
            }
            if (patientData.FirstOrDefault(x => x.Key == "AnimalInfoPhone") != null && !string.IsNullOrWhiteSpace(patientData.FirstOrDefault(x => x.Key == "AnimalInfoPhone").Value))
            {
                patientData.FirstOrDefault(x => x.Key == "AnimalInfoPhone").Value = CryptionHelper.PhoneEncrypt(patientData.FirstOrDefault(x => x.Key == "AnimalInfoPhone").Value, isEncryptedShow);
            }
            if (patientData.FirstOrDefault(x => x.Key == "AnimalInfoIdentityCard") != null && !string.IsNullOrWhiteSpace(patientData.FirstOrDefault(x => x.Key == "AnimalInfoIdentityCard").Value))
            {
                patientData.FirstOrDefault(x => x.Key == "AnimalInfoIdentityCard").Value = CryptionHelper.IDNumberEncrypt(patientData.FirstOrDefault(x => x.Key == "AnimalInfoIdentityCard").Value, isEncryptedShow);
            }
            if (patientData.FirstOrDefault(x => x.Key == "Name") != null && !string.IsNullOrWhiteSpace(patientData.FirstOrDefault(x => x.Key == "Name").Value))
            {
                patientData.FirstOrDefault(x => x.Key == "Name").Value = CryptionHelper.NameEncrypt(patientData.FirstOrDefault(x => x.Key == "Name").Value, isEncryptedShow);
            }
            if (patientData.FirstOrDefault(x => x.Key == "Phone") != null && !string.IsNullOrWhiteSpace(patientData.FirstOrDefault(x => x.Key == "Phone").Value))
            {
                patientData.FirstOrDefault(x => x.Key == "Phone").Value = CryptionHelper.PhoneEncrypt(patientData.FirstOrDefault(x => x.Key == "Phone").Value, isEncryptedShow);
            }
            if (patientData.FirstOrDefault(x => x.Key == "IdentityCard") != null && !string.IsNullOrWhiteSpace(patientData.FirstOrDefault(x => x.Key == "IdentityCard").Value))
            {
                patientData.FirstOrDefault(x => x.Key == "IdentityCard").Value = CryptionHelper.IDNumberEncrypt(patientData.FirstOrDefault(x => x.Key == "IdentityCard").Value, isEncryptedShow);
            }
            if (patientData.FirstOrDefault(x => x.Key == "InsuranceCode") != null && !string.IsNullOrWhiteSpace(patientData.FirstOrDefault(x => x.Key == "InsuranceCode").Value))
            {
                patientData.FirstOrDefault(x => x.Key == "InsuranceCode").Value = CryptionHelper.SSNumberEncrypt(patientData.FirstOrDefault(x => x.Key == "InsuranceCode").Value, isEncryptedShow);
            }
        }

        /// <summary>
        /// 助理查询自己所服务的专家集合
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<IList<ConsultationExpertDTO>> FindOrganizationBindExpertsAsync(FindOrganizationBindExpertsRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var result = await GetOrganizationBindExpertsByUserCodeAsync(userCode);
            return result?.MappingTo<IList<ConsultationExpertDTO>>();
        }

        /// <summary>
        /// 助理查询自己所服务的专家集合
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private async Task<IList<UserDTO>> GetOrganizationBindExpertsByUserCodeAsync(string userCode)
        {
            var userInfoDTO = await _userDBService.FindUserByCodeAsync(userCode);
            if (!userInfoDTO.RoleCodes.Contains("Role_ExpertAssistant") && !userInfoDTO.IsDirector)
            {
                return new List<UserDTO>();
            }
            var userList = await FindOrganizationAssistantsAsync(userInfoDTO.RootOrganizationCode, "Role_CertifiedExpert");
            //如果是机构负责人返回全部专家
            if (userInfoDTO.IsDirector)
            {
                return userList.MappingTo<IList<UserDTO>>();
            }
            var bindExperts = await _userDBService.GetBindExpertsAsync(userCode);
            //如果绑定了专家额返回绑定的专家
            if (bindExperts.Any())
            {
                return bindExperts.MappingTo<IList<UserDTO>>();
            }
            else//如果没有绑定任何专家则返回全部专家
            {
                return userList.MappingTo<IList<UserDTO>>();
            }
        }

        /// <summary>
        /// 查询扫查部位列表
        /// </summary>
        /// <param name="request">token请求实体</param>
        /// <returns></returns>
        public async Task<List<string>> FindScanPositionsAsync(TokenRequest request)
        {
            var resultList = new List<string>();
            var json = File.ReadAllText(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Resource", "Consultation", "ScanPosition.json"));
            JObject o = JObject.Parse(json);
            var scanPositionList = o["ScanPosition"]["Source"].ToList();
            if (scanPositionList?.Count > 0)
            {
                resultList = scanPositionList.Select(c => c.ToString()).Distinct().ToList();
            }
            // result.SettingVersion = o["General"]["Version"].ToString();
            // o.Remove("General");
            // result.SettingData = o.ToString();
            return resultList;
        }

        /// <summary>
        /// 接受会诊邀请
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> AcceptInvitationAsync(AcceptInvitationRequest request)
        {
            if (string.IsNullOrWhiteSpace(request.ConsultationRecordCode))
            {
                ThrowRpcException(CustomerRpcCode.ConsultationNotExisted, "ConsultationNotExisted");
            }
            var dbRequest = new ConsultationRecordCodeDBRequest();
            dbRequest.Code = request.ConsultationRecordCode;
            var consultationRecord = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(dbRequest);
            if (consultationRecord == null)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationNotExisted, "ConsultationNotExisted");
            }
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userDTO = await _userDBService.FindUserByCodeAsync(userCode);
            var result = await _consultationRecordDBService.SetMemberStatusAsync(new SetMemberStatusDBRequest
            {
                ConsultationRecordCode = request.ConsultationRecordCode,
                MemberCode = userCode,
                MemberStatus = request.IsAgree ? ConsultationMemeberAcceptStatus.Accepted : ConsultationMemeberAcceptStatus.Rejected,
                RefusalCause = request.RefusalCause
            });
            var clientIds = new List<string> { consultationRecord.ExpertUserCode };
            var expertUser = await _userDBService.FindUserByCodeAsync(consultationRecord.ExpertUserCode);
            if (!string.IsNullOrWhiteSpace(expertUser.BindAssistantUserCode))
            {
                clientIds.Add(expertUser.BindAssistantUserCode);
            }
            if (request.IsAgree)
            {
                //同意邀请
                var addScheduleUsersRequest = new AddScheduleUsersDBRequest
                {
                    RelevanceCode = consultationRecord.ConsultationCode,
                    UserCodes = new List<string> { userCode },
                };
                await _userDBService.AddScheduleUsersDBAsync(addScheduleUsersRequest);
                var inviteeApproveApplyConsultationNotification = new InviteeApproveApplyConsultationNotification
                {
                    OperatorName = userDTO.FullName,
                    ConsultationCode = consultationRecord.ConsultationCode,
                    PatientName = GetPatientName(consultationRecord.PatientDatas),
                    ConsultationTime = consultationRecord.ConsultationTime.ToUniversalTime(),
                    ConsultationTimeEnd = consultationRecord.ConsultationTimeEnd.ToUniversalTime(),
                };
                var broadcastNotificationRequest = new BroadcastNotificationRequest()
                {
                    ClientIds = clientIds,
                    Message = inviteeApproveApplyConsultationNotification,
                    JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(inviteeApproveApplyConsultationNotification),
                    NotificationType = inviteeApproveApplyConsultationNotification.NotificationType,
                    TransactionType = TransactionTypeEnum.Consultion,
                    RelevanceCode = consultationRecord.ConsultationCode,
                    ReceiverType = ApplicantTypeEnum.Client
                };
                await _notificationService.BroadcastMessageAsync(broadcastNotificationRequest);

                var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = consultationRecord.ConsultationCode });
                if (room != null)
                {
                    await _rtcService.AgreeInAsync(new AgreeInRequest
                    {
                        LiveRoomCode = room.LiveRoomCode,
                        UserCode = userCode,
                        SortLevel = (int)LiveConsultationRoleEnum.OtherParticipant,
                    });
                }
            }
            else
            {
                //拒绝邀请 
                var inviteeRejectApplyConsultationNotification = new InviteeRejectApplyConsultationNotification
                {
                    OperatorName = userDTO.FullName,
                    ConsultationCode = consultationRecord.ConsultationCode,
                    PatientName = GetPatientName(consultationRecord.PatientDatas),
                    ConsultationTime = consultationRecord.ConsultationTime.ToUniversalTime(),
                    ConsultationTimeEnd = consultationRecord.ConsultationTimeEnd.ToUniversalTime(),
                    RejectReason = request.RefusalCause,
                };
                var broadcastNotificationRequest = new BroadcastNotificationRequest()
                {
                    ClientIds = clientIds,
                    Message = inviteeRejectApplyConsultationNotification,
                    JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(inviteeRejectApplyConsultationNotification),
                    NotificationType = inviteeRejectApplyConsultationNotification.NotificationType,
                    TransactionType = TransactionTypeEnum.Consultion,
                    RelevanceCode = consultationRecord.ConsultationCode,
                    ReceiverType = ApplicantTypeEnum.Client
                };
                await _notificationService.BroadcastMessageAsync(broadcastNotificationRequest);
            }
            return result;
        }

        /// <summary>
        /// 完善会诊信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> ImproveConsultationInfoAsync(ImproveConsultationInfoRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var userInfoDTO = await _userDBService.FindUserByCodeAsync(userCode);
            //验证用户是否为空
            if (userInfoDTO == null || string.IsNullOrWhiteSpace(userInfoDTO.UserCode))
            {
                ThrowRpcException(CustomerRpcCode.UserNotFind, "User Not Find");
            }
            var consultation = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(new ConsultationRecordCodeDBRequest { Code = request.ConsultationCode });
            var applyUser = new UserDTO();
            if (!string.IsNullOrWhiteSpace(consultation.ApplyUserCode))
            {
                applyUser = await _userDBService.FindUserByCodeAsync(consultation.ApplyUserCode);
            }
            if (applyUser.BindAssistantUserCode != userCode && userCode != consultation.ApplyUserCode && userCode != consultation.OperateUserCode && !((consultation.ApplyOrganizationCode == userInfoDTO.RootOrganizationCode) && userInfoDTO.IsDirector))
            {
                ThrowRpcException(CustomerRpcCode.ConsultationNorightError, "Consultation Noright Error");
            }
            if (consultation.ConsultationStatus == TransactionStatusEnum.End)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationStatusError, "Consultation Is Ended");
            }
            if (string.IsNullOrEmpty(request.PatientCode))
            {
                ThrowRpcException(CustomerRpcCode.PatientCodeIsEmpty, "Patient code is empty");
            }
            if (request.PatientDatas != null && request.PatientDatas.Any())
            {
                var patientRequest = new UpdatePatientRequest()
                {
                    Token = request.Token,
                    Code = request.PatientCode,
                    PatientData = request.PatientDatas,
                };
                var patientResult = await _patientService.UpdatePatientAsync(patientRequest);
                if (!patientResult)
                {
                    ThrowRpcException(CustomerRpcCode.UpdatePatientInfoFail, "Update patient information fail");
                }
            }
            consultation.ScanPosition = request.ScanPosition;
            consultation.Diseases = request.Diseases;
            consultation.PrimaryDiagnosis = request.PrimaryDiagnosis;
            var result = await _consultationRecordDBService.UpdateConsultationRecordAsync(consultation, true);
            return result;
        }

        /// <summary>
        /// 获取用户繁忙状态
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<UserStatusEnum> GetUserStatusAsync(GetUserStatusRequest request)
        {
            var result = GetUserStatus(request.UserCode);
            return result;
        }

        /// <summary>
        /// 根据会诊单号查询会诊中可直接切换的会诊单列表
        /// </summary>
        /// <param name="request">根据会诊单号查询会诊中可直接切换的会诊单列表</param>
        /// <returns></returns>
        /// <errorCodes></errorCodes>
        public async Task<IList<ConsultationPageDTO>> FindCanSwitchConsultationsAsync(FindCanSwitchConsultationsRequest request)
        {
            var result = new List<ConsultationPageDTO>();
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var dbResult = await _consultationRecordDBService.FindCanSwitchConsultationsDBAsync(request.ConsultationCode);
            if (dbResult != null && dbResult.Count > 0)
            {
                var userDTO = await _userDBService.FindUserByCodeAsync(userCode);
                var rootOrg = await _organizationDBService.GetOrganizationDetailAsync(new GetOrganizationDBRequest { OrganizationCode = userDTO.RootOrganizationCode });
                var expertUserCodes = dbResult.Select(x => x.ExpertUserCode).Where(e => !string.IsNullOrWhiteSpace(e)).ToList();
                var expertUsers = new List<UserDTO>();
                if (expertUserCodes.Count > 0)
                {
                    expertUsers = await _userDBService.FindUserListByUserCodesAsync(expertUserCodes);
                }
                //评价
                var evaluateList = await _consultationRecordDBService.GetAllConsultationEvaluatesByCodesAsync(dbResult.Select(x => x.ConsultationCode).ToList());
                foreach (var item in dbResult)
                {
                    if (!string.IsNullOrEmpty(item.ApplyOrganizationCode))
                    {
                        var organization = CacheMaintenance.Instance.Get<IOrganizationsManager>().Get(item.ApplyOrganizationCode);
                        if (organization != null)
                        {
                            item.ApplyOrganizationName = organization.OrganizationName;
                        }
                    }

                    var expertUser = expertUsers.FirstOrDefault(x => x.UserCode == item.ExpertUserCode);
                    var evaluate = evaluateList.FirstOrDefault(x => x.ConsultationRecordCode == item.ConsultationCode);
                    var consultationPageDTO = new ConsultationPageDTO()
                    {
                        ConsultationCode = item.ConsultationCode,
                        PatientName = (item.PatientDatas == null || item.PatientDatas.Count == 0) ? GetNotFilled(request.Language) : CryptionHelper.NameEncrypt(GetPatientValue(item.PatientDatas, "Name"), rootOrg.IsEncryptedShow),
                        Phone = (item.PatientDatas == null || item.PatientDatas.Count == 0) ? "" : CryptionHelper.PhoneEncrypt(GetPatientValue(item.PatientDatas, "Phone"), rootOrg.IsEncryptedShow),
                        PatientAge = (item.PatientDatas == null || item.PatientDatas.Count == 0) ? "" : GetPatientAge(item.PatientDatas, request.Language),
                        Sex = (item.PatientDatas == null || item.PatientDatas.Count == 0) ? "" : GetPatientGender(item.PatientDatas, request.Language),
                        ConsultationTime = item.ConsultationTime.ToUniversalTime(),
                        ConsultationTimeEnd = item.ConsultationTimeEnd.ToUniversalTime(),
                        ApplyOrganizationName = item.ApplyOrganizationName,
                        ExpertUserName = !string.IsNullOrWhiteSpace(expertUser?.FullName) ? expertUser?.FullName : expertUser?.UserName,
                        ConsultationStatus = item.ConsultationStatus,
                        ConsultationEvaluate = evaluate == null ? EvaluateGradeEnum.UnSet : evaluate.EvaluateGrade,
                        IsEmergency = item.IsEmergency,
                        EmergencyCode = item.EmergencyCode
                    };
                    result.Add(consultationPageDTO);
                }
            }
            return result;
        }

        /// <summary>
        /// 会诊大列表导出
        /// </summary>
        /// <param name="request">会诊大列表导出请求实体</param>
        /// <returns></returns>
        /// <errorCodes></errorCodes>
        public async Task<ExportConsultationDataResult> ExportConsultationsAsync(ExportConsultationsRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var dbRequest = new ExportConsultationRecordsDBRequest();
            dbRequest.IsExportReport = request.IsExportReport;
            dbRequest.IsExportConsultation = request.IsExportConsultation;
            dbRequest.IsExportConsultationFileData = request.IsExportConsultationFileData;
            dbRequest.Language = request.Language;
            dbRequest.UserCode = userCode;
            dbRequest.Keyword = request.Keyword;
            dbRequest.StartDate = request.StartDate;
            dbRequest.EndDate = request.EndDate;
            dbRequest.ConsultationStatus = request.ConsultationStatus;
            dbRequest.ConsultationQueryType = request.ConsultationQueryType;
            dbRequest.EvaluateGrade = request.EvaluateGrade;
            dbRequest.ExpertCodes = request.ExpertCodes;
            dbRequest.ApplyOrganizationCodes = request.ApplyOrganizationCodes;
            dbRequest.ExpertOrganizationCodes = request.ExpertOrganizationCodes;
            dbRequest.PatientSex = request.PatientSex;
            dbRequest.PatientAgeLimit = request.PatientAgeLimit;
            dbRequest.PatientDiseases = request.PatientDiseases;
            dbRequest.PatientPrimaryDiagnosis = request.PatientPrimaryDiagnosis;
            var result = await _consultationRecordDBService.ExportConsultationsDBAsync(dbRequest);
            bool hasConsultation=false, hasReport=false, hasImage=false;
            if(result != null)
            {
                if(request.IsExportConsultation)
                {
                    if(result.ConsultationList!=null && result.ConsultationList.Any())
                    {
                        hasConsultation = true;
                    }
                }
                if(request.IsExportReport)
                {
                    if(result.ReportList!=null && result.ReportList.Any())
                    {
                        hasReport = true;
                    }
                } 
                if(request.IsExportConsultationFileData)
                {
                    if(result.ConsultationFileDatalList!=null && result.ConsultationFileDatalList.Any())
                    {
                        hasImage = true;
                    }
                }
            }
            if(!hasConsultation && !hasReport && !hasImage)
            {
                ThrowRpcException(CustomerRpcCode.NoFoundExportList, "NoFoundExportList");
            }
            return result;
        }

        private async void StartCheckConsultationState(int timeout)
        {
            while (true)
            {
                CheckConsultationIsStart();
                await Task.Delay(timeout);
            }
        }

        /// <summary>
        /// 会诊开始前发通知提醒
        /// </summary>
        private bool CheckConsultationIsStart()
        {
            if (sendNotificationLocker.WaitOne(1000))
            {
                try
                {
                    var timeNow = DateTime.UtcNow;
                    var checkConsultationList = _consultationRecordDBService.FindToStartConsultationRecordListAsync().Result;
                    foreach (var consultationModel in checkConsultationList)
                    {
                        var consultationReminders = consultationModel.ConsultationReminders.Where(w => !w.IsExecuted).ToList();//已发送的就不再执行
                        var consultationTime = consultationModel.ConsultationTime;
                        if (consultationTime <= timeNow)
                        {
                            continue;
                        }
                        if (consultationReminders == null || consultationReminders.Count == 0)
                        {
                            continue;
                        }
                        foreach (var reminder in consultationReminders)
                        {
                            int timeStep = GetTimeStep(consultationTime, reminder.ConsultationReminderTime);
                            int remainder = (int)Math.Ceiling((consultationTime.ToUniversalTime() - timeNow).TotalMinutes);
                            if (remainder == timeStep)
                            {

                                var notification = new ConsultationRemindNotification()
                                {
                                    ConsultationCode = consultationModel.ConsultationCode,
                                    CountdownTime = timeStep,
                                    ConsultationTime = consultationModel.ConsultationTime.ToUniversalTime(),
                                    ConsultationTimeEnd = consultationModel.ConsultationTimeEnd.ToUniversalTime(),
                                    ExpertName = consultationModel.ExpertUserName,
                                    PatientName = consultationModel.PatientName,
                                    IsResponse = true
                                };
                                var members = consultationModel.ConsultationMembers.Select(f => f.MemberCode).ToList();
                                members.Add(consultationModel.ApplyUserCode);
                                members.Add(consultationModel.ExpertUserCode);
                                SendNotifyToMembers(reminder.ConsultationReminderMode, consultationModel.ConsultationCode, members, notification, notification.ConsultationCode).ConfigureAwait(false);
                                //更新发送状态
                                reminder.IsExecuted = true;
                            }
                        }
                        _consultationRecordDBService.UpdateConsultationRemindersAsync(consultationModel.ConsultationCode, consultationReminders).ConfigureAwait(false);
                    }
                    return true;
                }
                catch (Exception ex)
                {
                    Logger.WriteLineWarn("LiveConsultationService-CheckConsultationIsStart:" + ex);
                    return false;
                }
                finally
                {
                    sendNotificationLocker.ReleaseMutex();
                }
            }
            return false;
        }

        /// <summary>
        /// 发送提醒通知
        /// </summary>
        /// <param name="consultationReminderMode"></param>
        /// <param name="msgQueueId"></param>
        /// <param name="clientIds"></param>
        /// <param name="notify"></param>
        /// <returns></returns>
        private async Task SendNotifyToMembers(ConsultationReminderMode consultationReminderMode, string msgQueueId, List<string> clientIds, ConsultationRemindNotification notify, string relevanceCode = "")
        {
            if (consultationReminderMode == ConsultationReminderMode.Application)
            {
                var notificationRequest = new BroadcastNotificationRequest()
                {
                    MsgQueueId = msgQueueId,
                    ClientIds = clientIds,
                    Message = notify,
                    JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(notify),
                    NotificationType = notify.NotificationType,
                    TransactionType = TransactionTypeEnum.Consultion,
                    RelevanceCode = relevanceCode,
                    ReceiverType = ApplicantTypeEnum.Client
                };
                await _notificationService.BroadcastMessageAsync(notificationRequest);
            }
            else if (consultationReminderMode == ConsultationReminderMode.SMS)
            {
                var time = notify.CountdownTime.ToString();
                if (notify.CountdownTime >= 60 * 24)
                {
                    time = "1天";
                }
                else
                {
                    time += "分钟";
                }
                await SendSmsReminderConsultationAsync(clientIds, time, notify.PatientName,
                notify.ConsultationTime, notify.ConsultationTimeEnd);
            }
        }



        /// <summary>
        /// 获取倒计时时间
        /// </summary>
        /// <param name="consultationTime"></param>
        /// <param name="consultationReminderTime"></param>
        /// <returns></returns>
        private int GetTimeStep(DateTime consultationTime, ConsultationReminderTimeEnum consultationReminderTime)
        {
            var timeStep = 0;
            switch (consultationReminderTime)
            {
                case ConsultationReminderTimeEnum.FifteenMinutes:
                    timeStep = 15;
                    break;
                case ConsultationReminderTimeEnum.ThirtyMinutes:
                    timeStep = 30;
                    break;
                case ConsultationReminderTimeEnum.SixtyMinutes:
                    timeStep = 60;
                    break;
                case ConsultationReminderTimeEnum.OneDay:
                    timeStep = 1440;
                    break;
            }
            return timeStep;
        }

        /// <summary>
        /// 获取用户状态，空闲、繁忙、离线
        /// </summary>
        /// <param name="clientId"></param>
        /// <returns></returns>
        private UserStatusEnum GetUserStatus(string clientId)
        {
            var userCodes = new List<string> { clientId };
            var clientInfos = _rtcService.GetLiveMemberStatusInfosAsync(new GetLiveMemberStatusInfosRequest { UserCodes = userCodes }).Result;
            var client = clientInfos?.FirstOrDefault();
            if (client != null)
            {
                return client.UserStatusType;
            }
            return UserStatusEnum.NotOnline;
        }

    }
}