WingLiveConsultationService/LiveConsultationService.cs

using System.Data.Common;
using WingInterfaceLibrary.Interface;
using WingInterfaceLibrary.Request;
using WingInterfaceLibrary.Enum;
using WingInterfaceLibrary.Request.Notification;
using WingInterfaceLibrary.Enum.NotificationEnum;
using WingServerCommon.Service;
using WingInterfaceLibrary.LiveConsultation;
using WingInterfaceLibrary.Interface.DBInterface;
using WingServerCommon.Interfaces.Cache;
using WingInterfaceLibrary.DB.Request;
using WingInterfaceLibrary.Request.DBRequest;
using WingInterfaceLibrary.LiveConsultation.Consultation;
using WingServerCommon.Log;
using WingInterfaceLibrary.DTO.LiveRoom;
using WingServerCommon.Config;
using WingServerCommon.Config.Parameters;
using WingInterfaceLibrary.Rtc;
using WingServerCommon.Utilities;
using WingInterfaceLibrary.Request.Lock;
using WingInterfaceLibrary.DTO.Consultation;
using WingInterfaceLibrary.Internal.Request;
using WingInterfaceLibrary.Internal.Interface;
using WingInterfaceLibrary.Request.Authentication;
using WingInterfaceLibrary.Notifications;
using WingInterfaceLibrary.DTO.User;
using WingInterfaceLibrary.Request.User;
using WingServerCommon.Mapper;
using System.Collections.Concurrent;
using WingInterfaceLibrary.Notifications.Live;
using WingInterfaceLibrary.Request.Remote;
using WingInterfaceLibrary.Request.Device;
using WingInterfaceLibrary.DTO.RemoteParameters;
using WingInterfaceLibrary.Request.DBCopy;
using System;
using WingInterfaceLibrary.Result.QualityControl;
using WingInterfaceLibrary.Request.QualityControl;
using Newtonsoft.Json.Linq;
using JsonRpcLite.Services;

namespace WingLiveConsultationService
{
    public partial class LiveConsultationService : JsonRpcService, ILiveConsultationService
    {
        private ConcurrentDictionary<string, IList<AdditionParameterDTO>> _controllingParameterLiveConsultations = new ConcurrentDictionary<string, IList<AdditionParameterDTO>>();
        private readonly string _serverHost;
        private int _connectionTimeout => EnvironmentConfigManager.GetParammeter<IntParameter>("LiveConsultation", "ConnectionTimeout").Value;
        private IAuthenticationService _authenticationService;
        private INotificationService _notificationService;
        private IUserDBService _userDBService;
        private IOrganizationDBService _organizationDBService;
        private IConsultationRecordDBService _consultationRecordDBService;
        private IRemedicalDBService _remedicalDBService;
        private IRemedicalMeasuredInfoDBService _remedicalMeasuredInfoDBService;
        private IPatientInfoDBService _patientInfoDBService;
        private ILiveRoomDBService _liveRoomDBService;
        private IDeviceInfoDBService _deviceDBService;
        private IDeviceService _deviceService;
        private IPatientService _patientService;
        private IWingRtcService _wingRtcService;
        private IRtcService _rtcService;
        private IMasterInteractionCenterService _masterInteractionCenterService;
        private LiveConsultationHeartRateManager _liveConsultationHeartRateManager;

        private IRoleService _roleService;
        private string _serverID;
        private LockManager _lockManager;
        private ILockService _lockService;
        private IReportDBService _reportDBService;
        private IDeviceForwardService _deviceForwardService;
        private static object _objLocker = new object();
        private string _reminderSmsTemplateId => EnvironmentConfigManager.GetParammeter<StringParameter>("LiveConsultation", "ReminderSmsTemplateId").Value; //短信提醒模板Id
        private string _inviteSmsTemplateId => EnvironmentConfigManager.GetParammeter<StringParameter>("LiveConsultation", "InviteSmsTemplateId").Value; //短信邀请会诊模板Id
        private string _submitSmsTemplateId => EnvironmentConfigManager.GetParammeter<StringParameter>("LiveConsultation", "SubmitSmsTemplateId").Value; //短信提交会诊模板Id
        private int _emergencyTimeout => EnvironmentConfigManager.GetParammeter<IntParameter>("LiveConsultation", "EmergencyTimeout").Value;
        private ISMSService _smsService;
        private int _downloadOriginalLowestValue = 1048576;
        private System.Timers.Timer _timer;
        //任务周期
        private int _dutyCycle = 60 * 60 * 1000;//1 hours
        public LiveConsultationService()
        {
            _serverHost = ConfigurationManager.Host;
            _serverID = ConfigurationManager.GetParammeter<StringParameter>("General", "ServerID").Value;
            _liveConsultationHeartRateManager = new LiveConsultationHeartRateManager(HandleClientJoined, HandleClientNetworkErr, HandleClientLeave);
            _timer = new System.Timers.Timer();
            _timer.Elapsed += new System.Timers.ElapsedEventHandler(Verify_Elapsed);
            _timer.Interval = _dutyCycle;
            _timer.Enabled = true;
        }

        /// <summary>
        /// Init service
        /// </summary>
        public override void Load(JsonRpcClientPool jsonRpcClientPool)
        {
            base.Load(jsonRpcClientPool);
            _authenticationService = GetProxy<IAuthenticationService>();
            _notificationService = GetProxy<INotificationService>();
            _userDBService = GetProxy<IUserDBService>();
            _organizationDBService = GetProxy<IOrganizationDBService>();
            _consultationRecordDBService = GetProxy<IConsultationRecordDBService>();
            _remedicalDBService = GetProxy<IRemedicalDBService>();
            _remedicalMeasuredInfoDBService = GetProxy<IRemedicalMeasuredInfoDBService>();
            _patientInfoDBService = GetProxy<IPatientInfoDBService>();
            _liveRoomDBService = GetProxy<ILiveRoomDBService>();
            _deviceDBService = GetProxy<IDeviceInfoDBService>();
            _patientService = GetProxy<IPatientService>();
            _wingRtcService = GetProxy<IWingRtcService>();
            _rtcService = GetProxy<IRtcService>();
            _smsService = GetProxy<ISMSService>();
            _masterInteractionCenterService = GetProxy<IMasterInteractionCenterService>();
            _roleService = GetProxy<IRoleService>();
            _reportDBService = GetProxy<IReportDBService>();
            _deviceService = GetProxy<IDeviceService>();
            LiveConsultationRoom.OnOpenNotifyQueue = OpenNotifyQueue;
            LiveConsultationRoom.OnBroadcastMessage = BroadcastMessage;
            LiveConsultationRoom.OnRtcGenerateRoomUrl = RtcGenerateRoomUrl;
            LiveConsultationRoom.OnGetUserSign = GetUserSign;
            _lockService = GetProxy<ILockService>();
            var inProcessServiceSettings = ConfigurationManager.GetParammeter<StringParameter>("Services", "InProcess").Value;
            var remoteServiceSettings = ConfigurationManager.GetParammeter<StringParameter>("Services", "Remote").Value;
            if (!inProcessServiceSettings.Contains("LockService") && !remoteServiceSettings.Contains("LockService"))
            {
                _lockManager = new LockManager();
            }
            else
            {
                _lockManager = new LockManager(ApplyLock, ReleaseLock);
            }
            _timer.Start();
        }

        /// <summary>
        /// 自定义定时任务
        /// </summary>
        /// <param name="clientIdList">用户code列表</param>
        /// <param name="sendNoticeFunc">发送通知委托</param>
        /// <returns>是否成功</returns>
        private async void Verify_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            try
            {
                if (!ConfigurationManager.IsDistributed || ConfigurationManager.IsMaster)
                {
                    var toStartConsultationRecords = await _consultationRecordDBService.FindToStartConsultationRecordListAsync();
                    var needUpdateRecordCodes = new List<string>();
                    foreach (var record in toStartConsultationRecords)
                    {
                        if (record.ConsultationTimeEnd.Date < DateTime.UtcNow.Date.AddMonths(-1))
                        {
                            await _consultationRecordDBService.UpdateConsultationStatusAsync(record.ConsultationCode, TransactionStatusEnum.Expired);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Dispatch VerifyPasswordExpire Error:{ex}");
            }
        }

        public override async void LoadAfterRegister()
        {
            try
            {
                _deviceForwardService = GetProxy<IDeviceForwardService>();
                if (!ConfigurationManager.IsDistributed || ConfigurationManager.IsMaster)
                {
                    var inProcessRecords = await _consultationRecordDBService.GetConsultationRecordsByStatusAsync(new GetConsultationRecordsByStatusDBRequest
                    {
                        Status = TransactionStatusEnum.InProgress
                    });
                    if (inProcessRecords?.Any() == true)
                    {
                        foreach (var record in inProcessRecords)
                        {
                            //修改预约记录状态
                            await _consultationRecordDBService.UpdateConsultationStatusAsync(record.ConsultationCode, TransactionStatusEnum.ToStart);
                        }
                    }
                    StartCheckConsultationState(30000);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"LiveConsultationService LoadAfterRegister err, {ex}");
            }
        }

        private string OpenNotifyQueue(string roomId)
        {
            var openNotifyQueueRequest = new OpenNotifyQueueRequest { Module = roomId };
            var msgQueueId = _notificationService.OpenNotifyQueueAsync(openNotifyQueueRequest).Result;
            return msgQueueId;
        }

        private bool BroadcastMessage(BroadcastNotificationRequest notificationRequest)
        {
            return _notificationService.BroadcastMessageAsync(notificationRequest).Result;
        }

        private GenerateRoomUrlResult RtcGenerateRoomUrl(int integerRoomId, string uniqueId)
        {
            var agenerateRoomUrlRequest = new GenerateRoomUrlRequest
            {
                RoomId = (uint)integerRoomId,
                UniqueId = uniqueId,
            };
            var agenerateRoomUrlResult = _wingRtcService.GenerateRoomUrlAsync(agenerateRoomUrlRequest).Result;
            return agenerateRoomUrlResult;
        }

        private bool ApplyLock(string lockKey)
        {
            try
            {
                var result = _lockService.ApplyLockAsync(new ApplyLockRequest
                {
                    LockKey = lockKey
                }).Result;
                return result.IsSuccess;
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"LiveConsultationService ApplyLock err, lock key:{lockKey}, ex:{ex}");
                return false;
            }
        }

        private bool ReleaseLock(string lockUniqueCode)
        {
            try
            {
                var result = _lockService.ReleaseLockAsync(new ReleaseLockRequest
                {
                    LockUniqueCode = lockUniqueCode
                }).Result;
                return result.IsSuccess;
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"LiveConsultationService ReleaseLock err, release key:{lockUniqueCode}, ex:{ex}");
                return false;
            }
        }

        private string GetUserSign(string userCode)
        {
            var request = new GetUserSignRequest { UserId = userCode };
            var result = _wingRtcService.GetUserSignAsync(request).Result;
            return result.UserSign;
        }

        /// <summary>
        /// Dispatch message function
        /// </summary>
        public static Action<IList<RemoteNotifyTarget>, NotificationTypeEnum> DispatchMessage;

        /// <summary>
        /// Push message function
        /// </summary>
        public static Action<IList<string>, NotificationTypeEnum> PushMessage;

        /// <summary>
        /// Initiate a diagnosis meeting
        /// </summary>
        /// <param name="request">The request</param>
        /// <returns></returns>
        public async Task<InitiateLiveConsultationResult> InitiateLiveConsultationAsync(InitiateLiveConsultationRequest request)
        {
            var tokenInfo = await _authenticationService.GetTokenAsync(request);
            var initiatorCode = tokenInfo.ClientId;
            var initiator = await _userDBService.FindUserByCodeAsync(initiatorCode);
            var roomId = request.ConsultationCode;

            var consultationRecord = CacheMaintenance.Instance.Get<IConsultationRecordManager>().Get(roomId);
            if (consultationRecord == null)
            {
                Logger.WriteLineWarn($"LiveConsultationService initiate live consultation failed, consultation not existed, roomId:{roomId}");
                ThrowRpcException(CustomerRpcCode.ConsultationNotExisted, "Consultation not existed");
            }
            if (!consultationRecord.IsEmergency && string.IsNullOrWhiteSpace(consultationRecord.ExpertUserCode))
            {
                Logger.WriteLineWarn($"LiveConsultationService initiate live consultation failed, expert is empty, roomId:{roomId}");
                ThrowRpcException(CustomerRpcCode.ConsultationExpertIsEmpty, "Consultation Expert IsEmpty");
            }
            if (consultationRecord.ConsultationStatus == (int)TransactionStatusEnum.Applied
                || consultationRecord.ConsultationStatus == (int)TransactionStatusEnum.Withdrawn
                || consultationRecord.ConsultationStatus == (int)TransactionStatusEnum.Rejected)
            {
                Logger.WriteLineWarn($"LiveConsultationService reservation record not reviewed, current status:{consultationRecord.ConsultationStatus}, roomId:{roomId}");
                ThrowRpcException(CustomerRpcCode.ReservationNotReviewed, "Reservation record not reviewed");
            }
            if (consultationRecord.ConsultationStatus == (int)TransactionStatusEnum.InProgress)
            {
                Logger.WriteLineWarn($"LiveConsultationService consultation in process, current status:{consultationRecord.ConsultationStatus}, roomId:{roomId}");
                ThrowRpcException(CustomerRpcCode.ConsultationInProcess, "Consultation In Process");
            }
            var emergencyDoctors = new List<UserDTO>();
            if (consultationRecord.IsEmergency && string.IsNullOrWhiteSpace(consultationRecord.ExpertUserCode))
            {
                emergencyDoctors = await GetEmergencyDoctorsAsync(initiator.RootOrganizationCode);
                if (!emergencyDoctors.Any())
                {
                    Logger.WriteLineWarn($"LiveConsultationService emergency doctors is empty, current status:{consultationRecord.ConsultationStatus}, roomId:{roomId}");
                    ThrowRpcException(CustomerRpcCode.EmergencyDoctorsIsEmpty, "Emergency Doctors Is Empty");
                }
            }
            using (await _lockManager.Acquire(roomId))
            {
                var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
                var freshRoom = false;
                if (room == null)
                {
                    freshRoom = true;
                }
                else if (!string.IsNullOrWhiteSpace(consultationRecord.ExpertUserCode) && !consultationRecord.IsEmergency)
                {
                    var expertDTO = await _userDBService.FindUserByCodeAsync(consultationRecord.ExpertUserCode);
                    var assistantDoctorUserCode = expertDTO?.BindAssistantDoctorUserCode;
                    if (!string.IsNullOrWhiteSpace(assistantDoctorUserCode) && (room.UserInfos == null || !room.UserInfos.Any(x => x.Code == assistantDoctorUserCode)))
                    {
                        freshRoom = true;
                    }
                }
                if (freshRoom)
                {
                    room = await CreateLiveRoomAsync(roomId);
                    room = await _rtcService.AddOrUpdateLiveRoomAsync(new AddOrUpdateLiveRoomRequest
                    {
                        LiveRoom = room
                    });
                    Logger.WriteLineInfo($"LiveConsultationService InitiateLiveConsultationAsync CreateLiveRoom, data:{Newtonsoft.Json.JsonConvert.SerializeObject(room)}");
                }
                if (room == null)
                {
                    Logger.WriteLineWarn($"LiveConsultationService save to db failed, roomId:{roomId}");
                    ThrowRpcException(CustomerRpcCode.ConsultationDBError, "Consultation DB error");
                }
                var members = await _rtcService.GetLiveMemberInfosAsync(new GetLiveMemberInfosRequest { LiveRoomCode = roomId });
                // //状态验证
                var applyer = members.FirstOrDefault(x => x.Id == consultationRecord.ApplyUserCode);
                if (applyer == null || !applyer.IsOnline)
                {
                    Logger.WriteLineWarn($"LiveConsultationService initiate live consultation failed, applyer not online, roomId:{roomId}");
                    ThrowRpcException(CustomerRpcCode.ApplyerNotOnline, "Consultation applyer not online");
                }
                else if (applyer.IsBusy)
                {
                    Logger.WriteLineWarn($"LiveConsultationService initiate live consultation failed, applyer is busy, roomId:{roomId}");
                    ThrowRpcException(CustomerRpcCode.ApplyerIsBusy, "Applyer Is Busy");
                }
                if (!string.IsNullOrWhiteSpace(consultationRecord.ExpertUserCode) && consultationRecord.IsEmergency)
                {
                    var expert = members.FirstOrDefault(x => x.Id == consultationRecord.ExpertUserCode);
                    if (expert == null || !expert.IsOnline)
                    {
                        Logger.WriteLineWarn($"LiveConsultationService initiate live consultation failed, expert not online, roomId:{roomId}");
                        ThrowRpcException(CustomerRpcCode.ExpertNotOnline, "Consultation expert not online");
                    }
                    else if (expert.IsBusy)
                    {
                        Logger.WriteLineWarn($"LiveConsultationService initiate live consultation failed, expert is busy, roomId:{roomId}");
                        ThrowRpcException(CustomerRpcCode.ExpertIsBusy, "Expert Is Busy");
                    }
                }
                //设备是否被占用
                var deviceLiveRoom = await _rtcService.GetInitiatingRoomByDeviceCodeAsync(new GetInitiatingRoomByDeviceCodeRequest()
                {
                    DeviceCode = consultationRecord.DeviceCode,
                });
                if (deviceLiveRoom != null && deviceLiveRoom.BusinessModule == BusinessModuleEnum.LivingConsultation)
                {
                    ThrowRpcException(CustomerRpcCode.DeviceInOtherConsultation, "Device In Other Consultation");
                }
                if (request.CheckOnly)
                {
                    return new InitiateLiveConsultationResult { ConsultationCode = roomId };
                }

                //修改预约记录状态
                await _consultationRecordDBService.UpdateConsultationStatusAsync(roomId, TransactionStatusEnum.InProgress);
                room = await _rtcService.InitiateAsync(new InitiateRequest
                {
                    LiveRoomCode = roomId,
                    InitiatorCode = initiatorCode,
                    LoginSource = tokenInfo.LoginSource,
                });

                members = await _rtcService.GetLiveMemberInfosAsync(new GetLiveMemberInfosRequest { LiveRoomCode = roomId });
                if (consultationRecord.IsEmergency)
                {

                    if (string.IsNullOrWhiteSpace(consultationRecord.ExpertUserCode))
                    {
                        //呼叫急诊医生
                        CallEmergencyDoctors(roomId, emergencyDoctors, room.RtcRoomId, members.FirstOrDefault(x => x.Id == initiatorCode));
                    }
                    else
                    {
                        StartCheckEmergencyDoctorTimeout(roomId, initiatorCode, consultationRecord.ExpertUserCode);
                    }
                }

                var userSignRequest = new GetUserSignRequest
                {
                    UserId = initiatorCode
                };
                var userSignResult = await _wingRtcService.GetUserSignAsync(userSignRequest);
                var result = new InitiateLiveConsultationResult
                {
                    ConsultationCode = roomId,
                    RoomNo = room.RtcRoomId,
                    LiveProtocol = EnvironmentConfigs.General.LiveProtocolDetail<TransactionStatusEnum>(),
                    InitiatorCode = initiatorCode,
                    AppId = room.SdkAppId,
                    UserSign = userSignResult.UserSign,
                    MemberLiveDatas = members,
                };
                Logger.WriteLineInfo($"LiveConsultationService InitiateLiveConsultationAsync roomId:{roomId}, rtcRoomId:{room.RtcRoomId}, members:{string.Join(";", members.Select(m => $"{m.Name},sortLevel:{m.SortLevel},sortNumber:{m.SortNumber}"))}");

                return result;
            }
        }
        private async Task<LiveRoomDTO> CreateLiveRoomAsync(string roomId)
        {
            var consultationRequest = new ConsultationRecordCodeDBRequest { Code = roomId };
            var consultationRecord = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(consultationRequest);
            if (consultationRecord != null && !string.IsNullOrWhiteSpace(consultationRecord.ConsultationCode))
            {
                //申请人、专家、设备、其它参与人
                var userCodes = new List<string>();
                var expertUserCode = consultationRecord.ExpertUserCode;
                if (!string.IsNullOrWhiteSpace(expertUserCode))
                {
                    userCodes.Add(expertUserCode);
                }
                var applyUserCode = consultationRecord.ApplyUserCode;
                if (!string.IsNullOrWhiteSpace(applyUserCode))
                {
                    userCodes.Add(applyUserCode);
                }
                if (consultationRecord.ConsultationMembers != null && consultationRecord.ConsultationMembers.Any(x => x.MemberStatus == LiveConsultationMemberStatus.Accepted))
                {
                    var codes = consultationRecord.ConsultationMembers.Where(x => x.MemberStatus == LiveConsultationMemberStatus.Accepted).Select(c => c.MemberCode).Distinct().ToList();
                    userCodes.AddRange(codes);
                }
                //发起人
                var initiatorCode = consultationRecord.InitiatorCode;
                if (!string.IsNullOrWhiteSpace(initiatorCode) && !userCodes.Contains(initiatorCode))
                {
                    userCodes.Add(initiatorCode);
                }
                var expertUser = await _userDBService.FindUserByCodeAsync(consultationRecord.ExpertUserCode);
                //专家 助理医师
                var assistantDoctorCode = expertUser?.BindAssistantDoctorUserCode ?? string.Empty;
                if (consultationRecord.IsEmergency)
                {
                    userCodes.Remove(assistantDoctorCode);
                }
                else if (!string.IsNullOrWhiteSpace(assistantDoctorCode) && !userCodes.Contains(assistantDoctorCode))
                {
                    userCodes.Add(assistantDoctorCode);
                }
                var users = await _userDBService.FindUserListByUserCodesAsync(userCodes);
                var deviceCode = consultationRecord.DeviceCode;
                var deviceInfo = CacheMaintenance.Instance.Get<IDeviceInfosManager>().Get(deviceCode);
                if (deviceInfo == null)
                {
                    ThrowRpcException(CustomerRpcCode.DeviceNotExist, "Not find device");
                }
                //生成会诊用户/设备信息
                var tokenManager = CacheMaintenance.Instance.Get<ITokensManager>();
                var liveMembers = new List<LiveMemberDTO>();
                foreach (var user in users)
                {
                    var userCode = user.UserCode;
                    var isInitiator = userCode == initiatorCode;
                    var userName = user.DisplayName;
                    var consultationRole = LiveConsultationRoleEnum.OtherParticipant;
                    if (userCode == consultationRecord.ExpertUserCode)
                    {
                        consultationRole = LiveConsultationRoleEnum.Expert;
                    }
                    else if (userCode == consultationRecord.ApplyUserCode)
                    {
                        consultationRole = LiveConsultationRoleEnum.General;
                    }
                    else if (userCode == assistantDoctorCode)
                    {
                        consultationRole = LiveConsultationRoleEnum.AssistantDoctor;
                    }
                    var liveMember = new LiveMemberDTO
                    {
                        Code = userCode,
                        Name = userName,
                        MemberType = LiveMemberEnum.User,
                        HeadImageToken = user.HeadImageUrl,
                        Status = LiveMemberStatus.Default,
                        MuteOpened = false,
                        VideoOpened = true,
                        SortLevel = (int)consultationRole,
                    };
                    liveMembers.Add(liveMember);
                }
                var deviceName = deviceInfo.DisplayName;
                var deviceLiveInfo = new LiveMemberDTO
                {
                    Code = deviceCode,
                    Name = deviceName,
                    MemberType = LiveMemberEnum.Device,
                    HeadImageToken = deviceInfo.HeadPicUrl,
                    Status = LiveMemberStatus.Accepted,
                };
                liveMembers.Add(deviceLiveInfo);
                var room = new LiveRoomDTO
                {
                    LiveRoomCode = roomId,
                    Name = consultationRecord.PatientName,
                    RelatedCode = roomId,
                    BusinessModule = BusinessModuleEnum.LivingConsultation,
                    Status = LiveRoomStatus.Default,
                    UserInfos = liveMembers.Where(x => x.MemberType == LiveMemberEnum.User)?.ToList() ?? new List<LiveMemberDTO>(),
                    DeviceInfos = liveMembers.Where(x => x.MemberType == LiveMemberEnum.Device)?.ToList() ?? new List<LiveMemberDTO>(),
                };
                return room;
            }
            return null;
        }

        /// <summary>
        /// Cancel the initiating a diagnosis meeting
        /// </summary>
        /// <param name="request">The request</param>
        /// <returns></returns>
        /// <show>false</show>
        public async Task<CancelLiveConsultationResult> CancelLiveConsultationAsync(CancelLiveConsultationRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            //获取房间缓存
            var roomId = request.ConsultationCode;
            using (await _lockManager.Acquire(roomId))
            {
                var consultationRecord = CacheMaintenance.Instance.Get<IConsultationRecordManager>().Get(roomId);
                var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
                if (room == null || consultationRecord == null)
                {
                    ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
                }
                if (room.Status == LiveRoomStatus.Cancelled)
                {
                    ThrowRpcException(CustomerRpcCode.LiveConsultationCancelled, "LiveConsultationCancelled");
                }
                if (userCode != room.InitiatorCode)
                {
                    ThrowRpcException(CustomerRpcCode.NotConsultationInitiator, "NotConsultationInitiator");
                }
                //修改预约记录状态
                await _consultationRecordDBService.UpdateConsultationStatusAsync(roomId, TransactionStatusEnum.ToStart);
                if (consultationRecord.IsEmergency && string.IsNullOrWhiteSpace(consultationRecord.ExpertUserCode))
                {
                    await UpdateEmergencyStateAsync(roomId, EmergencyConsultationStatus.Cancelled);
                }
                await _rtcService.CancelAsync(new CancelRequest
                {
                    LiveRoomCode = roomId,
                    UserCode = userCode,
                });
                return new CancelLiveConsultationResult() { ConsultationCode = roomId };
            }
        }

        /// <summary>
        /// Accept a diagnosis request
        /// </summary>
        /// <param name="request">The request</param>
        /// <returns></returns>
        public async Task<AcceptLiveConsultationResult> AcceptLiveConsultationAsync(AcceptLiveConsultationRequest request)
        {
            var tokenInfo = await _authenticationService.GetTokenAsync(request);
            var userCode = tokenInfo.ClientId;
            var user = await _userDBService.FindUserByCodeAsync(userCode);
            //获取房间缓存
            var roomId = request.ConsultationCode;
            using (await _lockManager.Acquire(roomId))
            {
                var consultationRecord = CacheMaintenance.Instance.Get<IConsultationRecordManager>().Get(roomId);
                var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
                if (room == null || consultationRecord == null)
                {
                    ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
                }
                else
                {
                    if (room.Status == LiveRoomStatus.Cancelled)
                    {
                        ThrowRpcException(CustomerRpcCode.LiveConsultationCancelled, "LiveConsultationCancelled");
                    }
                    else if (room.Status == LiveRoomStatus.ConnectionTimeout)
                    {
                        ThrowRpcException(CustomerRpcCode.LiveConsultationTimeout, "LiveConsultationTimeout");
                    }
                    var accepter = room.UserInfos.FirstOrDefault(x => x.Code == userCode);
                    if (accepter == null && !consultationRecord.IsEmergency)
                    {
                        Logger.WriteLineWarn($"LiveConsultationService AcceptLiveConsultationAsync, roomData:{Newtonsoft.Json.JsonConvert.SerializeObject(room)}");
                        ThrowRpcException(CustomerRpcCode.LivMemberNotFound, "LiveMemberNotFound");
                    }
                    if (accepter != null)
                    {
                        var joinedByOtherDevice = await IsJoinedByOtherDevice(roomId, userCode, tokenInfo.LoginSource);
                        if (joinedByOtherDevice)
                        {
                            ThrowRpcException(CustomerRpcCode.JoinedByOtherDevice, "JoinedByOtherDevice");
                        }
                    }
                }
                if (request.CheckOnly)
                {
                    return new AcceptLiveConsultationResult { ConsultationCode = roomId };
                }
                if (consultationRecord.IsEmergency && string.IsNullOrWhiteSpace(consultationRecord.ExpertUserCode))
                {
                    await UpdateEmergencyStateAsync(roomId, EmergencyConsultationStatus.Accepted);
                    //维护专家信息
                    await _consultationRecordDBService.UpdateExpertCodeAsync(roomId, userCode);
                    //添加日程
                    var addScheduleUsersRequest = new AddScheduleUsersDBRequest
                    {
                        RelevanceCode = roomId,
                        UserCodes = new List<string> { userCode },
                    };
                    await _userDBService.AddScheduleUsersDBAsync(addScheduleUsersRequest);
                }
                await _rtcService.AcceptAsync(new AcceptRequest
                {
                    LiveRoomCode = roomId,
                    UserCode = userCode,
                    LoginSource = tokenInfo.LoginSource,
                });
                var members = await _rtcService.GetLiveMemberInfosAsync(new GetLiveMemberInfosRequest { LiveRoomCode = roomId });
                var boardDatas = await _rtcService.GetLiveBoardDatasAsync(new GetLiveBoardDatasRequest { LiveRoomCode = roomId });

                var userSignRequest = new GetUserSignRequest
                {
                    UserId = userCode
                };
                var userSignResult = await _wingRtcService.GetUserSignAsync(userSignRequest);

                var result = new AcceptLiveConsultationResult()
                {
                    ConsultationCode = roomId,
                    UserCode = userCode,
                    UserSign = userSignResult.UserSign,
                    AppId = room.SdkAppId,
                    RoomNo = room.RtcRoomId,
                    LiveProtocol = EnvironmentConfigs.General.LiveProtocolDetail<TransactionStatusEnum>(),
                    MemberLiveDatas = members,
                    InteractiveBoardDatas = boardDatas.Select(x => new InteractiveBoardDataDTO
                    {
                        UserCode = x.UserCode,
                        BoardData = x.BoardData,
                        InteractiveTime = x.InteractiveTime
                    }).ToList(),
                };
                Logger.WriteLineInfo($"LiveConsultationService AcceptLiveConsultationAsync roomId:{roomId}, rtcRoomId:{room.RtcRoomId}, members:{string.Join(";", members.Select(m => $"{m.Name},sortLevel:{m.SortLevel},sortNumber:{m.SortNumber}"))}");
                return result;
            }
        }

        /// <summary>
        /// Reject a diagnosis request
        /// </summary>
        /// <param name="request">The request</param>
        /// <returns></returns>
        public async Task<RejectLiveConsultationResult> RejectLiveConsultationAsync(RejectLiveConsultationRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            //获取房间缓存
            var roomId = request.ConsultationCode;
            using (await _lockManager.Acquire(roomId))
            {
                var consultationRecord = CacheMaintenance.Instance.Get<IConsultationRecordManager>().Get(roomId);
                var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
                if (room == null || consultationRecord == null)
                {
                    ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
                }
                var isEmergency = consultationRecord.IsEmergency;
                var rejecter = room.UserInfos.FirstOrDefault(x => x.Code == userCode);
                if (!isEmergency)
                {
                    if (rejecter == null)
                    {
                        //拒绝会诊中邀请
                        await _rtcService.RejectInviteAsync(new RejectInviteRequest
                        {
                            LiveRoomCode = roomId,
                            UserCode = userCode,
                        });
                    }
                    else
                    {
                        await _rtcService.RejectAsync(new RejectRequest
                        {
                            LiveRoomCode = roomId,
                            UserCode = userCode,
                        });
                        if (consultationRecord.ApplyUserCode == userCode)
                        {
                            //基层拒绝会诊，自动结束会诊
                            await _rtcService.CloseAsync(new CloseRequest
                            {
                                LiveRoomCode = roomId,
                                UserCode = userCode,
                            });
                            await _consultationRecordDBService.UpdateConsultationStatusAsync(roomId, TransactionStatusEnum.ToStart);
                        }
                    }
                }
                else
                {
                    if (string.IsNullOrWhiteSpace(consultationRecord.ExpertUserCode))
                    {
                        await UpdateEmergencyStateAsync(roomId, EmergencyConsultationStatus.Rejected);
                    }
                    else if (rejecter == null)
                    {
                        //拒绝会诊中邀请
                        await _rtcService.RejectInviteAsync(new RejectInviteRequest
                        {
                            LiveRoomCode = roomId,
                            UserCode = userCode,
                        });
                    }
                    else
                    {
                        await _rtcService.RejectAsync(new RejectRequest
                        {
                            LiveRoomCode = roomId,
                            UserCode = userCode,
                        });
                        if (consultationRecord.ExpertUserCode == userCode)
                        {
                            //专家拒绝会诊，自动结束会诊
                            await _rtcService.CloseAsync(new CloseRequest
                            {
                                LiveRoomCode = roomId,
                                UserCode = userCode,
                            });
                            await _consultationRecordDBService.UpdateConsultationStatusAsync(roomId, TransactionStatusEnum.ToStart);
                        }
                    }
                }

                var result = new RejectLiveConsultationResult() { ConsultationCode = roomId };
                return result;
            }
        }
        /// <summary>
        /// Join a diagnosis request
        /// </summary>
        /// <param name="request">The request</param>
        /// <returns></returns>
        public async Task<JoinLiveConsultationResult> JoinLiveConsultationAsync(JoinLiveConsultationRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            //获取房间缓存
            var roomId = request.ConsultationCode;
            LiveConsultationRoom room = null;
            if (room == null)
            {
                ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
            }

            //room.Accept(accepterToken.Code);
            //Notify other guys                
            BroadcastNotificationRequest notificationRequest = new BroadcastNotificationRequest();
            var others = room.Members.Where(x => x.Id != userCode);
            var otherIds = others.Select(x => x.Id).ToList();
            notificationRequest.ClientIds = otherIds; //TODO set message content                

            var accepter = room.Members.FirstOrDefault(x => x.Id == userCode);
            if (accepter == null)
            {
                //TODO thow exception                    
            }

            var joiner = new LiveConsultationJoinerInfo()
            {
                Id = accepter.Id,
                Name = accepter.Name,
                IsOnline = accepter.IsOnline,
                Mute = accepter.Mute,
                LoginSource = accepter.LoginSource,
                LiveData = accepter.LiveData
            };
            var notification = new JoinLiveConsultationNotification()
            {
                ConsultationCode = roomId,
                Joiner = joiner,
            };
            notificationRequest.Message = notification;
            notificationRequest.JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(notification);
            notificationRequest.NotificationType = notification.NotificationType;
            notificationRequest.TransactionType = TransactionTypeEnum.Consultion;
            notificationRequest.RelevanceCode = roomId;
            notificationRequest.ReceiverType = ApplicantTypeEnum.Client;
            await _notificationService.BroadcastMessageAsync(notificationRequest);

            var result = new JoinLiveConsultationResult() { ConsultationCode = roomId };
            return result;
        }

        /// <summary>
        /// Leave a diagnosis request
        /// </summary>
        /// <param name="request">The request</param>
        /// <returns></returns>
        public async Task<LeaveLiveConsultationResult> LeaveLiveConsultationAsync(LeaveLiveConsultationRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            //获取房间缓存
            var roomId = request.ConsultationCode;
            using (await _lockManager.Acquire(roomId))
            {
                var consultationRecord = CacheMaintenance.Instance.Get<IConsultationRecordManager>().Get(roomId);
                if (consultationRecord == null)
                {
                    ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
                }
                var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
                if (room == null)
                {
                    ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
                }
                else if (room.UserInfos.Any(x => x.Code == userCode))
                {
                    var members = await _rtcService.GetLiveMemberInfosAsync(new GetLiveMemberInfosRequest { LiveRoomCode = roomId });
                    var closed = userCode == consultationRecord.ExpertUserCode || userCode == consultationRecord.ApplyUserCode;
                    if (!closed)
                    {
                        var joinMembers = members.Where(x => x.MemberType == LiveMemberEnum.User && x.Status == LiveConsultationMemberStatus.Joined && x.Id != userCode)?.ToList() ?? new List<LiveConsultationMember>();
                        if (!joinMembers.Any())
                        {
                            closed = true;
                        }
                    }
                    var result = await _rtcService.LeaveAsync(new LeaveRequest
                    {
                        LiveRoomCode = roomId,
                        UserCode = userCode,
                        Closed = closed,
                    });
                    if (closed)
                    {
                        //修改预约记录状态
                        var reportRequest = new GetReportByRecordCodeDBRequest { RecordCode = roomId };
                        var report = await _reportDBService.GetReportByRecordCodeAsync(reportRequest);
                        if (report != null && report.Count > 0)
                        {
                            await _consultationRecordDBService.UpdateConsultationStatusAsync(roomId, TransactionStatusEnum.End);
                        }
                        else
                        {
                            var consultationStatus = TransactionStatusEnum.ToStart;
                            if (LiveMemberHasJoined(members, consultationRecord.ExpertUserCode) && LiveMemberHasJoined(members, consultationRecord.ApplyUserCode))
                            {
                                consultationStatus = TransactionStatusEnum.PendingReport;
                            }
                            await _consultationRecordDBService.UpdateConsultationStatusAsync(roomId, consultationStatus);
                        }
                    }
                }
                return new LeaveLiveConsultationResult() { ConsultationCode = roomId };
            }
        }

        /// <summary>
        /// 设置开启或关闭静音状态
        /// </summary>
        /// <param name="request">设置开启或关闭静音状态的请求</param>
        /// <returns></returns>
        public async Task<MuteLiveConsultationResult> MuteLiveConsultationAsync(MuteLiveConsultationRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            //获取房间缓存
            var roomId = request.ConsultationCode;
            var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
            if (room == null)
            {
                ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
            }
            else if (room.Status != LiveRoomStatus.Connected && room.Status != LiveRoomStatus.Initiating)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationNotInProcess, "Consultation Not InProcess");
            }
            else
            {
                await _rtcService.ChangeMuteOpenedAsync(new ChangeMuteOpenedRequest
                {
                    LiveRoomCode = roomId,
                    UserCode = userCode,
                    MuteOpened = request.Mute
                });
            }
            var result = new MuteLiveConsultationResult() { ConsultationCode = roomId };
            return result;
        }

        /// <summary>
        /// 开启或关闭视频
        /// </summary>
        /// <param name="request">开启或关闭视频请求</param>
        /// <returns></returns>       
        public async Task<SwitchLiveConsultationVideoResult> SwitchLiveConsultationVideoAsync(SwitchLiveConsultationVideoRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            //获取房间缓存
            var roomId = request.ConsultationCode;
            var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
            if (room == null)
            {
                ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
            }
            else if (room.Status != LiveRoomStatus.Connected && room.Status != LiveRoomStatus.Initiating)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationNotInProcess, "Consultation Not InProcess");
            }
            else
            {
                await _rtcService.ChangeVideoOpenedAsync(new ChangeVideoOpenedRequest
                {
                    LiveRoomCode = roomId,
                    UserCode = userCode,
                    VideoOpened = request.Opened
                });
            }
            var result = new SwitchLiveConsultationVideoResult() { ConsultationCode = roomId };
            return result;
        }

        /// <summary>
        /// Send HeartRate request in a diagnosis metting
        /// </summary>
        /// <param name="request">The request</param>
        /// <returns></returns>
        public async Task<LiveConsultationHeartRateResult> HeartRateAsync(LiveConsultationHeartRateRequest request)
        {
            var userToken = await _authenticationService.GetTokenAsync(request);
            var consultationRecord = CacheMaintenance.Instance.Get<IConsultationRecordManager>().Get(request.ConsultationCode);
            if (consultationRecord == null)
            {
                ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
            }
            else if (consultationRecord.ConsultationStatus == (int)TransactionStatusEnum.Applied
                || consultationRecord.ConsultationStatus == (int)TransactionStatusEnum.Withdrawn
                || consultationRecord.ConsultationStatus == (int)TransactionStatusEnum.Rejected)
            {
                ThrowRpcException(CustomerRpcCode.ReservationNotReviewed, $"Reservation record not reviewed, current status:{consultationRecord.ConsultationStatus.ToString()}");
            }
            else if (consultationRecord.ConsultationStatus != (int)TransactionStatusEnum.InProgress)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationEnded, $"ConsultationEnded, current status:{consultationRecord.ConsultationStatus.ToString()}");
            }
            _liveConsultationHeartRateManager.AddOrUpdate(userToken.Code, userToken.ClientId, userToken.AccountName, request.ConsultationCode);
            var controlHeartRate = new RemoteConnectHeartRateRequest()
            {
                Token = request.Token,
                IsNeedSyn = true,
                TransactionType = TransactionTypeEnum.Consultion
            };
            if (userToken.AccountType == AccountType.User)
            {
                var res = await _deviceService.RemoteConnectHeartRateAsync(controlHeartRate);
            }
            else
            {
                var res = await _deviceService.DeviceRemoteConnectHeartRateAsync(controlHeartRate);
            }
            return await Task.FromResult<LiveConsultationHeartRateResult>(new LiveConsultationHeartRateResult { ConsultationCode = request.ConsultationCode });
        }

        /// <summary>
        /// 调参
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> ControlParameterAsync(ControlDeviceParameterInConsultationRequest request)
        {
            var result = await _authenticationService.GetTokenAsync(new TokenRequest() { Token = request.Token });
            var userCode = result.ClientId;
            if (string.IsNullOrEmpty(userCode))
            {
                ThrowRpcException(CustomerRpcCode.UsercodeIsEmpty, "User code is empty");
            }
            //获取房间缓存
            var roomId = request.ConsultationCode;
            if (string.IsNullOrWhiteSpace(roomId))
            {
                ThrowRpcException(CustomerRpcCode.ConsultationCodeIsEmpty, "ConsultationCode is empty");
            }
            //会诊记录 
            var consultationRequest = new ConsultationRecordCodeDBRequest { Code = roomId };
            var consultationRecord = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(consultationRequest);
            var deviceCode = consultationRecord.DeviceCode;
            if (string.IsNullOrEmpty(deviceCode))
            {
                ThrowRpcException(CustomerRpcCode.NoExistDevice, "Device does not exist");
            }
            var deviceTokenInfo = CacheMaintenance.Instance.Get<ITokensManager>().Where(x => x.ClientId == deviceCode)?.FirstOrDefault();
            if (deviceTokenInfo == null)
            {
                ThrowRpcException(CustomerRpcCode.DeviceNotFind, "Device not found");
            }
            if (deviceTokenInfo.IsOldPlatform)
            {
                ThrowRpcException(CustomerRpcCode.DeviceNotSupport, "Device not support");
            }
            var checkIdleRequest = new GetDeviceRequest()
            {
                Token = request.Token,
                DeviceCode = deviceCode
            };
            var checkResult = await _deviceService.CheckDeviceIsIdleAsync(checkIdleRequest);
            if (!checkResult)
            {
                ThrowRpcException(CustomerRpcCode.RemoteConnectDeviceOccupied, "Remote connect device has been occupied");
            }
            var res = false;
            if (request.ControlType == ControlDeviceParameterEnum.Start || request.ControlType == ControlDeviceParameterEnum.RunExecuteApi ||
            request.ControlType == ControlDeviceParameterEnum.UpdateProbeApplication || request.ControlType == ControlDeviceParameterEnum.UpdateAndExitProbeApplication ||
            request.ControlType == ControlDeviceParameterEnum.ExitProbeApplication || request.ControlType == ControlDeviceParameterEnum.GetProbeApplication ||
            request.ControlType == ControlDeviceParameterEnum.ExecuteProbeApplicationSetting || request.ControlType == ControlDeviceParameterEnum.End)
            {
                var addRequest = new AddUserRemoteConnectRequest()
                {
                    Token = request.Token,
                    DeviceCode = deviceCode,
                    RoomId = roomId,
                    StatusEnum = ConnectStatusEnum.WaitConnect,
                    IsNeedSyn = request.IsNeedSyn
                };
                if (request.ControlType == ControlDeviceParameterEnum.Start)
                {
                    addRequest.StatusEnum = ConnectStatusEnum.WaitConnect;
                }
                else if (request.ControlType == ControlDeviceParameterEnum.RunExecuteApi || request.ControlType == ControlDeviceParameterEnum.ExecuteProbeApplicationSetting ||
                            request.ControlType == ControlDeviceParameterEnum.UpdateProbeApplication || request.ControlType == ControlDeviceParameterEnum.UpdateAndExitProbeApplication ||
                            request.ControlType == ControlDeviceParameterEnum.ExitProbeApplication || request.ControlType == ControlDeviceParameterEnum.GetProbeApplication)
                {
                    addRequest.StatusEnum = ConnectStatusEnum.CompleteConnect;
                }
                else if (request.ControlType == ControlDeviceParameterEnum.End)
                {
                    addRequest.StatusEnum = ConnectStatusEnum.WaitDisconnect;
                }
                var addRemoteConnectResult = await _deviceService.AddUserRemoteConnectAsync(addRequest);
                var user = await _userDBService.FindUserByCodeAsync(userCode);
                BroadcastNotificationRequest notificationRequest = new BroadcastNotificationRequest();
                if (request.ControlType == ControlDeviceParameterEnum.Start || request.ControlType == ControlDeviceParameterEnum.End)
                {
                    var notification = new ConnectStatusToDeviceNotification()//申请连接设备通知
                    {
                        ControlUserCode = userCode,
                        ControlUserName = user.DisplayName,
                        ControlType = request.ControlType,
                        TransactionType = TransactionTypeEnum.Consultion,
                        LoginSource = result.LoginSource,
                        DeviceCode = deviceCode,
                    };
                    notificationRequest.Message = notification;
                    notificationRequest.JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(notification);
                    notificationRequest.NotificationType = notification.NotificationType;

                    var isOldPlatform = deviceTokenInfo != null && deviceTokenInfo.IsOldPlatform && deviceTokenInfo.IsOnline;
                    if (isOldPlatform)
                    {
                        await _deviceForwardService.ApplyRemoteConnectAsync(notification);
                    }
                    notificationRequest.IsNeedSyn = false;
                }
                else
                {
                    var notification = new DeviceControlledParametersNotification()//设备通知
                    {
                        ControlUserCode = userCode,
                        ControlUserName = user.DisplayName,
                        ControlType = request.ControlType,
                        Parameters = request.Parameters,
                        LoginSource = result.LoginSource
                    };
                    notificationRequest.Message = notification;
                    notificationRequest.JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(notification);
                    notificationRequest.NotificationType = notification.NotificationType;
                    notificationRequest.IsNeedSyn = true;
                }
                notificationRequest.ClientIds = new List<string>() { deviceCode };
                notificationRequest.TransactionType = TransactionTypeEnum.Consultion;
                notificationRequest.RelevanceCode = roomId;
                notificationRequest.ReceiverType = ApplicantTypeEnum.Device;
                res = await _notificationService.BroadcastMessageAsync(notificationRequest);
            }
            return res;
        }

        /// <summary>
        /// 设备端接受连接/断开链接请求接口
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> AcceptRemoteConnnectionAsync(ControlDeviceResponseRequest request)
        {
            var res = false;
            string deviceCode = await GetClientIdByTokenAsync(request.Token);
            if (string.IsNullOrEmpty(request.UserCode))
            {
                ThrowRpcException(CustomerRpcCode.UsercodeIsEmpty, "User code is empty");
            }
            if (string.IsNullOrEmpty(deviceCode))
            {
                ThrowRpcException(CustomerRpcCode.DeviceCodeEmpty, "Device code is empty");
            }
            var result = CacheMaintenance.Instance.Get<ITokensManager>().Where(t => t.ClientId == request.UserCode && t.LoginSource == (int)request.LoginSource)?.OrderByDescending(x => x.IsOnline)?.FirstOrDefault() ?? new Token();
            if (string.IsNullOrEmpty(result.ClientId))
            {
                ThrowRpcException(CustomerRpcCode.UsercodeIsEmpty, "User code is empty");
            }
            var checkUserExistRequest = new GetDeviceRequest()
            {
                Token = result.Code,
                DeviceCode = deviceCode,
                IsNeedSyn = request.IsNeedSyn
            };
            var existRoomIdResult = await _deviceService.CheckUserIsExistRoomIdAsync(checkUserExistRequest);
            if (string.IsNullOrEmpty(existRoomIdResult))
            {
                ThrowRpcException(CustomerRpcCode.UserNotConnected, "User not connected");
            }
            var roomId = existRoomIdResult;
            var deviceInfo = CacheMaintenance.Instance.Get<IDeviceInfosManager>().Get(deviceCode);
            if (deviceInfo == null)
            {
                ThrowRpcException(CustomerRpcCode.DeviceNotExist, "Not find device");
            }
            var userCode = request.UserCode;
            if (request.ControlType == ControlDeviceParameterEnum.Start)
            {
                var addRequest = new AddUserRemoteConnectRequest()
                {
                    Token = result.Code,
                    DeviceCode = deviceCode,
                    RoomId = roomId,
                    StatusEnum = ConnectStatusEnum.CompleteConnect,
                    IsNeedSyn = request.IsNeedSyn
                };
                var addRemoteConnectResult = await _deviceService.AddUserRemoteConnectAsync(addRequest);
                var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
                if (room == null)
                {
                    ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
                }
                var existMember = room.UserInfos.FirstOrDefault(x => x.Code == userCode);
                if (existMember == null)
                {
                    ThrowRpcException(CustomerRpcCode.LivMemberNotFound, "LiveMemberNotFound");
                }
                var deviceMember = room.DeviceInfos.FirstOrDefault(v => v.Code == deviceCode);
                if (deviceMember == null)
                {
                    ThrowRpcException(CustomerRpcCode.NoExistDevice, "Device does not exist");
                }
                //检查是否用用户使用参数调节中
                var isControllingMember = room.UserInfos.FirstOrDefault(x => x.IsControllingParameter);
                if (isControllingMember != null && isControllingMember.Code != userCode)
                {
                    ThrowRpcException(CustomerRpcCode.ControllingParameterByOtherUser, "Controlling parameter by other");
                }
                var isControllingParameter = true;
                if (existMember.IsControllingParameter != isControllingParameter)
                {
                    var changeStateResult = await _rtcService.ChangeControllingStateAsync(new ChangeControllingStateRequest
                    {
                        LiveRoomCode = room.LiveRoomCode,
                        UserCode = userCode,
                        IsControllingParameter = isControllingParameter,
                    });
                }
                if (isControllingParameter)
                {
                    var notification = new DeviceControlledParametersNotification()//设备通知
                    {
                        ControlUserCode = userCode,
                        ControlUserName = request.UserName,
                        ControlType = ControlDeviceParameterEnum.Get,
                        Parameters = new List<AdditionParameterDTO>()
                    };
                    BroadcastNotificationRequest notificationRequest = new BroadcastNotificationRequest();
                    notificationRequest.ClientIds = new List<string>() { deviceCode };
                    notificationRequest.Message = notification;
                    notificationRequest.JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(notification);
                    notificationRequest.NotificationType = notification.NotificationType;
                    notificationRequest.TransactionType = TransactionTypeEnum.AfterSales;
                    notificationRequest.RelevanceCode = roomId;
                    notificationRequest.ReceiverType = ApplicantTypeEnum.Device;
                    notificationRequest.IsNeedSyn = true;
                    res = await _notificationService.BroadcastMessageAsync(notificationRequest);
                }
            }
            else
            {
                //关闭正在进行的链接
                var closeRemoteConnectResult = await _deviceService.CloseUserRemoteConnectAsync(checkUserExistRequest);
                if (request.ControlType == ControlDeviceParameterEnum.End)
                {
                    var notify = new DeviceDisconnectRemoteControlNotification()
                    {
                        DeviceCode = deviceCode,
                    };
                    var endNotificationRequest = new SendNotificationRequest()
                    {
                        ClientId = request.UserCode,
                        Message = notify,
                        JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(notify),
                        NotificationType = notify.NotificationType,
                        TransactionType = TransactionTypeEnum.AfterSales,
                        RelevanceCode = request.UserCode,
                        ReceiverType = ApplicantTypeEnum.Client
                    };
                    res = await _notificationService.PostMessageAsync(endNotificationRequest);
                    return res;
                }
                else if (request.ControlType == ControlDeviceParameterEnum.RejectConnect)
                {
                    var notify = new DeviceRejectRemoteControlNotification()
                    {
                        DeviceCode = deviceCode,
                    };
                    var rejectNotificationRequest = new SendNotificationRequest()
                    {
                        ClientId = request.UserCode,
                        Message = notify,
                        JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(notify),
                        NotificationType = notify.NotificationType,
                        TransactionType = TransactionTypeEnum.AfterSales,
                        RelevanceCode = request.UserCode,
                        ReceiverType = ApplicantTypeEnum.Client
                    };
                    res = await _notificationService.PostMessageAsync(rejectNotificationRequest);
                    return res;
                }
            }
            return res;
        }

        private async void HandleClientJoined(string roomId, string clientId, string name, bool sendMessage)
        {
            try
            {
                //获取房间缓存
                var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
                var liveMember = room?.UserInfos.FirstOrDefault(x => x.Code == clientId);
                if (liveMember == null)
                {
                    liveMember = room?.DeviceInfos.FirstOrDefault(x => x.Code == clientId);
                }
                if (room != null && liveMember != null)
                {
                    if (liveMember.Status == LiveMemberStatus.Accepted || liveMember.Status == LiveMemberStatus.Left || sendMessage)
                    {
                        await _rtcService.HeartRateJoinedAsync(new HeartRateJoinRequest
                        {
                            LiveRoomCode = roomId,
                            UserCode = clientId,
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"LiveConsultationService HandleClientJoined err, name:{name}, clientId:{clientId}, roomId:{roomId}, ex:{ex}");
            }
        }

        private async void HandleClientNetworkErr(string roomId, string clientId, string name)
        {
            try
            {
                //获取房间缓存
                var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
                var liveMember = room?.UserInfos.FirstOrDefault(x => x.Code == clientId);
                if (liveMember == null)
                {
                    liveMember = room?.DeviceInfos.FirstOrDefault(x => x.Code == clientId);
                }
                if (room != null && liveMember != null)
                {
                    if (liveMember.Status == LiveMemberStatus.Joined)
                    {
                        await _rtcService.NetworkErrorAsync(new NetworkErrorRequest
                        {
                            LiveRoomCode = roomId,
                            UserCode = clientId,
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"LiveConsultationService ClientNetworkErrAsync err, name:{name}, clientId:{clientId}, roomId:{roomId}, ex:{ex}");
            }
        }

        private async void HandleClientLeave(string roomId, string clientId, string name)
        {
            try
            {
                //获取房间缓存
                var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
                var liveMember = room?.UserInfos.FirstOrDefault(x => x.Code == clientId);
                if (liveMember == null)
                {
                    liveMember = room?.DeviceInfos.FirstOrDefault(x => x.Code == clientId);
                }
                if (room != null && liveMember != null)
                {
                    var consultationRecord = CacheMaintenance.Instance.Get<IConsultationRecordManager>().Get(roomId);
                    if (liveMember.Status == LiveMemberStatus.Joined && consultationRecord != null)
                    {
                        var closed = false;
                        //调整为只要基层或者会诊专家离线就认为会诊结束，房间解散
                        if (consultationRecord.ExpertUserCode == clientId || consultationRecord.ApplyUserCode == clientId)
                        {
                            closed = true;
                        }
                        // var joinMembers = members.Where(x => x.MemberType == LiveMemberEnum.User && x.Status == LiveConsultationMemberStatus.Joined && x.Id != clientId)?.ToList() ?? new List<LiveConsultationMember>();
                        // if (!joinMembers.Any())
                        // {
                        //     closed = true;
                        // }
                        await _rtcService.HeartRateLeavedAsync(new HeartRateLeavedRequest
                        {
                            LiveRoomCode = roomId,
                            UserCode = clientId,
                        });
                        if (closed)
                        {
                            await _rtcService.CloseAsync(new CloseRequest
                            {
                                LiveRoomCode = roomId,
                                UserCode = clientId,
                            });
                            //修改预约记录状态
                            var reportRequest = new GetReportByRecordCodeDBRequest { RecordCode = roomId };
                            var report = await _reportDBService.GetReportByRecordCodeAsync(reportRequest);
                            if (report != null && report.Count > 0)
                            {
                                await _consultationRecordDBService.UpdateConsultationStatusAsync(roomId, TransactionStatusEnum.End);
                            }
                            else
                            {
                                var consultationStatus = TransactionStatusEnum.ToStart;
                                var members = await _rtcService.GetLiveMemberInfosAsync(new GetLiveMemberInfosRequest { LiveRoomCode = roomId });
                                if (LiveMemberHasJoined(members, consultationRecord.ExpertUserCode) && LiveMemberHasJoined(members, consultationRecord.ApplyUserCode))
                                {
                                    consultationStatus = TransactionStatusEnum.PendingReport;
                                }
                                await _consultationRecordDBService.UpdateConsultationStatusAsync(roomId, consultationStatus);
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"LiveConsultationService HandleClientLeave err, name:{name}, clientId:{clientId}, roomId:{roomId}, ex:{ex}");
            }
        }

        private void ThrowRpcException(CustomerRpcCode code, string message, string internalMessage = null)
        {
            base.ThrowRpcException((int)code, message, internalMessage ?? message);
        }



        private async Task<string> GetClientIdByTokenAsync(string token)
        {
            var result = await _authenticationService.GetTokenAsync(new TokenRequest() { Token = token });
            return result.ClientId; //return User code 
        }

        /// <summary>
        /// 发送白板交互数据
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> SendInteractiveBoardDataAsync(SendInteractiveBoardDataRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            var roomId = request.ConsultationCode;
            var room = _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
            if (room == null)
            {
                ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
            }
            await _rtcService.SendBoardDataAsync(new SendBoardDataRequest
            {
                LiveRoomCode = roomId,
                UserCode = userCode,
                BoardData = request.BoardData,
                IsClear = request.IsClear,
            });
            return true;
        }

        /// <summary>
        ///  Initiated   other Users or devices in  diagnosis meeting
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<InviteInLiveConsultationResult> InviteInLiveConsultationAsync(InviteInLiveConsultationRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            //获取房间缓存
            var roomId = request.ConsultationCode;
            using (await _lockManager.Acquire(roomId))
            {
                var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
                if (room == null)
                {
                    ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
                }
                else if (room.Status != LiveRoomStatus.Initiating)
                {
                    //只有会诊过程的状态才可以邀请
                    ThrowRpcException(CustomerRpcCode.ConsultationNotInProcess, "ConsultationNotInProcess");
                }
                if (request.InviteCodes.Count == 1)
                {
                    var liveMemberInfos = await _rtcService.GetLiveMemberStatusInfosAsync(new GetLiveMemberStatusInfosRequest { UserCodes = request.InviteCodes });
                    var liveMemberInfo = liveMemberInfos.FirstOrDefault();
                    if (liveMemberInfo?.UserStatusType == UserStatusEnum.NotOnline)
                    {
                        ThrowRpcException(CustomerRpcCode.InviterNotOnLine, "Inviter Not OnLine");
                    }
                    if (liveMemberInfo?.UserStatusType == UserStatusEnum.IsBusy)
                    {
                        ThrowRpcException(CustomerRpcCode.InviterIsBusy, "Inviter Is Busy");
                    }
                }
                await _rtcService.InviteInAsync(new InviteInRequest
                {
                    LiveRoomCode = roomId,
                    UserCode = userCode,
                    InviteCodes = request.InviteCodes.ToList()
                });

                var result = new InviteInLiveConsultationResult
                {
                    ConsultationCode = roomId
                };
                return result;
            }
        }

        /// <summary>
        ///  Cancel initiating  other Users or devices in  diagnosis meeting
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<CancelInvitingInLiveConsultationResult> CancelInvitingInLiveConsultationAsync(CancelInvitingInLiveConsultationRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            //获取房间缓存
            var roomId = request.ConsultationCode;
            using (await _lockManager.Acquire(roomId))
            {
                var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
                if (room == null)
                {
                    ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
                }
                else if (room.Status != LiveRoomStatus.Initiating)
                {
                    //只有会诊过程的状态才可以邀请
                    ThrowRpcException(CustomerRpcCode.ConsultationNotInProcess, "ConsultationNotInProcess");
                }
                await _rtcService.CancelInviteInAsync(new CancelInviteInRequest
                {
                    LiveRoomCode = roomId,
                    UserCode = userCode,
                    InviteCodes = request.InviteCodes.ToList()
                });
                return new CancelInvitingInLiveConsultationResult() { ConsultationCode = roomId };
            }
        }

        /// <summary>
        /// 拒绝会诊中邀请-废弃
        /// </summary>
        /// <param name="request">The request</param>
        /// <returns></returns>
        public async Task<RejectLiveConsultationResult> RejectInviteLiveConsultationAsync(RejectLiveConsultationRequest request)
        {
            var userCode = await GetClientIdByTokenAsync(request.Token);
            //获取房间缓存
            var roomId = request.ConsultationCode;
            using (await _lockManager.Acquire(roomId))
            {
                var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
                if (room == null)
                {
                    ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
                }
                await _rtcService.RejectInviteAsync(new RejectInviteRequest
                {
                    LiveRoomCode = roomId,
                    UserCode = userCode,
                });
                var result = new RejectLiveConsultationResult() { ConsultationCode = roomId };
                return result;
            }
        }

        /// <summary>
        /// 会诊中加入房间
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<JoinLiveConsultationResult> JoinInLiveConsultationAsync(JoinLiveConsultationRequest request)
        {
            var tokenInfo = await _authenticationService.GetTokenAsync(request);
            var userCode = tokenInfo.ClientId;
            //获取房间缓存
            var roomId = request.ConsultationCode;
            var recordRequest = new ConsultationRecordCodeDBRequest { Code = request.ConsultationCode };
            var record = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(recordRequest);
            using (await _lockManager.Acquire(roomId))
            {
                var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
                if (room == null)
                {
                    ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
                }
                else if (room.Status != LiveRoomStatus.Initiating)
                {
                    if (record.ConsultationStatus == TransactionStatusEnum.InProgress)
                    {
                        var consultationStatus = room.Status == LiveRoomStatus.Closed ? TransactionStatusEnum.PendingReport : TransactionStatusEnum.ToStart;
                        await _consultationRecordDBService.UpdateConsultationStatusAsync(roomId, consultationStatus);
                    }
                    ThrowRpcException(CustomerRpcCode.ConsultationNotInProcess, "ConsultationNotInProcess");
                }
                var joinedByOtherDevice = await IsJoinedByOtherDevice(roomId, userCode, tokenInfo.LoginSource);
                if (joinedByOtherDevice)
                {
                    ThrowRpcException(CustomerRpcCode.JoinedByOtherDevice, "JoinedByOtherDevice");
                }
                if (request.CheckOnly)
                {
                    return new JoinLiveConsultationResult { ConsultationCode = roomId };
                }
                await _rtcService.JoinInAsync(new JoinInRequest
                {
                    LiveRoomCode = roomId,
                    UserCode = userCode,
                    SortLevel = (int)LiveConsultationRoleEnum.OtherParticipant,
                    LoginSource = tokenInfo.LoginSource,
                });
                //加入到参与人员
                if (userCode != record.ExpertUserCode && userCode != record.ApplyUserCode)
                {
                    var consultationMember = record.ConsultationMembers.FirstOrDefault(x => x.MemberCode == userCode);
                    if (consultationMember == null)
                    {
                        var userInfoDTO = await _userDBService.FindUserByCodeAsync(userCode);
                        var addMemberDTO = new ConsultationMemberDTO
                        {
                            MemberCode = userInfoDTO.UserCode,
                            MemberOrganizationCode = userInfoDTO.RootOrganizationCode,
                            MemberDepartmentCode = userInfoDTO.OrganizationCode,
                            MemberStatus = LiveConsultationMemberStatus.Accepted,
                            MemberOperateTime = DateTime.UtcNow
                        };
                        record.ConsultationMembers.Add(addMemberDTO);
                        await _consultationRecordDBService.UpdateConsultationRecordAsync(record);
                    }
                    else if (consultationMember.MemberStatus != LiveConsultationMemberStatus.Accepted)
                    {
                        consultationMember.MemberStatus = LiveConsultationMemberStatus.Accepted;
                        consultationMember.MemberOperateTime = DateTime.UtcNow;
                        await _consultationRecordDBService.UpdateConsultationRecordAsync(record);
                    }
                }
                //加入到日程
                var addScheduleUsersRequest = new AddScheduleUsersDBRequest
                {
                    RelevanceCode = roomId,
                    UserCodes = new List<string> { userCode },
                };
                await _userDBService.AddScheduleUsersDBAsync(addScheduleUsersRequest);

                var userSignRequest = new GetUserSignRequest
                {
                    UserId = userCode
                };
                var userSignResult = await _wingRtcService.GetUserSignAsync(userSignRequest);
                var boardDatas = await _rtcService.GetLiveBoardDatasAsync(new GetLiveBoardDatasRequest { LiveRoomCode = roomId });
                var members = await _rtcService.GetLiveMemberInfosAsync(new GetLiveMemberInfosRequest { LiveRoomCode = roomId });

                var result = new JoinLiveConsultationResult
                {
                    ConsultationCode = roomId,
                    UserCode = userCode,
                    UserSign = userSignResult.UserSign,
                    AppId = room.SdkAppId,
                    RoomNo = room.RtcRoomId,
                    LiveProtocol = EnvironmentConfigs.General.LiveProtocolDetail<TransactionStatusEnum>(),
                    MemberLiveDatas = members,
                    InteractiveBoardDatas = boardDatas.Select(x => new InteractiveBoardDataDTO
                    {
                        UserCode = x.UserCode,
                        BoardData = x.BoardData,
                        InteractiveTime = x.InteractiveTime
                    }).ToList(),
                };
                Logger.WriteLineInfo($"LiveConsultationService JoinInLiveConsultationAsync roomId:{roomId}, rtcRoomId:{room.RtcRoomId}, members:{string.Join(";", members.Select(m => $"{m.Name},sortLevel:{m.SortLevel},sortNumber:{m.SortNumber}"))}");
                return result;
            }
        }

        /// <summary>
        /// 会诊中获取可邀请用户信息列表
        /// </summary>
        /// <param name="request">请求体</param>
        /// <returns>用户信息列表</returns>
        public async Task<List<UserExtendDTO>> GetInviteableUserListAsync(GetInviteableUserListRequest request)
        {
            //获取房间缓存
            var roomId = request.ConsultationCode;
            var language = request.Language;
            var organizationCode = request.OrganizationCode;
            var dbRequest = new GetUserListDBRequest
            {
                OrganizationCode = organizationCode,
                OrganizationQueryType = OrganizationQueryTypeEnum.All,
                ExceptUsers = new List<string>(),
                RoleCodes = new List<string> { "Role_CertifiedExpert", "Role_CertifiedPhysician", "Role_InternshipDoctor" }
            };
            var users = await _userDBService.GetUserListAsync(dbRequest);
            //过滤已在会诊间的用户 返回的结果能够跟据状态排序，能够邀请的用户排在前面，不在线和繁忙的用户排在后面
            if (users.Count > 0)
            {
                var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
                if (room != null)
                {
                    var userCodes = room.UserInfos.Select(x => x.Code);
                    users = users.Where(x => !userCodes.Contains(x.UserCode)).ToList();
                }
            }
            var result = users.MappingTo<List<UserExtendDTO>>();
            if (result.Count == 0)
            {
                return result;
            }
            var findAuthenticationRolesRequest = new FindAuthenticationRolesRequest { Language = language };
            var roles = await _roleService.FindAllRolesAsync(findAuthenticationRolesRequest);
            foreach (var item in result)
            {
                if (item.RoleCodes != null && item.RoleCodes.Count > 0)
                {
                    item.RoleName = roles.FirstOrDefault(x => x.RoleCode == item.RoleCodes[0])?.RoleName;
                }
                item.UserStatus = GetUserStatus(item.UserCode);
            }
            result = result.OrderByDescending(x => x.UserStatus).ToList();
            var orgInfo = CacheMaintenance.Instance.Get<IOrganizationsManager>().Where(c => c.Code == organizationCode)?.FirstOrDefault() ?? new CacheOrganizationDTO();
            foreach (var item in result)
            {
                item.RootOrganizationCode = organizationCode;
                item.RootOrganizationName = orgInfo.OrganizationName;
            }
            return result;
        }

        /// <summary>
        /// 切换会诊房间
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<ChangeConsultationResult> ChangeConsultationAsync(ChangeConsultationRequest request)
        {
            var userToken = await _authenticationService.GetTokenAsync(request);
            var userCode = userToken.ClientId;
            var originalRoomId = request.OriginalCode;
            var currentRoomId = request.CurrentCode;
            var original = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = originalRoomId });
            if (original == null)
            {
                ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
            }
            else if (original.Status != LiveRoomStatus.Initiating)
            {
                ThrowRpcException(CustomerRpcCode.ConsultationNotInProcess, "ConsultationNotInProcess");
            }
            var liveMember = original.UserInfos.FirstOrDefault(x => x.Code == userCode);
            if (liveMember == null)
            {
                ThrowRpcException(CustomerRpcCode.ChangeConsultationNoFeature, "ChangeConsultationNoFeature");
            }
            else if (liveMember.Status != LiveMemberStatus.Joined)
            {
                ThrowRpcException(CustomerRpcCode.OperatorNoJoined, "OperatorNoJoined");
            }
            var roomId = original.LiveRoomCode;
            var patientName = original.Name;
            var initiatorCode = original.InitiatorCode;
            var current = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = currentRoomId });
            if (current == null)
            {
                ThrowRpcException(CustomerRpcCode.CurrentConsultationNotFound, "CurrentConsultationNotFound");
            }
            else if (current.Status == LiveRoomStatus.Initiating)
            {
                ThrowRpcException(CustomerRpcCode.CurrentConsultationInProcess, "CurrentConsultationInProcess");
            }
            //处理会诊中。切换下一个病人时，针对会 待会诊和已过期的会诊单进行缓存更新处理      
            var consultationRecord = CacheMaintenance.Instance.Get<IConsultationRecordManager>().Get(current.LiveRoomCode);
            if (consultationRecord != null && (consultationRecord.ConsultationStatus == (int)TransactionStatusEnum.ToStart ||
                                                consultationRecord.ConsultationStatus == (int)TransactionStatusEnum.Expired))
            {
                var consultationStatus = TransactionStatusEnum.InProgress;
                await _consultationRecordDBService.UpdateConsultationStatusAsync(current.LiveRoomCode, consultationStatus);
                CacheMaintenance.Instance.Get<IConsultationRecordManager>().Remove(current.LiveRoomCode);
            }
            await _rtcService.ChangeRoomAsync(new ChangeRoomRequest
            {
                LiveRoomCode = original.LiveRoomCode,
                UserCode = userCode,
                OriginalCode = request.OriginalCode,
                CurrentCode = request.CurrentCode,
            });
            _liveConsultationHeartRateManager.AddOrUpdate(userToken.Code, userCode, userToken.AccountName, current.LiveRoomCode);
            //修改预约记录状态
            var reportRequest = new GetReportByRecordCodeDBRequest { RecordCode = original.LiveRoomCode };
            var report = await _reportDBService.GetReportByRecordCodeAsync(reportRequest);
            var members = await _rtcService.GetLiveMemberInfosAsync(new GetLiveMemberInfosRequest { LiveRoomCode = current.LiveRoomCode });
            if (report != null && report.Count > 0)
            {
                await _consultationRecordDBService.UpdateConsultationStatusAsync(original.LiveRoomCode, TransactionStatusEnum.End);
            }
            else
            {
                consultationRecord = CacheMaintenance.Instance.Get<IConsultationRecordManager>().Get(roomId);
                if (consultationRecord != null)
                {
                    var consultationStatus = TransactionStatusEnum.ToStart;
                    if (LiveMemberHasJoined(members, consultationRecord.ExpertUserCode) && LiveMemberHasJoined(members, consultationRecord.ApplyUserCode))
                    {
                        consultationStatus = TransactionStatusEnum.PendingReport;
                    }
                    await _consultationRecordDBService.UpdateConsultationStatusAsync(original.LiveRoomCode, consultationStatus);
                }
            }
            var result = new ChangeConsultationResult
            {
                ConsultationCode = current.LiveRoomCode,
                RoomNo = current.RtcRoomId,
                InitiatorCode = current.InitiatorCode,
                MemberLiveDatas = members,
            };
            return result;
        }

        // /// <summary>
        // /// 更改调参状态
        // /// </summary>
        // /// <param name="request">请求实体</param>
        // /// <returns>true</returns>
        // /// <show>false</show>
        // public async Task<bool> ChangeConsultationControllingStateAsync(ChangeConsultationControllingStateRequest request)
        // {
        //     var userCode = request.UserCode;
        //     var isControllingParameter = request.IsControllingParameter;
        //     await _rtcService.ChangeControllingStateAsync(new ChangeControllingStateRequest
        //     {
        //         UserCode = userCode,
        //         DeviceCode = request.DeviceCode,
        //         IsControllingParameter = request.IsControllingParameter,
        //     });
        //     return await Task.FromResult(true);
        // }

        /// <summary>
        /// 发送会诊提醒短信通知
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private async Task<bool> SendSmsReminderConsultationAsync(IList<string> clientIds, string time, string patientName, DateTime startTime, DateTime endTime)
        {
            try
            {
                var startEndTimeStr = startTime.ToLocalTime().ToString("yyyy-MM-dd HH:mm") + "-" + endTime.ToLocalTime().ToString("HH:mm");
                var phones = await GetMobileList(clientIds);
                return await _smsService.GeneralMessageAsync(phones, _reminderSmsTemplateId, new List<string> { time, patientName, startEndTimeStr });
            }
            catch (System.Exception ex)
            {
                Logger.WriteLineWarn("LiveConsultationService-SendSmsReminderConsultationAsync:" + "patientName" + patientName + ":" + ex);
                return false;
            }
        }

        private async Task<List<string>> GetMobileList(IList<string> clientIds)
        {
            var users = await _userDBService.FindUserListByUserCodesAsync(clientIds.ToList());
            return users.Where(c => !string.IsNullOrEmpty(c.Phone)).Select(v => v.Phone).Distinct().ToList();
        }

        /// <summary>
        /// 发送会诊邀请短信通知
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private async Task<bool> SendSmsInviteConsultationAsync(IList<string> clientIds, string inviter, string patientName, DateTime startTime, DateTime endTime)
        {
            try
            {
                var startEndTimeStr = startTime.ToLocalTime().ToString("yyyy-MM-dd HH:mm") + "-" + endTime.ToLocalTime().ToString("HH:mm");
                var phones = await GetMobileList(clientIds);
                return await _smsService.GeneralMessageAsync(phones, _inviteSmsTemplateId, new List<string> { inviter, patientName, startEndTimeStr });
            }
            catch (System.Exception ex)
            {
                Logger.WriteLineWarn("LiveConsultationService-SendSmsInviteConsultationAsync:" + "patientName" + patientName + ":" + ex);
                return false;
            }
        }

        /// <summary>
        /// 发送预约申请提交短信通知
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private async Task<bool> SendSmsSubmitApplyConsultationAsync(IList<string> clientIds, string inviter, string patientName, DateTime consultationTime, string orgName)
        {
            try
            {
                var consultationTimeStr = consultationTime.ToLocalTime().ToString("yyyy-MM-dd");
                var phones = await GetMobileList(clientIds);
                return await _smsService.GeneralMessageAsync(phones, _submitSmsTemplateId, new List<string> { inviter, patientName, consultationTimeStr, orgName });
            }
            catch (System.Exception ex)
            {
                Logger.WriteLineWarn("LiveConsultationService-SendSmsSubmitApplyConsultationAsync:" + "patientName" + patientName + ":" + ex.ToString());
                return false;
            }
        }

        /// <summary>
        /// 呼叫急诊专家
        /// </summary>
        /// <param name="roomId"></param>
        /// <param name="doctors"></param>
        /// <returns></returns>
        private void CallEmergencyDoctors(string roomId, IList<UserDTO> doctors, int rtcRoomId, LiveConsultationMember initiator)
        {
            var consultationRecord = CacheMaintenance.Instance.Get<IConsultationRecordManager>().Get(roomId);
            if (consultationRecord != null && consultationRecord.IsEmergency && string.IsNullOrWhiteSpace(consultationRecord.ExpertUserCode))
            {
                Task.Run(async () =>
                {
                    Logger.WriteLineInfo($"LiveConsultationService CallEmergencyDoctors, roomId:{roomId}, name:{consultationRecord.PatientCode}");
                    await UpdateEmergencyStateAsync(roomId, EmergencyConsultationStatus.Initiating);
                    var status = EmergencyConsultationStatus.Initiating;
                    foreach (var doctor in doctors)
                    {
                        status = GetEmergencyStatus(roomId);
                        if (status == EmergencyConsultationStatus.Accepted
                            || status == EmergencyConsultationStatus.Cancelled)
                        {
                            break;
                        }
                        //开始呼叫
                        Logger.WriteLineInfo($"LiveConsultationService CallEmergencyDoctors, roomId:{roomId}, doctor:{doctor.DisplayName}");
                        var emergencyCallNotification = new EmergencyCallNotification
                        {
                            ConsultationCode = roomId,
                            RoomNo = rtcRoomId,
                            Timeout = _emergencyTimeout,
                            Initiator = initiator
                        };
                        var broadcastNotificationRequest = new BroadcastNotificationRequest()
                        {
                            ClientIds = new List<string> { doctor.UserCode },
                            Message = emergencyCallNotification,
                            JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(emergencyCallNotification),
                            NotificationType = emergencyCallNotification.NotificationType,
                            TransactionType = TransactionTypeEnum.Consultion,
                            RelevanceCode = consultationRecord.Code,
                            ReceiverType = ApplicantTypeEnum.Client
                        };
                        await _notificationService.BroadcastMessageAsync(broadcastNotificationRequest);
                        for (var s = 0; s < _emergencyTimeout; s++)
                        {
                            await Task.Delay(1000);
                            status = GetEmergencyStatus(roomId);
                            if (status == EmergencyConsultationStatus.Accepted
                             || status == EmergencyConsultationStatus.Cancelled
                             || status == EmergencyConsultationStatus.Rejected)
                            {
                                break;
                            }
                        }
                    }
                    if (status == EmergencyConsultationStatus.Initiating || status == EmergencyConsultationStatus.Rejected)
                    {
                        await _rtcService.CloseAsync(new CloseRequest
                        {
                            LiveRoomCode = roomId,
                            UserCode = initiator.Id,
                        });
                        await _consultationRecordDBService.UpdateConsultationStatusAsync(roomId, TransactionStatusEnum.ToStart);
                        //急诊呼叫失败
                        var callFailedNotification = new EmergencyCallFailedNotification
                        {
                            ConsultationCode = roomId,
                        };
                        var broadcastNotificationRequest = new BroadcastNotificationRequest()
                        {
                            ClientIds = new List<string> { initiator.Id },
                            Message = callFailedNotification,
                            JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(callFailedNotification),
                            NotificationType = callFailedNotification.NotificationType,
                            TransactionType = TransactionTypeEnum.Consultion,
                            RelevanceCode = consultationRecord.Code,
                            ReceiverType = ApplicantTypeEnum.Client
                        };
                        await _notificationService.BroadcastMessageAsync(broadcastNotificationRequest);
                    }
                });
            }
        }

        /// <summary>
        /// 查询急诊专家集合
        /// </summary>
        /// <param name="organizationCode">当前操作人所在机构</param>
        /// <returns></returns>
        private async Task<List<UserDTO>> GetEmergencyDoctorsAsync(string organizationCode)
        {
            var getOrganizationDBRequest = new GetOrganizationDBRequest
            {
                OrganizationCode = organizationCode
            };
            var organization = await _organizationDBService.GetOrganizationDetailAsync(getOrganizationDBRequest);
            if (organization == null || organization.ReferralOrganizations == null || !organization.ReferralOrganizations.Any())
            {
                //未设置会诊医院
                ThrowRpcException(CustomerRpcCode.ReferralOrganizationsIsEmpty, "Referral Organizations Is Empty");
            }
            var emergencyOrgCode = organization.ParentCode;
            if (organization.ReferralOrganizations.All(x => x.OrganizationCode != organization.ParentCode))
            {
                emergencyOrgCode = organization.ReferralOrganizations.FirstOrDefault().OrganizationCode;
            }
            if (string.IsNullOrWhiteSpace(emergencyOrgCode))
            {
                //未设置会诊医院
                ThrowRpcException(CustomerRpcCode.ReferralOrganizationsIsEmpty, "Referral Organizations Is Empty");
            }
            var orgList = await _organizationDBService.SearchOrgByRootCodesAsync(new List<string> { emergencyOrgCode });
            if (orgList.Any() != true)
            {
                return new List<UserDTO>();
            }
            var orgCodes = orgList.Select(x => x.OrganizationCode).ToList();
            var doctors = await _userDBService.FindUserListByOrganizationCodesAsync(orgCodes);
            if (doctors.Any() != true)
            {
                return new List<UserDTO>();
            }
            var tokenManager = CacheMaintenance.Instance.Get<ITokensManager>();
            var userCodes = doctors.Select(x => x.UserCode).ToList();
            var doctorInfos = await _rtcService.GetLiveMemberStatusInfosAsync(new GetLiveMemberStatusInfosRequest { UserCodes = userCodes });
            var emergencyDoctors = doctors.Where(d =>
            {
                if (!d.RoleCodes.Contains("Role_CertifiedExpert") && !d.RoleCodes.Contains("Role_CertifiedPhysician"))
                {
                    return false;
                }
                var info = doctorInfos.FirstOrDefault(x => x.Code == d.UserCode);
                if (info == null || info.UserStatusType == UserStatusEnum.NotOnline)
                {
                    return false;
                }
                if (info.UserStatusType == UserStatusEnum.IsBusy)
                {
                    return false;
                }
                return true;
            });
            return emergencyDoctors?.ToList() ?? new List<UserDTO>();
        }

        private void StartCheckEmergencyDoctorTimeout(string roomId, string initiatorCode, string expertCode)
        {
            Task.Run(async () =>
            {
                await Task.Delay(60 * 1000);
                var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
                if (room != null && room.Status == LiveRoomStatus.Initiating)
                {
                    var members = await _rtcService.GetLiveMemberInfosAsync(new GetLiveMemberInfosRequest { LiveRoomCode = roomId });
                    if (members == null || !members.Any(x => x.Id == expertCode && x.Status == LiveConsultationMemberStatus.Joined))
                    {
                        //专家超时未接受，自动结束会诊
                        await _rtcService.CloseAsync(new CloseRequest
                        {
                            LiveRoomCode = roomId,
                            UserCode = initiatorCode,
                        });
                        await _consultationRecordDBService.UpdateConsultationStatusAsync(roomId, TransactionStatusEnum.ToStart);
                    }
                }
            });
        }

        private async Task<EmergencyConsultationStatus> UpdateEmergencyStateAsync(string roomId, EmergencyConsultationStatus status)
        {
            await _consultationRecordDBService.UpdateEmergencyStatusAsync(roomId, status);
            return status;
        }

        private EmergencyConsultationStatus GetEmergencyStatus(string roomId)
        {
            try
            {
                var status = CacheMaintenance.Instance.Get<IConsultationRecordManager>().Get(roomId).EmergencyStatus;
                return (EmergencyConsultationStatus)status;
            }
            catch (Exception ex)
            {
                return EmergencyConsultationStatus.Default;
            }
        }

        /// <summary>
        /// 判断是否已在其它设备进入房间
        /// </summary>
        /// <param name="recordCode"></param>
        /// <param name="userCode"></param>
        /// <param name="loginSource"></param>
        /// <returns></returns>
        private async Task<bool> IsJoinedByOtherDevice(string recordCode, string userCode, LoginSource loginSource)
        {
            var liveMember = await _rtcService.GetLiveMemberByRoomIdAsync(new GetLiveMemberByRoomIdRequest
            {
                LiveRoomCode = recordCode,
                UserCode = userCode,
            });
            if (liveMember == null || liveMember.MemberType == LiveMemberEnum.Device)
            {
                return false;
            }
            var loginSourceList = GetLoginSource(loginSource);
            return !loginSourceList.Contains(liveMember.LoginSource);
        }

        private List<LoginSource> GetLoginSource(LoginSource loginSource)
        {
            var list = new List<LoginSource>();
            switch (loginSource)
            {
                case LoginSource.PC:
                case LoginSource.Web:
                    list.Add(LoginSource.PC);
                    list.Add(LoginSource.Web);
                    break;
                case LoginSource.Mobile:
                case LoginSource.Pad:
                    list.Add(LoginSource.Mobile);
                    list.Add(LoginSource.Pad);
                    break;
                default:
                    list.Add(loginSource);
                    break;
            }
            return list;
        }

        private bool LiveMemberHasJoined(List<LiveConsultationMember> members, string memberCode)
        {
            if (members != null && members.Any())
            {
                if (!string.IsNullOrWhiteSpace(memberCode))
                {
                    return members.Any(x => x.Id == memberCode && (x.Status == LiveConsultationMemberStatus.Accepted || x.Status == LiveConsultationMemberStatus.Joined || x.Status == LiveConsultationMemberStatus.Left));
                }
            }
            return false;
        }

        /// <summary>
        /// 设备会诊中加入房间
        /// </summary>
        /// <param name="request">The request</param>
        /// <returns></returns>
        public async Task<LiveConsultationMember> DeviceJoinInLiveConsultationAsync(JoinLiveConsultationRequest request)
        {
            var roomId = request.ConsultationCode;
            var result = new LiveConsultationMember();
            try
            {
                //获取房间缓存
                using (await _lockManager.Acquire(roomId))
                {
                    var cacheConsultationRecordDTO = CacheMaintenance.Instance.Get<IConsultationRecordManager>().Get(request.ConsultationCode) ?? new CacheConsultationRecordDTO();
                    //验证
                    var deviceTokenInfo = CacheMaintenance.Instance.Get<ITokensManager>().Where(dx => dx.ClientId == cacheConsultationRecordDTO.DeviceCode)?.FirstOrDefault() ?? new Token();
                    if (!deviceTokenInfo.IsOnline)
                    {
                        ThrowRpcException(CustomerRpcCode.DeviceNotOnline, "Device not online");
                    }
                    var room = await _rtcService.GetLiveRoomAsync(new GetLiveRoomRequest { LiveRoomCode = roomId });
                    if (room == null)
                    {
                        ThrowRpcException(CustomerRpcCode.LiveConsultationNotFound, "LiveConsultationNotFound");
                    }
                    else if (room.Status != LiveRoomStatus.Initiating)
                    {
                        ThrowRpcException(CustomerRpcCode.ConsultationNotInProcess, "ConsultationNotInProcess");
                    }
                    //如果房间中都设备已经在推流，joined，就比较已经加入房间了，返回已有的信息
                    var deviceLiveRoom = room.DeviceInfos?.FirstOrDefault(c => c.Code == cacheConsultationRecordDTO.DeviceCode);
                    if (deviceLiveRoom == null)
                    {
                        ThrowRpcException(CustomerRpcCode.DeviceNotExist, "Device not exist");
                    }
                    if (deviceLiveRoom.Status == LiveMemberStatus.Joined)
                    {
                        var liveMemberReq = new GetLiveMemberInfosRequest()
                        {
                            LiveRoomCode = roomId
                        };
                        var liveMemberInfoList = await _rtcService.GetLiveMemberInfosAsync(liveMemberReq);
                        if (liveMemberInfoList?.Count > 0)
                        {
                            result = liveMemberInfoList.FirstOrDefault(c => c.Id == cacheConsultationRecordDTO.DeviceCode) ?? new LiveConsultationMember();
                            return result;
                        }
                    }
                    //验证超声机空闲状态
                    var memberRequest = new GetLiveMemberStatusInfosRequest()
                    {
                        UserCodes = new List<string>() { cacheConsultationRecordDTO.DeviceCode }
                    };
                    var stautsInfo = await _rtcService.GetLiveMemberStatusInfosAsync(memberRequest);
                    var curDeviceInfo = new LiveMemberStatusDTO();
                    if (stautsInfo?.Count > 0)
                    {
                        curDeviceInfo = stautsInfo.FirstOrDefault(c => c.Code == cacheConsultationRecordDTO.DeviceCode) ?? new LiveMemberStatusDTO();
                    }
                    if (curDeviceInfo == null || (curDeviceInfo.UserStatusType == UserStatusEnum.IsBusy && curDeviceInfo.LiveRoomCode != roomId))
                    {
                        Logger.WriteLineWarn($"LiveConsultationService deviceCode:[{cacheConsultationRecordDTO.DeviceCode}] Join in consultation live failed, roomId:{roomId}");
                        ThrowRpcException(CustomerRpcCode.DeviceIsBusy, "Device is busy");
                    }
                    var joinLiveMemberInfo = await _rtcService.DeviceJoinInAsync(new DeviceJoinInRequest
                    {
                        LiveRoomCode = roomId,
                        DeviceCode = cacheConsultationRecordDTO.DeviceCode
                    });
                    //从rtc中取 device信息返回给客户端
                    var req = new GetLiveMemberInfosRequest()
                    {
                        LiveRoomCode = roomId
                    };
                    var liveMemberList = await _rtcService.GetLiveMemberInfosAsync(req);
                    if (liveMemberList?.Count > 0)
                    {
                        result = liveMemberList.FirstOrDefault(c => c.Id == cacheConsultationRecordDTO.DeviceCode) ?? new LiveConsultationMember();
                        //同时转发给其他用户
                        var message = new HeartRateJoinConsultationNotification
                        {
                            ConsultationCode = roomId,
                            Joiner = new LiveConsultationJoinerInfo
                            {
                                Id = result.Id,
                                Name = result.Name,
                                HeadImageUrl = result.HeadImageToken,
                                Mute = result.Mute,
                                VideoOpend = result.VideoOpend,
                                SortLevel = result.SortLevel,
                                LiveData = result.LiveData,
                                IsOnline = result.IsOnline,
                                IsOldPlatform = deviceTokenInfo != null && deviceTokenInfo.IsOnline && deviceTokenInfo.IsOldPlatform,
                                ConsultationDeviceInfo = new LiveConsultationJoinDeviceInfo()
                                {
                                    MergedChannel = result.MergedChannel,
                                    MergedVideoOutputWidth = result.MergedVideoOutputWidth,
                                    MergedVideoOutputHeight = result.MergedVideoOutputHeight,
                                    VideoDeviceOutputList = result.VideoDeviceInfos,
                                    DeviceCode = cacheConsultationRecordDTO.DeviceCode,
                                    DeviceSign = "",
                                    IsOldPlatform = deviceTokenInfo != null && deviceTokenInfo.IsOnline && deviceTokenInfo.IsOldPlatform,
                                    LiveProtocol = EnvironmentConfigs.General.LiveProtocolDetail<TransactionStatusEnum>(),
                                }
                            }
                        };
                        var userInfos = liveMemberList.Where(c => c.MemberType == LiveMemberEnum.User && c.IsOnline == true);
                        if (userInfos?.Any() == true)
                        {
                            //开启独立队列
                            var openNotifyQueueRequest = new WingInterfaceLibrary.Request.Notification.OpenNotifyQueueRequest { Module = roomId };
                            var msgQueueId = await _notificationService.OpenNotifyQueueAsync(openNotifyQueueRequest);
                            var clientIds = userInfos.Select(x => x.Id).ToList();
                            var tokenInfos = CacheMaintenance.Instance.Get<ITokensManager>().Where(x => clientIds.Contains(x.ClientId));
                            if (tokenInfos != null && tokenInfos.Any())
                            {
                                Logger.WriteLineInfo($"DeviceJoinInLiveConsultationAsync PushMessage, roomId:{roomId}, type:{message.NotificationType.ToString()}, receivers:{string.Join(";", tokenInfos.Select(x => x.AccountName).Distinct())}");
                            }
                            var notificationRequest = new BroadcastNotificationRequest
                            {
                                MsgQueueId = msgQueueId,
                                ClientIds = clientIds,
                                Message = message,
                                JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(message),
                                NotificationType = message.NotificationType,
                                TransactionType = TransactionTypeEnum.Consultion,
                                RelevanceCode = roomId,
                                ReceiverType = ApplicantTypeEnum.Client,
                                WSConnectType = WSConnectTypeEnum.ConsultationSecondWindow,
                                IsNeedSyn = true
                            };
                            var res = await _notificationService.BroadcastMessageAsync(notificationRequest);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineInfo($"LiveConsultationService DeviceJoinInLiveConsultationAsync Error, roomId:{roomId}, ex:{ex}");
            }
            return result;
        }

        public async Task<bool> SyncBatchConsultationAsync(SyncBatchConsultationRequest syncBatchConsultationRequest)
        {
            await _consultationRecordDBService.SyncBatchConsultationDBAsync(syncBatchConsultationRequest);
            return true;
        }

        /// <summary>
        /// 查询会诊报告质控项枚举列表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<GetConsultationQualityTypeResult> GetConsultationReportQualityTypeAsync(GetConsultationReportQualityTypeRequest request)
        {

            var getConsultationQualityTypeResult = new GetConsultationQualityTypeResult();
            getConsultationQualityTypeResult.QualityTypeList = new List<QualityTypeDetail>();
            try
            {
                var jsonContent = WingServerCommon.ResourceManage.ResourceManager.GetSetting(request.Language + "consultation");
                if (string.IsNullOrWhiteSpace(jsonContent))
                {
                    jsonContent = WingServerCommon.ResourceManage.ResourceManager.GetSetting("en-US" + "consultation");
                }
                JObject json = JObject.Parse(jsonContent);
                foreach (QualityType qualityType in Enum.GetValues(typeof(QualityType)))
                {
                    string name = Enum.GetName(typeof(QualityType), qualityType);
                    int key = (int)qualityType;
                    if (key == 0)
                    {
                        continue;
                    }
                    QualityTypeDetail detail = new QualityTypeDetail();

                    detail.Key = key;
                    detail.Description = json["Language"][name]?.ToString();
                    getConsultationQualityTypeResult.QualityTypeList.Add(detail);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveConsultationService GetConsultationReportQualityTypeAsync，Language:{request.Language},error{ex.ToString()}");
            }
            return getConsultationQualityTypeResult;
        }

        /// <summary>
        /// 新增会诊报告质控
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> AddConsultationReportQualityAsync(AddConsultationReportQualityRequest request)
        {
            try
            {
                string consultationRecordCode = request.ConsultationRecordCode;
                string reportCode = request.ReportCode;
                int qualityTypeKey = request.QualityTypeKey;
                var findDBRequest = new GetReportByCodeDBRequest { ReportCode = request.ReportCode };
                var reportInfo = await _reportDBService.GetReportByCodeAsync(findDBRequest);
                if (reportInfo.QualityType != QualityType.None)
                {
                    //此报告已质控错误码
                    ThrowRpcException(CustomerRpcCode.ConsultationReportQualityControlled, "ConsultationReportQualityControlled");
                }
                var reportList = await _reportDBService.GetReportsByRecordCodesAsync(new List<string> { consultationRecordCode });
                if (reportList.Any(x => x.QualityType != QualityType.None))
                {
                    //该会诊有其他报告已做质控
                    ThrowRpcException(CustomerRpcCode.ConsultationOtherReportQualityControlled, "ConsultationOtherReportQualityControlled");
                }
                reportInfo.QualityType = (QualityType)qualityTypeKey;
                if (reportInfo.QualityType == QualityType.Qualified)
                {
                    reportInfo.QualifiedState = QualifiedState.Qualified;
                }
                else
                {
                    reportInfo.QualifiedState = QualifiedState.UnQualified;
                }
                //修改报告质控信息
                var saveReportQualityInfoDBRequest = new SaveReportQualityInfoDBRequest();
                saveReportQualityInfoDBRequest.ReportCode = reportInfo.ReportCode;
                saveReportQualityInfoDBRequest.QualifiedState = reportInfo.QualifiedState;
                saveReportQualityInfoDBRequest.QualityType = reportInfo.QualityType;
                await _reportDBService.SaveReportQualityInfoAsync(saveReportQualityInfoDBRequest);
                //修改会诊单质控信息
                var consultationRequest = new ConsultationRecordCodeDBRequest { Code = consultationRecordCode };
                var consultationRecord = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(consultationRequest);
                consultationRecord.QualifiedState = reportInfo.QualifiedState;
                consultationRecord.QualityType = reportInfo.QualityType;
                await _consultationRecordDBService.UpdateConsultationRecordAsync(consultationRecord);
                return true;
            }
            catch (RpcException rpcEx)
            {
                throw rpcEx;
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveConsultationService AddConsultationReportQualityAsync,ConsultationRecordCode:{request.ConsultationRecordCode},reportCode:{request.ReportCode},error:{ex.ToString()}");
                return false;
            }
        }

        /// <summary>
        /// 修改会诊报告质控
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> ModifyConsultationReportQualityAsync(ModifyConsultationReportQualityRequest request)
        {
            try
            {
                string consultationRecordCode = request.ConsultationRecordCode;
                string reportCode = request.ReportCode;
                int qualityTypeKey = request.QualityTypeKey;
                var findDBRequest = new GetReportByCodeDBRequest { ReportCode = request.ReportCode };
                var reportInfo = await _reportDBService.GetReportByCodeAsync(findDBRequest);
                if (reportInfo.QualityType == QualityType.None)
                {
                    //此报告还未做质控错误码
                    ThrowRpcException(CustomerRpcCode.ConsultationReportNotQualityControl, "ConsultationReportNotQualityControl");
                }
                reportInfo.QualityType = (QualityType)qualityTypeKey;
                if (reportInfo.QualityType == QualityType.Qualified)
                {
                    reportInfo.QualifiedState = QualifiedState.Qualified;
                }
                else
                {
                    reportInfo.QualifiedState = QualifiedState.UnQualified;
                }
                //修改报告质控信息
                var saveReportQualityInfoDBRequest = new SaveReportQualityInfoDBRequest();
                saveReportQualityInfoDBRequest.ReportCode = reportInfo.ReportCode;
                saveReportQualityInfoDBRequest.QualifiedState = reportInfo.QualifiedState;
                saveReportQualityInfoDBRequest.QualityType = reportInfo.QualityType;
                await _reportDBService.SaveReportQualityInfoAsync(saveReportQualityInfoDBRequest);
                //修改会诊单质控信息
                var consultationRequest = new ConsultationRecordCodeDBRequest { Code = consultationRecordCode };
                var consultationRecord = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(consultationRequest);
                consultationRecord.QualifiedState = reportInfo.QualifiedState;
                consultationRecord.QualityType = reportInfo.QualityType;
                await _consultationRecordDBService.UpdateConsultationRecordAsync(consultationRecord);
                return true;
            }
            catch (RpcException rpcEx)
            {
                throw rpcEx;
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveConsultationService ModifyConsultationReportQualityAsync,ConsultationRecordCode:{request.ConsultationRecordCode},reportCode:{request.ReportCode},error:{ex.ToString()}");
                return false;
            }
        }

        /// <summary>
        /// 删除会诊报告质控
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<bool> DeleteConsultationReportQualityAsync(DeleteConsultationReportQualityRequest request)
        {
            try
            {
                string consultationRecordCode = request.ConsultationRecordCode;
                string reportCode = request.ReportCode;
                var findDBRequest = new GetReportByCodeDBRequest { ReportCode = request.ReportCode };
                var reportInfo = await _reportDBService.GetReportByCodeAsync(findDBRequest);
                var reportList = await _reportDBService.GetReportsByRecordCodesAsync(new List<string> { consultationRecordCode });
                reportInfo.QualityType = QualityType.None;
                reportInfo.QualifiedState = QualifiedState.UnSet;
                //修改报告质控信息
                var saveReportQualityInfoDBRequest = new SaveReportQualityInfoDBRequest();
                saveReportQualityInfoDBRequest.ReportCode = reportInfo.ReportCode;
                saveReportQualityInfoDBRequest.QualifiedState = reportInfo.QualifiedState;
                saveReportQualityInfoDBRequest.QualityType = reportInfo.QualityType;
                await _reportDBService.SaveReportQualityInfoAsync(saveReportQualityInfoDBRequest);
                //修改会诊单质控信息
                var consultationRequest = new ConsultationRecordCodeDBRequest { Code = consultationRecordCode };
                var consultationRecord = await _consultationRecordDBService.FindConsultationRecordByCodeAsync(consultationRequest);
                consultationRecord.QualifiedState = reportInfo.QualifiedState;
                consultationRecord.QualityType = reportInfo.QualityType;
                await _consultationRecordDBService.UpdateConsultationRecordAsync(consultationRecord);
                return true;
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveConsultationService DeleteConsultationReportQualityAsync,ConsultationRecordCode:{request.ConsultationRecordCode},reportCode:{request.ReportCode},error:{ex.ToString()}");
                return false;
            }
        }
    }
}