WingLiveConsultationService/LiveConsultationRoom.cs

using WingInterfaceLibrary.LiveConsultation;
using WingInterfaceLibrary.Enum;
using WingInterfaceLibrary.Request.Notification;
using WingServerCommon.Config;
using WingInterfaceLibrary.Notifications;
using WingServerCommon.Interfaces.Cache;
using WingInterfaceLibrary.Rtc;
using WingServerCommon.Log;
using System.Text;
using WingInterfaceLibrary.DTO.User;
using WingInterfaceLibrary.LiveConsultation.Consultation;

namespace WingLiveConsultationService
{
    /// <summary>
    /// 会诊房间
    /// </summary>
    public partial class LiveConsultationRoom : LiveConsultationRoomDTO
    {
        public static Func<int, string, GenerateRoomUrlResult> OnRtcGenerateRoomUrl;
        public static Func<string, string> OnGetUserSign;

        public LiveConsultationRoom(string roomId, int roomNo, string patientName, DateTime consultationTime, TransactionStatusEnum consultationStatus
            , string applyOrganizationCode, string applyUserCode, string expertOrganizationCode, List<LiveConsultationMember> liveMembers, string expertUserCode, bool isEmergency) : base(roomId)
        {
            RoomId = roomId;
            RoomNo = roomNo;
            PatientName = patientName ?? string.Empty;
            ConsultationTime = consultationTime;
            ConsultationStatus = consultationStatus;
            ApplyOrganizationCode = applyOrganizationCode;
            ApplyUserCode = applyUserCode;
            ExpertOrganizationCode = expertOrganizationCode;
            Members = liveMembers ?? new List<LiveConsultationMember>();
            ExpertUserCode = expertUserCode;
            IsEmergency = isEmergency;
            InteractiveBoardDatas = new List<InteractiveBoardDataDTO>();
        }

        /// <summary>
        /// 修改预约记录状态
        /// </summary>
        /// <param name="status"></param>
        public void ChangeConsultationStatus(TransactionStatusEnum status)
        {
            WriteDebugLogs("ChangeConsultationStatus", null, $"{ConsultationStatus.ToString()}>>{status.ToString()}");
            ConsultationStatus = status;
        }

        /// <summary>
        /// 参与人员同意参加会诊
        /// </summary>
        /// <param name="userCode"></param>
        public void Agree(string userCode)
        {
            var liveMember = Members.FirstOrDefault(x => x.Id == userCode);
            if (liveMember != null)
            {
                liveMember.Status = LiveConsultationMemberStatus.Default;
            }
            else
            {
                liveMember = InitLiveMemberByCode(userCode);
                liveMember.Status = LiveConsultationMemberStatus.Default;
                Members.Add(liveMember);
            }
            WriteDebugLogs("Agree", liveMember);
        }

        /// <summary>
        /// 开始会诊
        /// </summary>
        /// <param name="initiatorCode"></param>
        /// <param name="integerRoomId"></param>
        /// <param name="timeout"></param>
        /// <param name="sdkAppId"></param>
        public void Initiate(string initiatorCode, int integerRoomId, int timeout, int sdkAppId, bool pushMessage = false)
        {
            var initiator = Members.FirstOrDefault(x => x.Id == initiatorCode);
            if (initiator != null)
            {
                initiator.IsInitiator = true;
                initiator.Status = LiveConsultationMemberStatus.Joined;
            }
            else
            {
                initiator = InitLiveMemberByCode(initiatorCode);
                initiator.IsInitiator = true;
                initiator.Status = LiveConsultationMemberStatus.Joined;
                Members.Add(initiator);
            }
            foreach (var liveMember in Members)
            {
                if (liveMember.Id != initiatorCode)
                {
                    liveMember.IsInitiator = false;
                    liveMember.Status = LiveConsultationMemberStatus.Default;
                }
                liveMember.Mute = false;
                liveMember.VideoOpend = true;
                liveMember.IsControllingParameter = false;
            }
            RoomNo = integerRoomId;
            ConsultationStatus = TransactionStatusEnum.InProgress;
            Status = LiveConsultationRoomStatus.Initiating;
            InteractiveBoardDatas = new List<InteractiveBoardDataDTO>();
            EmergencyAccepted = false;
            RefreshMemberInfosByToken();
            //StartCheckConnectionTimeout(timeout);
            if (pushMessage)
            {
                PushInitiateMessage(sdkAppId);
            }
            WriteDebugLogs("Initiate", initiator);
        }

        /// <summary>
        /// 接受会诊邀请-参与人员
        /// </summary>
        /// <param name="userCode"></param>
        public void Accept(string userCode, bool pushMessage = false)
        {
            var accepter = Members.FirstOrDefault(x => x.Id == userCode);
            if (accepter != null)
            {
                accepter.Status = LiveConsultationMemberStatus.Accepted;
                accepter.Mute = false;
                accepter.IsControllingParameter = false;
                accepter.VideoOpend = true;
                RemoveInteractiveBoardDatasByUserCode(userCode);
                if (Status == LiveConsultationRoomStatus.Connected)
                {
                    Status = LiveConsultationRoomStatus.Initiating;
                }
                if (pushMessage)
                {
                    PushCancelInviteInMessage(new List<string> { accepter.Id }, true);//取消其他端的呼叫行为
                    PushAcceptMessage(accepter);
                }
            }
            WriteDebugLogs("Accept", accepter);
        }

        /// <summary>
        /// 接受会诊邀请-急诊专家
        /// </summary>
        /// <param name="userCode"></param>
        /// <param name="orgCode"></param>
        /// <param name="pushMessage"></param>
        public void EmergencyAccept(string userCode, string orgCode, bool pushMessage = false)
        {
            EmergencyAccepted = true;
            var accepter = Members.FirstOrDefault(x => x.Id == userCode);
            if (accepter == null)
            {
                accepter = InitLiveMemberByCode(userCode);
                accepter.Status = LiveConsultationMemberStatus.Accepted;
                Members.Add(accepter);
                //急诊专家信息
                ExpertUserCode = userCode;
                ExpertOrganizationCode = orgCode;
            }
            accepter.Status = LiveConsultationMemberStatus.Accepted;
            accepter.Mute = false;
            accepter.VideoOpend = true;
            accepter.IsControllingParameter = false;
            if (Status == LiveConsultationRoomStatus.Connected)
            {
                Status = LiveConsultationRoomStatus.Initiating;
            }
            if (pushMessage)
            {
                PushAcceptMessage(accepter);
            }
            WriteDebugLogs("EmergencyAccept", accepter);
        }

        /// <summary>
        /// 拒绝会诊邀请-参与人员
        /// </summary>
        /// <param name="userCode"></param>
        public void Reject(string userCode, bool pushMessage = false)
        {
            var rejecter = Members.FirstOrDefault(x => x.Id == userCode);
            if (rejecter != null)
            {
                rejecter.Status = LiveConsultationMemberStatus.Rejected;
                if (pushMessage)
                {
                    PushCancelInviteInMessage(new List<string> { rejecter.Id }, true);//取消其他端的呼叫行为
                    PushRejectMessage(rejecter);
                }
            }
            WriteDebugLogs("Reject", rejecter);
        }

        /// <summary>
        /// 取消会诊
        /// </summary>
        public void CancelInitiate(bool pushMessage = false)
        {
            Status = LiveConsultationRoomStatus.Cancelled;
            ConsultationStatus = TransactionStatusEnum.ToStart;
            if (pushMessage)
            {
                PushCancelMessage();
                PushCloseMessage();
            }
            foreach (var liveMember in Members)
            {
                if (liveMember.Status == LiveConsultationMemberStatus.Joined)
                {
                    liveMember.Status = LiveConsultationMemberStatus.Left;
                }
            }
            WriteDebugLogs("CancelInitiate", Initiator);
        }

        /// <summary>
        /// 会诊心跳，进入房间
        /// </summary>
        /// <param name="userCode"></param>
        public void HeartRateJoin(string userCode, bool pushMessage = false)
        {
            var joiner = Members.FirstOrDefault(x => x.Id == userCode);
            if (joiner != null && joiner.Status != LiveConsultationMemberStatus.Joined)
            {
                joiner.Status = LiveConsultationMemberStatus.Joined;
                if (pushMessage)
                {
                    PushHeartRateJoinMessage(joiner);
                }
            }
            WriteDebugLogs("HeartRateJoin", joiner);
        }

        /// <summary>
        /// 会诊心跳，网络质量不佳
        /// </summary>
        /// <param name="userCode"></param>
        public void NetworkErr(string userCode, bool pushMessage = false)
        {
            var liveMember = Members.FirstOrDefault(x => x.Id == userCode);
            if (liveMember != null && liveMember.Status == LiveConsultationMemberStatus.Joined)
            {
                if (pushMessage)
                {
                    PushNetworkErrMessage(liveMember);
                }
            }
            WriteDebugLogs("NetworkErr", liveMember);
        }

        /// <summary>
        /// 会诊心跳，离开房间
        /// </summary>
        /// <param name="userCode"></param>
        public bool HeartRateLeave(string userCode, bool pushMessage = false)
        {
            var leaver = Members.FirstOrDefault(x => x.Id == userCode);
            var needClose = false;
            if (leaver != null && leaver.Status == LiveConsultationMemberStatus.Joined)
            {
                leaver.Status = LiveConsultationMemberStatus.Left;
                if (pushMessage)
                {
                    PushHeartRateLeaveMessage(leaver);
                }
                if (MainUserInfos == null || MainUserInfos.All(x => x.Status != LiveConsultationMemberStatus.Joined))
                {
                    Close(pushMessage);
                    needClose = true;
                }
            }
            WriteDebugLogs("HeartRateLeave", leaver);
            return needClose;
        }

        /// <summary>
        /// 离开房间，含结束会诊
        /// </summary>
        /// <param name="userCode"></param>
        public bool Leave(string userCode, bool pushMessage = false)
        {
            var leaver = Members.FirstOrDefault(x => x.Id == userCode);
            var needClose = false;
            if (leaver != null && leaver.Status == LiveConsultationMemberStatus.Joined)
            {
                leaver.Status = LiveConsultationMemberStatus.Left;
                leaver.Mute = false;
                leaver.IsControllingParameter = false;
                leaver.VideoOpend = true;
                RemoveInteractiveBoardDatasByUserCode(userCode);
                if (pushMessage)
                {
                    PushLeaveMessage(leaver);
                }
                if (MainUserInfos == null || MainUserInfos.All(x => x.Status != LiveConsultationMemberStatus.Joined))
                {
                    Close(pushMessage);
                    needClose = true;
                }
            }
            WriteDebugLogs("Leave", leaver, $"close:{needClose.ToString()}");
            return needClose;
        }

        /// <summary>
        /// 结束会诊
        /// </summary>
        public void Close(bool pushMessage = false)
        {
            Status = LiveConsultationRoomStatus.Closed;
            ConsultationStatus = TransactionStatusEnum.PendingReport;
            if (pushMessage)
            {
                PushCancelMessage();
                PushCloseMessage();
            }
            foreach (var liveMember in Members)
            {
                if (liveMember.Status == LiveConsultationMemberStatus.Joined)
                {
                    liveMember.Status = LiveConsultationMemberStatus.Left;
                }
            }
            InteractiveBoardDatas = new List<InteractiveBoardDataDTO>();
            WriteDebugLogs("Close");
        }

        /// <summary>
        /// 开启关闭静音
        /// </summary>
        /// <param name="userCode"></param>
        /// <param name="mute"></param>
        public void ChangeMuteState(string userCode, bool mute, bool pushMessage = false)
        {
            var liveMember = Members.FirstOrDefault(x => x.Id == userCode);
            if (liveMember != null && liveMember.Status == LiveConsultationMemberStatus.Joined)
            {
                liveMember.Mute = mute;
                if (pushMessage)
                {
                    PushMuteStateMessage(liveMember);
                }
            }
            WriteDebugLogs("ChangeMuteState", liveMember, $"mute:{mute.ToString()}");
        }

        /// <summary>
        /// 开启关闭视频
        /// </summary>
        /// <param name="userCode"></param>
        /// <param name="isVideoOpen"></param>
        public void ChangeVideoOpenState(string userCode, bool isVideoOpen, bool pushMessage = false)
        {
            var liveMember = Members.FirstOrDefault(x => x.Id == userCode);
            if (liveMember != null && liveMember.Status == LiveConsultationMemberStatus.Joined)
            {
                liveMember.VideoOpend = isVideoOpen;
                if (pushMessage)
                {
                    PushVideoOpenStateMessage(liveMember);
                }
            }
            WriteDebugLogs("ChangeVideoOpenState", liveMember, $"isVideoOpen:{isVideoOpen.ToString()}");
        }
        /// <summary>
        /// 更改调参状态
        /// </summary>
        /// <param name="userCode"></param>
        /// <param name="isVideoOpen"></param>
        public void ChangeControllingParameterState(string userCode, bool isControllingParameter)
        {
            var liveMember = Members.FirstOrDefault(x => x.Id == userCode);
            if (liveMember != null && liveMember.Status == LiveConsultationMemberStatus.Joined)
            {
                liveMember.IsControllingParameter = isControllingParameter;
            }
            WriteDebugLogs("ChangeControllingParameterState", liveMember, $"isControllingParameter:{isControllingParameter.ToString()}");
        }

        /// <summary>
        /// 会诊中邀请
        /// </summary>
        /// <param name="userCode"></param>
        /// <param name="clientIds"></param>
        public void InviteIn(string userCode, List<string> clientIds, bool pushMessage = false)
        {
            var liveMember = Members.FirstOrDefault(x => x.Id == userCode);
            if (liveMember != null && liveMember.Status == LiveConsultationMemberStatus.Joined)
            {
                if (pushMessage)
                {
                    PushInviteInMessage(liveMember, clientIds);
                }
            }
            WriteDebugLogs("InviteIn", liveMember);
        }

        /// <summary>
        /// 取消会诊中邀请
        /// </summary>
        /// <param name="userCode"></param>
        /// <param name="clientIds"></param>
        public void CancelInviteIn(string userCode, List<string> clientIds, bool pushMessage = false)
        {
            var liveMember = Members.FirstOrDefault(x => x.Id == userCode);
            if (liveMember != null && liveMember.Status == LiveConsultationMemberStatus.Joined)
            {
                var notifyUserCodes = new List<string>();
                foreach (var clientId in clientIds)
                {
                    if (Members.Any(x => x.Id == clientId && x.Status == LiveConsultationMemberStatus.Joined))
                    {
                        continue;
                    }
                    notifyUserCodes.Add(clientId);
                }
                if (notifyUserCodes.Any())
                {
                    if (pushMessage)
                    {
                        PushCancelInviteInMessage(notifyUserCodes);
                    }
                }
            }
            WriteDebugLogs("CancelInviteIn", liveMember);
        }

        /// <summary>
        /// 接受会诊中邀请
        /// </summary>
        /// <param name="userCode"></param>
        public void AcceptIn(string userCode, bool pushMessage = false)
        {
            var liveMember = Members.FirstOrDefault(x => x.Id == userCode);
            if (liveMember != null)
            {
                liveMember.Status = LiveConsultationMemberStatus.Accepted;
                liveMember.Mute = false;
                liveMember.IsControllingParameter = false;
                liveMember.VideoOpend = true;
            }
            else
            {
                liveMember = InitLiveMemberByCode(userCode);
                liveMember.Status = LiveConsultationMemberStatus.Accepted;
                liveMember.Mute = false;
                liveMember.IsControllingParameter = false;
                liveMember.VideoOpend = true;
                Members.Add(liveMember);
            }
            RemoveInteractiveBoardDatasByUserCode(userCode);
            if (pushMessage)
            {
                PushCancelInviteInMessage(new List<string> { liveMember.Id }, true);//取消其他端的呼叫行为
                PushAcceptInMessage(liveMember);
            }
            WriteDebugLogs("AcceptIn", liveMember);
        }

        /// <summary>
        /// 拒绝会诊中邀请
        /// </summary>
        /// <param name="rejecterCode"></param>
        public void RejectIn(string rejecterCode, bool pushMessage = false)
        {
            if (Initiator != null && Initiator.Status == LiveConsultationMemberStatus.Joined)
            {
                var userInfo = CacheMaintenance.Instance.Get<IUserInfoManager>().Get(rejecterCode);
                WriteDebugLogs("RejectIn", Initiator, $"rejecter name:{userInfo.UserName};{userInfo.FullName}");
                if (pushMessage)
                {
                    PushCancelInviteInMessage(new List<string> { userInfo.Code }, true);//取消其他端的呼叫行为
                    PushRejectInMessage(Initiator, userInfo);
                }
            }
            else
            {
                WriteDebugLogs("RejectIn", Initiator);
            }
        }

        /// <summary>
        /// 发送白板交互数据
        /// </summary>
        /// <param name="userCode"></param>
        /// <param name="boardData"></param>
        /// <param name="isClear"></param>
        public void SendBoardData(string userCode, string boardData, DateTime interactiveTime, bool isClear, bool pushMessage = false)
        {
            var liveMember = Members.FirstOrDefault(x => x.Id == userCode);
            if (liveMember != null && liveMember.Status == LiveConsultationMemberStatus.Joined)
            {
                if (!isClear)
                {
                    InteractiveBoardDatas.Add(new InteractiveBoardDataDTO
                    {
                        InteractiveTime = interactiveTime,
                        UserCode = userCode,
                        BoardData = boardData,
                    });
                }
                else
                {
                    RemoveInteractiveBoardDatasByUserCode(userCode);
                }
                if (pushMessage)
                {
                    PushBoardDataMessage(liveMember, boardData, isClear);
                }
            }
            WriteDebugLogs("SendBoardData", liveMember);
        }

        /// <summary>
        /// 呼叫急诊专家
        /// </summary>
        /// <param name="doctor"></param>
        /// <param name="timeOut"></param>
        public void CallEmergencyDoctor(UserDTO doctor, int timeOut)
        {
            if (!EmergencyAccepted)
            {
                PushEmergencyMessage(doctor, timeOut);
            }
        }

        /// <summary>
        /// 急诊呼叫失败
        /// </summary>
        public void EmergencyFailed()
        {
            if (!EmergencyAccepted)
            {
                PushEmergencyFailedMessage();
            }
        }

        /// <summary>
        /// 切换会诊房间
        /// </summary>
        /// <param name="userCode"></param>
        /// <param name="current"></param>
        /// <param name="timeout"></param>
        /// <param name="sdkAppId"></param>
        /// <returns></returns>
        public void ChangeRoom(string userCode, LiveConsultationRoom current, int timeout, int sdkAppId)
        {
            current.Initiate(Initiator.Id, RoomNo, timeout, sdkAppId, false);
            var closeMemberCodes = new List<string>();
            foreach (var origMember in Members)
            {
                if (origMember.Status != LiveConsultationMemberStatus.Joined)
                {
                    continue;
                }
                var liveMember = current.Members.FirstOrDefault(x => x.Id == origMember.Id);
                if (liveMember != null)
                {
                    liveMember.Status = LiveConsultationMemberStatus.Accepted;
                    liveMember.Mute = origMember.Mute;
                    liveMember.VideoOpend = origMember.VideoOpend;
                    liveMember.IsControllingParameter = origMember.IsControllingParameter;
                }
                else
                {
                    closeMemberCodes.Add(origMember.Id);
                }
            }
            PushCloseDueToChangeMessage(closeMemberCodes);
            PushChangeRoomMessage(userCode, current);
            Close(false);
        }

        private void StartCheckConnectionTimeout(int timeout)
        {
            Task.Run(async () =>
            {
                Status = LiveConsultationRoomStatus.Initiating;
                await Task.Delay(timeout * 1000);
                if (Status != LiveConsultationRoomStatus.Connected)
                {
                    Status = LiveConsultationRoomStatus.ConnectionTimeout;
                }
            });
        }

        public LiveConsultationMember InitLiveMemberByCode(string userCode)
        {
            var user = CacheMaintenance.Instance.Get<IUserInfoManager>().Get(userCode);
            var userName = !string.IsNullOrWhiteSpace(user.FullName) ? user.FullName : user.UserName;
            var liveMember = new LiveConsultationMember
            {
                Id = userCode,
                MemberType = LiveMemberEnum.User,
                Name = userName,
                HeadImageToken = user.HeadImageToken,
                IsInitiator = false,
                Status = LiveConsultationMemberStatus.Default,
                //LiveData = liveData,
            };
            var userToken = CacheMaintenance.Instance.Get<ITokensManager>().Where(t => t.ClientId == userCode)?.OrderByDescending(x => x.IsOnline)?.FirstOrDefault();
            if (userToken != null)
            {
                var loginSource = (LoginSource)userToken.LoginSource;
                liveMember.LoginServerUrl = userToken.LoginServer;
                liveMember.LoginSource = (LoginSource)userToken.LoginSource;
                liveMember.IsOnline = userToken.IsOnline;
                liveMember.IsBusy = false;
            }
            return liveMember;
        }

        private void RefreshMemberInfosByToken(string liveMemberId = "")
        {
            var tokenManager = CacheMaintenance.Instance.Get<ITokensManager>();
            foreach (var liveMember in Members)
            {
                var id = liveMember.Id;
                if (!string.IsNullOrWhiteSpace(liveMemberId) && id != liveMemberId)
                {
                    continue;
                }
                var userToken = tokenManager.Where(t => t.ClientId == id)?.OrderByDescending(x => x.IsOnline)?.FirstOrDefault();
                if (userToken != null)
                {
                    var loginSource = (LoginSource)userToken.LoginSource;
                    liveMember.LoginServerUrl = userToken.LoginServer;
                    liveMember.LoginSource = (LoginSource)userToken.LoginSource;
                    liveMember.IsOnline = userToken.IsOnline;
                }
                var agenerateRoomUrlResult = OnRtcGenerateRoomUrl.Invoke(RoomNo, id);
                liveMember.LiveData = new LiveData
                {
                    RtmpPullUrl = agenerateRoomUrlResult.RtmpUrl,
                    HlsPullUrl = agenerateRoomUrlResult.HlsUrl,
                    HttpPullUrl = agenerateRoomUrlResult.FlvUrl,
                };
            }
        }

        private void WriteDebugLogs(string actionName, LiveConsultationMember liveMember = null, string log = "")
        {
            var logs = new StringBuilder();
            logs.AppendLine($"LiveConsultationRoom action:{actionName}, patientName:{PatientName}, roomId:{RoomId}, room status:{Status.ToString()}");
            if (liveMember != null)
            {
                logs.AppendLine($"user:{liveMember.Name}, status:{liveMember.Status.ToString()}");
            }
            else
            {
                logs.AppendLine($"user:not existed");
            }
            logs.AppendLine($"log:{log}");
            Logger.WriteLineInfo($"{logs.ToString()}");
        }

        /// <summary>
        /// 清除白板数据
        /// </summary>
        /// <param name="userCode"></param>
        private void RemoveInteractiveBoardDatasByUserCode(string userCode)
        {
            InteractiveBoardDatas = InteractiveBoardDatas.Where(x => x.UserCode != userCode)?.ToList() ?? new List<InteractiveBoardDataDTO>();
        }

    }

    public class LiveConsultationRoomDTO
    {
        public LiveConsultationRoomDTO(string roomId)
        {
            RoomId = roomId;
        }

        /// <summary>
        /// The consultation unique id
        /// </summary>
        /// <value></value>
        public string RoomId { get; set; }

        /// <summary>
        /// The diagnosis room No
        /// </summary>
        /// <value></value>
        public int RoomNo { get; set; }

        public string MsgQueueId { get; set; }

        public IList<LiveConsultationMember> Members { get; set; } = new List<LiveConsultationMember>();

        public LiveConsultationMember Initiator
        {
            get
            {
                return Members.FirstOrDefault(x => x.IsInitiator);
            }
        }
        public IEnumerable<LiveConsultationMember> UserInfos
        {
            get
            {
                return Members.Where(x => x.MemberType == LiveMemberEnum.User);
            }
        }
        public IEnumerable<LiveConsultationMember> DeviceInfos
        {
            get
            {
                return Members.Where(x => x.MemberType == LiveMemberEnum.Device);
            }
        }
        public IEnumerable<LiveConsultationMember> MainUserInfos
        {
            get
            {
                return Members.Where(x => x.IsInitiator || x.Id == ApplyUserCode || x.Id == ExpertUserCode);
            }
        }

        /// <summary>
        /// The diagnosis room status
        /// </summary>
        /// <value></value>
        public LiveConsultationRoomStatus Status { get; set; }

        /// <summary>
        /// 病人名称
        /// </summary>
        public string PatientName { get; set; }

        /// <summary>
        /// 会诊时间
        /// </summary>
        public DateTime ConsultationTime { get; set; }

        /// <summary>
        /// 会诊状态
        /// </summary>
        public TransactionStatusEnum ConsultationStatus { get; set; }

        /// <summary>
        /// 申请机构编码
        /// </summary>
        public string ApplyOrganizationCode { get; set; }

        /// <summary>
        /// 申请医师编码
        /// </summary>
        public string ApplyUserCode { get; set; }

        /// <summary>
        /// 会诊机构编码
        /// </summary>
        public string ExpertOrganizationCode { get; set; }

        /// <summary>
        /// 会诊专家编码
        /// </summary>
        public string ExpertUserCode { get; set; }

        /// <summary>
        /// 是否急诊标识
        /// </summary>
        /// <value></value>
        public bool IsEmergency { get; set; }

        /// <summary>
        /// 急诊已接通
        /// </summary>
        /// <value></value>
        public bool EmergencyAccepted { get; set; }

        /// <summary>
        /// 白板数据集合
        /// </summary>
        /// <typeparam name="InteractiveBoardDataDTO"></typeparam>
        /// <returns></returns>
        public IList<InteractiveBoardDataDTO> InteractiveBoardDatas { get; set; } = new List<InteractiveBoardDataDTO>();
    }


}