WingLiveConsultationService/LiveConsultationRoom.PushMessage.cs

using WingInterfaceLibrary.LiveConsultation;
using WingInterfaceLibrary.Enum;
using WingInterfaceLibrary.Request.Notification;
using WingServerCommon.Config;
using WingInterfaceLibrary.Notifications;
using WingServerCommon.Interfaces.Cache;
using WingInterfaceLibrary.Internal.Request;
using WingInterfaceLibrary.LiveConsultation.Consultation;
using WingInterfaceLibrary.DTO.User;
using WingServerCommon.Log;
using WingInterfaceLibrary.Enum.NotificationEnum;

namespace WingLiveConsultationService
{
    /// <summary>
    /// 会诊房间
    /// </summary>
    public partial class LiveConsultationRoom
    {
        public static Func<string, string> OnOpenNotifyQueue;

        public static Func<BroadcastNotificationRequest, bool> OnBroadcastMessage;

        public bool PushMessage(IEnumerable<LiveConsultationMember> clients, NotificationDTO message)
        {
            if (clients?.Any() == true)
            {
                if (string.IsNullOrWhiteSpace(MsgQueueId))
                {
                    MsgQueueId = OnOpenNotifyQueue.Invoke(RoomId);
                }
                var notificationRequest = new BroadcastNotificationRequest
                {
                    MsgQueueId = MsgQueueId,
                    ClientIds = clients.Select(x => x.Id).ToList(),
                    Message = message,
                    JsonMessage = Newtonsoft.Json.JsonConvert.SerializeObject(message),
                    NotificationType = message.NotificationType,
                    TransactionType = TransactionTypeEnum.Consultion,
                    RelevanceCode = RoomId,
                    ReceiverType = ApplicantTypeEnum.Client,
                    WSConnectType = WSConnectTypeEnum.ConsultationSecondWindow
                };
                WriteDebugLogs("PushMessage", log: $"notification type:{message.NotificationType.ToString()}, login clients:{string.Join(";", clients.Select(x => x.Name))}");
                return OnBroadcastMessage.Invoke(notificationRequest);
            }
            else
            {
                WriteDebugLogs("PushMessage", log: $"notification type:{message.NotificationType.ToString()}, login clients is empty");
            }
            return false;
        }

        private void PushInitiateMessage(int sdkAppId)
        {
            var userInfos = UserInfos?.Where(x => !x.IsInitiator && !x.IsBusy);
            if (userInfos?.Any() == true)
            {
                var message = new InviteLiveConsultationNotification
                {
                    ConsultationCode = RoomId,
                    RoomNo = RoomNo,
                    Initiator = Initiator,
                    IsResponse = true,
                };
                PushMessage(userInfos, message);
            }
            if (DeviceInfos != null && DeviceInfos.Any())
            {
                foreach (var device in DeviceInfos)
                {
                    var deviceCode = device.Id;
                    // var deviceSign = OnGetUserSign.Invoke(deviceCode);
                    // var message = new InviteLiveConsultationToDeviceNotification
                    // {
                    //     ConsultationCode = RoomId,
                    //     RoomNo = RoomNo,
                    //     MergedChannel = device.MergedChannel,
                    //     MergedVideoOutputWidth = device.MergedVideoOutputWidth,
                    //     MergedVideoOutputHeight = device.MergedVideoOutputHeight,
                    //     VideoDeviceOutputList = device.VideoDeviceInfos,
                    //     DeviceCode = deviceCode,
                    //     UserSign = deviceSign,
                    //     AppId = sdkAppId,
                    // };
                    // PushMessage(new List<LiveConsultationMember> { device }, message);
                }
            }
        }

        private void PushAcceptMessage(LiveConsultationMember accepter)
        {
            var userInfos = Members.Where(x => x.Id == Initiator?.Id);
            if (userInfos?.Any() == true)
            {
                var accepterInfo = new LiveConsultatioAccepterInfo
                {
                    Id = accepter.Id,
                    Name = accepter.Name,
                    HeadImageUrl = accepter.HeadImageToken,
                    IsOnline = accepter.IsOnline,
                    Mute = accepter.Mute,
                    LoginSource = accepter.LoginSource,
                    LiveData = accepter.LiveData
                };
                var message = new AcceptLiveConsultationNotification
                {
                    ConsultationCode = RoomId,
                    Accepter = accepterInfo
                };
                PushMessage(userInfos, message);
            }
        }

        private void PushRejectMessage(LiveConsultationMember rejecter)
        {
            var userInfos = Members.Where(x => x.Id == Initiator?.Id);
            if (userInfos?.Any() == true)
            {
                var rejecterInfo = new LiveConsultationRejecterInfo
                {
                    Id = rejecter.Id,
                    Name = rejecter.Name,
                    HeadImageUrl = rejecter.HeadImageToken,
                };
                var message = new RejectLiveConsultationNotification
                {
                    ConsultationCode = RoomId,
                    Rejecter = rejecterInfo
                };
                PushMessage(userInfos, message);
            }
        }

        private void PushHeartRateJoinMessage(LiveConsultationMember joiner)
        {
            var userInfos = Members.Where(x => x.Id != joiner.Id && x.MemberType == LiveMemberEnum.User && x.Status == LiveConsultationMemberStatus.Joined);
            if (userInfos?.Any() == true)
            {
                var joinerInfo = new LiveConsultationJoinerInfo
                {
                    Id = joiner.Id,
                    Name = joiner.Name,
                    HeadImageUrl = joiner.HeadImageToken,
                    IsOnline = joiner.IsOnline,
                    Mute = joiner.Mute,
                    LoginSource = joiner.LoginSource,
                    LiveData = joiner.LiveData
                };
                var message = new HeartRateJoinConsultationNotification
                {
                    ConsultationCode = RoomId,
                    Joiner = joinerInfo
                };
                PushMessage(userInfos, message);
            }
        }

        private void PushNetworkErrMessage(LiveConsultationMember liveMember)
        {
            var userInfos = Members.Where(x => x.Id != liveMember.Id && x.MemberType == LiveMemberEnum.User && x.Status == LiveConsultationMemberStatus.Joined);
            if (userInfos?.Any() == true)
            {
                var joinerInfo = new LiveConsultationNetworkErrMemberInfo
                {
                    Id = liveMember.Id,
                    Name = liveMember.Name,
                    HeadImageUrl = liveMember.HeadImageToken,
                };
                var message = new NetworkErrConsultationNotification
                {
                    ConsultationCode = RoomId,
                    NetworkErrMemberInfo = joinerInfo
                };
                PushMessage(userInfos, message);
            }
        }

        private void PushHeartRateLeaveMessage(LiveConsultationMember leaver)
        {
            var userInfos = Members.Where(x => x.Id != leaver.Id && x.MemberType == LiveMemberEnum.User && x.Status == LiveConsultationMemberStatus.Joined);
            if (userInfos?.Any() == true)
            {
                var leaverInfo = new LiveConsultationLeaverInfo
                {
                    Id = leaver.Id,
                    Name = leaver.Name,
                    HeadImageUrl = leaver.HeadImageToken,
                };
                var message = new HeartRateLeaveConsultationNotification
                {
                    ConsultationCode = RoomId,
                    LeaverInfo = leaverInfo
                };
                PushMessage(userInfos, message);
            }
        }

        private void PushLeaveMessage(LiveConsultationMember leaver)
        {
            var userInfos = Members.Where(x => x.Id != leaver.Id && x.MemberType == LiveMemberEnum.User && x.Status == LiveConsultationMemberStatus.Joined);
            if (userInfos?.Any() == true)
            {
                var leaverInfo = new LiveConsultationLeaverInfo
                {
                    Id = leaver.Id,
                    Name = leaver.Name,
                    HeadImageUrl = leaver.HeadImageToken,
                };
                var message = new LeaveLiveConsultationNotification
                {
                    ConsultationCode = RoomId,
                    LeaverInfo = leaverInfo
                };
                PushMessage(userInfos, message);
            }
        }

        private void PushCloseMessage()
        {
            var userInfos = UserInfos?.Where(v => v.Status == LiveConsultationMemberStatus.Accepted || v.Status == LiveConsultationMemberStatus.Joined);
            if (userInfos?.Any() == true)
            {
                var message = new CloseLiveConsultationNotification
                {
                    ConsultationCode = RoomId,
                    InitiatorCode = Initiator?.Id
                };
                PushMessage(userInfos, message);
            }
            var deviceInfos = DeviceInfos?.Where(v => v.Status == LiveConsultationMemberStatus.Accepted || v.Status == LiveConsultationMemberStatus.Joined);
            if (deviceInfos?.Any() == true)
            {
                // var message = new CloseLiveConsultationToDeviceNotification
                // {
                //     ConsultationCode = RoomId,
                //     InitiatorCode = Initiator?.Id
                // };
                // PushMessage(deviceInfos, message);
            }
        }

        private void PushCloseDueToChangeMessage(List<string> closeMemberInfos)
        {
            var userInfos = UserInfos?.Where(x => closeMemberInfos.Contains(x.Id))?.Where(v => v.Status == LiveConsultationMemberStatus.Accepted || v.Status == LiveConsultationMemberStatus.Joined);
            if (userInfos?.Any() == true)
            {
                var message = new CloseConsultationDueToChangeNotification
                {
                    ConsultationCode = RoomId
                };
                PushMessage(userInfos, message);
            }
            var deviceInfos = DeviceInfos?.Where(x => closeMemberInfos.Contains(x.Id))?.Where(v => v.Status == LiveConsultationMemberStatus.Accepted || v.Status == LiveConsultationMemberStatus.Joined);
            if (deviceInfos?.Any() == true)
            {
                // var message = new CloseConsultationDueToChangeToDeviceNotification
                // {
                //     ConsultationCode = RoomId
                // };
                // PushMessage(deviceInfos, message);
            }
        }

        private void PushCancelMessage()
        {
            var userInfos = UserInfos?.Where(v => v.Status == LiveConsultationMemberStatus.Default);
            if (userInfos?.Any() == true)
            {
                var message = new CancelLiveConsultationNotification
                {
                    ConsultationCode = RoomId,
                    InitiatorCode = Initiator?.Id
                };
                PushMessage(userInfos, message);
            }
            var deviceInfos = DeviceInfos?.Where(v => v.Status == LiveConsultationMemberStatus.Default);
            if (deviceInfos?.Any() == true)
            {
                // var message = new CancelLiveConsultationToDeviceNotification
                // {
                //     ConsultationCode = RoomId,
                //     InitiatorCode = Initiator?.Id
                // };
                // PushMessage(deviceInfos, message);
            }
        }

        private void PushMuteStateMessage(LiveConsultationMember liveMember)
        {
            var userInfos = Members.Where(x => x.Id != liveMember.Id && x.MemberType == LiveMemberEnum.User && x.Status == LiveConsultationMemberStatus.Joined);
            if (userInfos?.Any() == true)
            {
                var muterInfo = new LiveConsultationMuterInfo
                {
                    Id = liveMember.Id,
                    Name = liveMember.Name,
                };
                var message = new MuteLiveConsultationNotification
                {
                    ConsultationCode = RoomId,
                    MuterInfo = muterInfo,
                    Mute = liveMember.Mute
                };
                PushMessage(userInfos, message);
            }
        }

        private void PushVideoOpenStateMessage(LiveConsultationMember liveMember)
        {
            var userInfos = Members.Where(x => x.Id != liveMember.Id && x.MemberType == LiveMemberEnum.User && x.Status == LiveConsultationMemberStatus.Joined);
            if (userInfos?.Any() == true)
            {
                var switcherInfo = new LiveConsultationSwitcherInfo
                {
                    Id = liveMember.Id,
                    Name = liveMember.Name,
                };
                var message = new SwitchLiveConsultationVideoNotification
                {
                    ConsultationCode = RoomId,
                    Opened = liveMember.VideoOpend,
                    SwitcherInfo = switcherInfo
                };
                PushMessage(userInfos, message);
            }
        }

        private void PushInviteInMessage(LiveConsultationMember liveMember, List<string> clientIds)
        {
            var userTokens = CacheMaintenance.Instance.Get<ITokensManager>().Where(x => clientIds.Contains(x.ClientId));
            if (userTokens?.Any() == true)
            {
                var userInfos = userTokens.GroupBy(x => new { x.ClientId }).Select(x =>
                {
                    var loginServerUrl = x.OrderByDescending(x => x.IsOnline).FirstOrDefault().LoginServer;
                    return new LiveConsultationMember
                    {
                        Id = x.Key.ClientId,
                        LoginServerUrl = loginServerUrl
                    };
                });
                var message = new InviteInLiveConsultationNotification
                {
                    ConsultationCode = RoomId,
                    RoomNo = RoomNo,
                    Operator = liveMember,
                    MemberLiveDatas = Members,
                    IsResponse = true,
                };
                PushMessage(userInfos, message);
            }
        }

        private void PushCancelInviteInMessage(List<string> clientIds, bool exceptCurrent = false)
        {
            var userTokens = CacheMaintenance.Instance.Get<ITokensManager>().Where(x => clientIds.Contains(x.ClientId));
            if (userTokens?.Any() == true)
            {
                var userInfos = new List<LiveConsultationMember>();
                foreach (var clientId in clientIds)
                {
                    var clientTokens = userTokens.Where(x => x.ClientId == clientId)?.OrderByDescending(x => x.LoginServer == ConfigurationManager.Host);
                    if (clientTokens != null && clientTokens.Any() && (!exceptCurrent || clientTokens.Count() > 1))
                    {
                        userInfos.Add(new LiveConsultationMember
                        {
                            Id = clientId,
                            LoginServerUrl = clientTokens.FirstOrDefault()?.LoginServer
                        });
                    }
                }
                if (userTokens.Any())
                {
                    var message = new CancelInvitingInLiveConsultationNotification
                    {
                        ConsultationCode = RoomId
                    };
                    PushMessage(userInfos, message);
                }
            }
        }

        private void PushAcceptInMessage(LiveConsultationMember liveMember)
        {
            var userInfos = Members.Where(x => x.Id != liveMember.Id && x.MemberType == LiveMemberEnum.User && x.Status == LiveConsultationMemberStatus.Joined);
            if (userInfos?.Any() == true)
            {
                var joinerInfo = new LiveConsultationJoinerInfo
                {
                    Id = liveMember.Id,
                    Name = liveMember.Name,
                    HeadImageUrl = liveMember.HeadImageToken,
                    IsOnline = liveMember.IsOnline,
                    Mute = liveMember.Mute,
                    LoginSource = liveMember.LoginSource,
                    LiveData = liveMember.LiveData
                };
                var message = new JoinInLiveConsultationNotification
                {
                    ConsultationCode = RoomId,
                    Joiner = joinerInfo
                };
                PushMessage(userInfos, message);
            }
        }

        private void PushRejectInMessage(LiveConsultationMember liveMember, CacheUserDTO userInfo)
        {
            var userInfos = Members.Where(x => x.Id == liveMember.Id && x.MemberType == LiveMemberEnum.User && x.Status == LiveConsultationMemberStatus.Joined);
            if (userInfos?.Any() == true)
            {
                var userName = !string.IsNullOrWhiteSpace(userInfo.FullName) ? userInfo.FullName : userInfo.UserName;
                var rejecterInfo = new LiveConsultationRejecterInfo
                {
                    Id = userInfo.Code,
                    Name = userName,
                    HeadImageUrl = userInfo.HeadImageUrl,
                };
                var message = new RejectInviteLiveConsultationNotification
                {
                    ConsultationCode = RoomId,
                    Rejecter = rejecterInfo
                };
                PushMessage(userInfos, message);
            }
        }

        private void PushBoardDataMessage(LiveConsultationMember liveMember, string boardData, bool isClear)
        {
            var userInfos = Members.Where(x => x.Id != liveMember.Id && x.MemberType == LiveMemberEnum.User && x.Status == LiveConsultationMemberStatus.Joined);
            if (userInfos?.Any() == true)
            {
                var message = new SendInteractiveBoardDataNotification
                {
                    ConsultationCode = RoomId,
                    BoardData = boardData,
                    IsClear = isClear,
                    UserCode = liveMember.Id,
                };
                PushMessage(userInfos, message);
            }
        }

        private void PushEmergencyMessage(UserDTO doctor, int timeOut)
        {
            if (Initiator != null && Initiator.Status == LiveConsultationMemberStatus.Joined)
            {
                var message = new EmergencyCallNotification
                {
                    ConsultationCode = RoomId,
                    RoomNo = RoomNo,
                    Timeout = timeOut,
                    Initiator = Initiator
                };
                var liveMember = new LiveConsultationMember
                {
                    Id = doctor.UserCode,
                    Name = doctor.UserName,
                };
                PushMessage(new List<LiveConsultationMember> { liveMember }, message);
            }
        }

        private void PushEmergencyFailedMessage()
        {
            if (Initiator != null && Initiator.Status == LiveConsultationMemberStatus.Joined)
            {
                var message = new EmergencyCallFailedNotification
                {
                    ConsultationCode = RoomId,
                };
                PushMessage(new List<LiveConsultationMember> { Initiator }, message);
            }
        }

        private void PushChangeRoomMessage(string operatorCode, LiveConsultationRoom current)
        {
            var userInfos = Members.Where(x => x.Id != operatorCode && x.MemberType == LiveMemberEnum.User);
            if (userInfos?.Any() == true)
            {
                var message = new ChangeConsultationNotification
                {
                    ConsultationCode = current.RoomId,
                    RoomNo = RoomNo,
                    MemberLiveDatas = current.Members,
                };
                PushMessage(userInfos, message);
            }
            var deviceInfos = Members.Where(x => x.MemberType == LiveMemberEnum.Device);
            if (deviceInfos?.Any() == true)
            {
                // var message = new ChangeConsultationToDeviceNotification
                // {
                //     ConsultationCode = current.RoomId,
                //     RoomNo = RoomNo,
                //     MemberLiveDatas = current.Members,
                // };
                // PushMessage(deviceInfos, message);
            }
        }

    }
}