FISLib_Old/Vinno.vCloud.Common.FIS/Consultation/ConsultationRecipientV2.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Vinno.IUS.Common.Log;
using Vinno.vCloud.Common.FIS.Helper;
using Vinno.vCloud.Protocol.Infrastructures;
using Vinno.vCloud.Protocol.Messages.Client.LiveTalking;
using WingInterfaceLibrary.Interface;
using WingInterfaceLibrary.LiveConsultation;
using WingInterfaceLibrary.Request.Device;
using WingInterfaceLibrary.Request.User;

namespace Vinno.vCloud.Common.FIS.Consultation
{
    internal class ConsultationRecipientV2 : ConsultationClientV2
    {
        private readonly string _deviceId;

        /// <summary>
        /// Raised when receive a Consultation request from server.
        /// </summary>
        public event EventHandler<ConsultationInfo> ConsultationRequestArrived;

        /// <summary>
        /// 当开始Web会诊时
        /// </summary>
        public event EventHandler<string> StartWebConsultationEvent;

        /// <summary>
        /// 当切换病人时触发，病人信息与会诊code变更
        /// </summary>
        public event EventHandler<ChangeLiveConsultationrResult> ChangeLiveConsultationEvent;

        public ConsultationRecipientV2(ConsultationLiveVideoProviderV2 videoProvider, ConsultationManagerV2 consultationManager, string deviceId, ILiveConsultationService liveConsultationService, IUserService userService, IDeviceService deviceService) : base(videoProvider, consultationManager, liveConsultationService, userService, deviceService)
        {
            _deviceId = deviceId;
        }

        /// <summary>
        /// Send a join Rtc Consultation Live  request
        /// </summary>
        /// <returns></returns>
        public ResultInfoDTO StartWebConsultation(FlutterLiveConsultationInfo flutterLiveConsultationInfo)
        {
            try
            {
                if (CurrentLiveStatus == LiveStates.RecipientAcceptting || CurrentLiveStatus == LiveStates.RecipientAcceptted)
                {
                    Logger.WriteLineInfo($"Consultation Live-- accept Consultation failed due to CurrentLiveStatus is {CurrentLiveStatus}");
                    return new ResultInfoDTO
                    {
                        IsSuccess = false,
                        FailMessage = $"StartWebConsultation Fail,Consultation is busy.",
                        ErrorCode = 861,
                    };
                }
                if (string.IsNullOrEmpty(flutterLiveConsultationInfo.ConsulationId))
                {
                    return new ResultInfoDTO
                    {
                        IsSuccess = false,
                        FailMessage = $"StartWebConsultation Fail,Consultation id is null.",
                    };
                }
                IsSecondViewMode = true;
                ConsultationInfo consultationInfo = new ConsultationInfo(ChatRole.Recipient)
                {
                    ConsultationId = flutterLiveConsultationInfo.ConsulationId,
                };
                consultationInfo.PatientInfo = ConsultationManager.FindConsultationDetail(flutterLiveConsultationInfo.ConsulationId, AccountToken, out _);
                lock (ConsultationInfoLocker)
                {
                    ConsultationInfo = consultationInfo;
                }
                StartWebConsultationEvent?.Invoke(this, flutterLiveConsultationInfo.LiveConsultationFlutterUrl);
                return new ResultInfoDTO
                {
                    IsSuccess = true,
                };
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Exception happened when StartWebConsultation {ex}");
                Hangup(true);
                return new ResultInfoDTO
                {
                    IsSuccess = false,
                    FailMessage = $"StartWebConsultation Error:{ex}",
                };
            }
        }

        /// <summary>
        /// Send a join Rtc Consultation Live  request
        /// </summary>
        /// <returns></returns>
        public ResultInfoDTO StartLiveConsultation(LiveConsultationRequestDTO liveConsultationRequestDTO, string cameraHardwareId, string micHardwareId, string speakerHardwareId)
        {
            try
            {
                if (CurrentLiveStatus == LiveStates.RecipientAcceptting || CurrentLiveStatus == LiveStates.RecipientAcceptted || IsSecondViewMode)
                {
                    Logger.WriteLineInfo($"Consultation Live-- accept Consultation failed due to CurrentLiveStatus is {CurrentLiveStatus},IsSecondViewMode:{IsSecondViewMode}");
                    if (liveConsultationRequestDTO.IsInvite)
                    {
                        return new ResultInfoDTO
                        {
                            IsSuccess = false,
                            FailMessage = $"AcceptConsultation Fail,Consultation is busy.",
                            ErrorCode = 852,
                        };
                    }
                    else
                    {
                        return new ResultInfoDTO
                        {
                            IsSuccess = false,
                            FailMessage = $"AcceptConsultation Fail,Consultation is busy.",
                            ErrorCode = 861,
                        };
                    }
                }
                if (string.IsNullOrEmpty(AccountId))
                {
                    CurrentLiveStatus = LiveStates.UnknowException;
                    return new ResultInfoDTO
                    {
                        IsSuccess = false,
                        FailMessage = $"AcceptConsultation Fail,AccountId is Null.",
                    };
                }
                string deviceId = null;
                CurrentLiveStatus = LiveStates.RecipientAcceptting;
                Logger.WriteLineInfo($"Consultation Live-- {AccountName} start Consultation request begin");
                ConsultationInfo consultationInfo;
                if (liveConsultationRequestDTO.IsInvite)
                {
                    var initiateLiveConsultationRequest = new InitiateLiveConsultationRequest
                    {
                        ConsultationCode = liveConsultationRequestDTO.ConsultationCode,
                        Token = AccountToken,
                        CheckOnly = false,
                    };
                    var initiateLiveConsultationResult = JsonRpcHelper.InitiateLiveConsultation(LiveConsultationService, initiateLiveConsultationRequest, out var errorCode);
                    if (initiateLiveConsultationResult == null)
                    {
                        CurrentLiveStatus = LiveStates.UnknowException;
                        return new ResultInfoDTO
                        {
                            IsSuccess = false,
                            FailMessage = $"Initiate Consultation Fail,result is null",
                            ErrorCode = errorCode
                        };
                    }
                    consultationInfo = DTOConverter.ConvertInitiateLiveConsultationResultToConsultationInfo(initiateLiveConsultationResult);
                    consultationInfo.PatientInfo = ConsultationManager.FindConsultationDetail(liveConsultationRequestDTO.ConsultationCode, AccountToken, out deviceId);
                }
                else if (liveConsultationRequestDTO.IsJoin)
                {
                    var joinLiveConsultationRequest = new JoinLiveConsultationRequest
                    {
                        ConsultationCode = liveConsultationRequestDTO.ConsultationCode,
                        Token = AccountToken,
                        CheckOnly = false,
                    };
                    var joinLiveConsultationResult = JsonRpcHelper.JoinInLiveConsultation(LiveConsultationService, joinLiveConsultationRequest, out var errorCode);
                    if (joinLiveConsultationResult == null)
                    {
                        CurrentLiveStatus = LiveStates.UnknowException;
                        return new ResultInfoDTO
                        {
                            IsSuccess = false,
                            FailMessage = $"Join Consultation Fail,result is null",
                            ErrorCode = errorCode
                        };
                    }
                    consultationInfo = DTOConverter.ConvertJoinLiveConsultationResultToConsultationInfo(joinLiveConsultationResult);
                    consultationInfo.PatientInfo = ConsultationManager.FindConsultationDetail(liveConsultationRequestDTO.ConsultationCode, AccountToken, out deviceId); ;
                }
                else
                {
                    var acceptLiveConsultationRequest = new AcceptLiveConsultationRequest
                    {
                        CheckOnly = false,
                        ConsultationCode = liveConsultationRequestDTO.ConsultationCode,
                        Token = liveConsultationRequestDTO.Token,
                    };
                    var acceptLiveConsultationResult = JsonRpcHelper.AcceptLiveConsultation(LiveConsultationService, acceptLiveConsultationRequest, out var errorCode);
                    if (acceptLiveConsultationResult == null)
                    {
                        CurrentLiveStatus = LiveStates.UnknowException;
                        return new ResultInfoDTO
                        {
                            IsSuccess = false,
                            FailMessage = $"AcceptConsultation Fail,result is null",
                            ErrorCode = errorCode
                        };
                    }
                    consultationInfo = DTOConverter.ConvertAcceptLiveConsultationResultToConsultationInfo(acceptLiveConsultationResult);
                    consultationInfo.PatientInfo = ConsultationManager.FindConsultationDetail(liveConsultationRequestDTO.ConsultationCode, AccountToken, out deviceId);
                }

                if (consultationInfo.TerminalInfo != null && !string.IsNullOrEmpty(deviceId))
                {
                    var getDeviceRequest = new GetDeviceRequest
                    {
                        DeviceCode = deviceId,
                        Token = AccountToken,
                    };
                    var deviceModel = JsonRpcHelper.GetDeviceInfo(DeviceService, getDeviceRequest);
                    consultationInfo.TerminalInfo.Model = deviceModel?.DeviceModel;
                }

                lock (ConsultationInfoLocker)
                {
                    ConsultationInfo = consultationInfo;
                }
                StartConsultation(cameraHardwareId, micHardwareId, speakerHardwareId, false);
                CurrentLiveStatus = LiveStates.RecipientAcceptted;
                Logger.WriteLineInfo($"Consultation Live-- {AccountName} accept meeConsultationting request end");
                ConsultationRequestArrived?.Invoke(this, ConsultationInfo);
                return new ResultInfoDTO
                {
                    IsSuccess = true,
                };
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Exception happened when accept Consultation{ex}");
                Hangup();
                return new ResultInfoDTO
                {
                    IsSuccess = false,
                    FailMessage = $"AcceptConsultation Error:{ex}",
                };
            }
        }

        /// <summary>
        /// Send a join Rtc Consultation Live  request
        /// </summary>
        /// <returns></returns>
        public ResultInfoDTO StartLiveConsultation(StartOnlyForRtmpPushingDTO startOnlyForRtmpPushingDTO, string cameraHardwareId, string micHardwareId)
        {
            try
            {
                if (CurrentLiveStatus == LiveStates.RecipientAcceptting || CurrentLiveStatus == LiveStates.RecipientAcceptted)
                {
                    Logger.WriteLineInfo($"Consultation Live-- accept Consultation failed due to CurrentLiveStatus is {CurrentLiveStatus}");
                    return new ResultInfoDTO
                    {
                        IsSuccess = false,
                        FailMessage = $"AcceptConsultation Fail,Consultation is busy.",
                        ErrorCode = 861,
                    };
                }
                if (string.IsNullOrEmpty(AccountId))
                {
                    CurrentLiveStatus = LiveStates.UnknowException;
                    return new ResultInfoDTO
                    {
                        IsSuccess = false,
                        FailMessage = $"AcceptConsultation Fail,AccountId is Null.",
                    };
                }
                CurrentLiveStatus = LiveStates.RecipientAcceptting;
                Logger.WriteLineInfo($"Consultation Live-- {AccountName} start Consultation request begin");
                ConsultationInfo consultationInfo;

                consultationInfo = new ConsultationInfo(ChatRole.Recipient)
                {
                    ConsultationId = startOnlyForRtmpPushingDTO.ConsultationCode,
                    State = LiveStates.OK,
                    LiveProtocol = LiveProtocol.Rtmp,
                    LiveTalkingMode = LiveTalkingMode.Video,
                    IsCurrentTerminal = false,
                    ConsultationMemberInfos = new List<ConsultationMemberInfo>
                    {
                        new ConsultationMemberInfo
                        {
                            PushLiveState = LiveStates.OK,
                            PushUrl = startOnlyForRtmpPushingDTO.RtmpPushingUrl,
                            Id = AccountId,
                            Name = AccountName,
                            DisplayName = AccountName,
                        },
                    },
                };
                consultationInfo.PatientInfo = ConsultationManager.FindConsultationDetail(startOnlyForRtmpPushingDTO.ConsultationCode, AccountToken, out _);
                lock (ConsultationInfoLocker)
                {
                    ConsultationInfo = consultationInfo;
                }
                StartConsultation(cameraHardwareId, micHardwareId, null, true);
                IsOnlyForRtmpPushing = true;
                CurrentLiveStatus = LiveStates.RecipientAcceptted;
                Logger.WriteLineInfo($"Consultation Live-- {AccountName} accept only rtmp pushing end");
                return new ResultInfoDTO
                {
                    IsSuccess = true,
                };
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Exception happened when only rtmp pushing:{ex}");
                Hangup();
                return new ResultInfoDTO
                {
                    IsSuccess = false,
                    FailMessage = $"AcceptConsultation Error:{ex}",
                };
            }
        }

        internal ResultInfoDTO ChangeLiveConsultation(ChangeLiveConsultationRequestDTO changeLiveConsultation0RequestDTO)
        {
            try
            {
                if (ConsultationInfo == null)
                {
                    Logger.WriteLineWarn($"ChangeLiveConsultation Fail: Current is not Consultating");
                    return new ResultInfoDTO
                    {
                        IsSuccess = false,
                        FailMessage = "ChangeLiveConsultation Fail: Current is not Consultating"
                    };
                }
                ConsultationInfo.ConsultationId = changeLiveConsultation0RequestDTO.ConsultationCode;
                var patientInfo = ConsultationManager.FindConsultationDetail(changeLiveConsultation0RequestDTO.ConsultationCode, AccountToken, out _);
                lock (ConsultationInfoLocker)
                {
                    ConsultationInfo.PatientInfo = patientInfo;
                }
                if (IsSecondViewMode && !IsOnlyForRtmpPushing)//第二屏且不是rtmp推流的情况下
                {
                    return new ResultInfoDTO
                    {
                        IsSuccess = true,
                    };
                }
                VideoProvider.ChangeConsultationCodeForConsultationConnectionKeeper(changeLiveConsultation0RequestDTO.ConsultationCode);
                if (IsOnlyForRtmpPushing)
                {
                    return new ResultInfoDTO
                    {
                        IsSuccess = true,
                    };
                }
                ChangeLiveConsultationEvent?.Invoke(this, new ChangeLiveConsultationrResult(changeLiveConsultation0RequestDTO.ConsultationCode, ConsultationInfo.PatientInfo));
                var currentConsultationMembers = ConsultationInfo?.ConsultationMemberInfos?.ToList();
                var leaveMemberList = currentConsultationMembers.Where(x => !changeLiveConsultation0RequestDTO.Members.Any(y => y.Id == x.Id));
                if (leaveMemberList != null)
                {
                    foreach (var member in leaveMemberList)
                    {
                        member.OperationType = ClientMessageOperationType.Delete;
                        var consultationMemberChangeDTO = new ConsultationMemberChangeDTO()
                        {
                            ConsultationCode = changeLiveConsultation0RequestDTO.ConsultationCode,
                            MemberInfo = member
                        };
                        ConsultationMemberChange(consultationMemberChangeDTO);
                        var memberInfo = ConsultationInfo?.ConsultationMemberInfos.FirstOrDefault(f => f.Id == consultationMemberChangeDTO.MemberInfo.Id);
                        if (memberInfo != null)
                        {
                            memberInfo.OperationType = ClientMessageOperationType.Delete;
                            ConsultationInfo?.ConsultationMemberInfos.Remove(memberInfo);
                        }
                        var meetingChangeMember = DTOConverter.ConvertConsultationMemberChangeDTOToConsultationMemberNotificaiton(consultationMemberChangeDTO);
                        HandleConsultationMemberNotificationArrived(meetingChangeMember);
                    }
                }
                currentConsultationMembers = ConsultationInfo?.ConsultationMemberInfos?.ToList();
                var addMemberList = changeLiveConsultation0RequestDTO.Members.Where(x => !currentConsultationMembers.Any(y => y.Id == x.Id));
                if (addMemberList != null)
                {
                    foreach (var member in addMemberList)
                    {
                        member.OperationType = ClientMessageOperationType.Add;
                        var consultationMemberChangeDTO = new ConsultationMemberChangeDTO()
                        {
                            ConsultationCode = changeLiveConsultation0RequestDTO.ConsultationCode,
                            MemberInfo = member
                        };
                        ConsultationMemberChange(consultationMemberChangeDTO);
                        var memberInfo = ConsultationInfo?.ConsultationMemberInfos.FirstOrDefault(f => f.Id == consultationMemberChangeDTO.MemberInfo.Id);
                        if (memberInfo == null)
                        {
                            ConsultationInfo?.ConsultationMemberInfos.Add(member);
                        }
                        var meetingChangeMember = DTOConverter.ConvertConsultationMemberChangeDTOToConsultationMemberNotificaiton(consultationMemberChangeDTO);
                        HandleConsultationMemberNotificationArrived(meetingChangeMember);
                    }
                }
                return new ResultInfoDTO
                {
                    IsSuccess = true,
                };
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"ChangeLiveConsultation error: {ex}");
                return new ResultInfoDTO
                {
                    IsSuccess = false,
                    FailMessage = $"ChangeLiveConsultation Fail: {ex}"
                };
            }
        }

        public string GetUserInfo(string token)
        {
            AccountToken = token;
            var getUserRequest = new GetUserInfoRequest
            {
                Token = token,
            };
            var userDTO = JsonRpcHelper.GetUserInfo(UserService, getUserRequest);
            if (userDTO == null)
            {
                AccountName = null;
                AccountId = null;
                Logger.WriteLineError($"GetUserInfo Error,result is null");
                return null;
            }
            else
            {
                AccountName = userDTO.DisplayName;
                AccountId = userDTO.UserCode;
                return AccountId;
            }
        }

        public override void Dispose()
        {
            Logger.WriteLineInfo("Consultation Recipient is dispose begin");
            base.Dispose();
            Logger.WriteLineInfo("Consultation Recipient is dispose end");
        }

        internal ResultInfoDTO LiveConsultationMemberChanged(ConsultationMemberChangeDTO consultationMemberChangeDTO)
        {
            if (ConsultationInfo == null)
            {
                Logger.WriteLineWarn($"LiveConsultationMemberChanged Fail: Current is not Consultating");
                return new ResultInfoDTO
                {
                    IsSuccess = false,
                    FailMessage = "LiveConsultationMemberChanged Fail: Current is not Consultating"
                };
            }
            if (ConsultationInfo.ConsultationId != consultationMemberChangeDTO.ConsultationCode)
            {
                Logger.WriteLineWarn($"LiveConsultationMemberChanged Fail: Current ConsultationCode is {ConsultationInfo.ConsultationId},not {consultationMemberChangeDTO.ConsultationCode}");
                return new ResultInfoDTO
                {
                    IsSuccess = false,
                    FailMessage = $"LiveConsultationMemberChanged Fail: Current ConsultationCode is {ConsultationInfo.ConsultationId},not {consultationMemberChangeDTO.ConsultationCode}"
                };
            }
            ConsultationMemberChange(consultationMemberChangeDTO);
            var memberInfo = ConsultationInfo?.ConsultationMemberInfos.FirstOrDefault(f => f.Id == consultationMemberChangeDTO.MemberInfo.Id);
            if (consultationMemberChangeDTO.MemberInfo.OperationType == ClientMessageOperationType.Add)
            {
                if (memberInfo == null)
                {
                    ConsultationInfo.ConsultationMemberInfos.Add(consultationMemberChangeDTO.MemberInfo);
                }
                memberInfo = consultationMemberChangeDTO.MemberInfo;
            }
            else if (consultationMemberChangeDTO.MemberInfo.OperationType == ClientMessageOperationType.Delete)
            {
                if (memberInfo != null)
                {
                    ConsultationInfo?.ConsultationMemberInfos.Remove(memberInfo);
                }
            }
            if (memberInfo != null)
            {
                consultationMemberChangeDTO.MemberInfo.RoleType = memberInfo.RoleType;
            }
            var meetingChangeMember = DTOConverter.ConvertConsultationMemberChangeDTOToConsultationMemberNotificaiton(consultationMemberChangeDTO);
            HandleConsultationMemberNotificationArrived(meetingChangeMember);
            return new ResultInfoDTO
            {
                IsSuccess = true,
            };
        }
    }
}