public async Task ExecuteAsync(CreateStudyRoomSessionCommand message, CancellationToken token)
        {
            var room = await _studyRoomRepository.LoadAsync(message.StudyRoomId, token);

            if (room.Tutor.Id != message.UserId) //only tutor can open a session
            {
                throw new ArgumentException();
            }

            var lastSession = room.GetCurrentSession();

            if (lastSession != null)
            {
                var roomAvailable = await _videoProvider.GetRoomAvailableAsync(lastSession.SessionId);

                if (roomAvailable)
                {
                    lastSession.ReJoinStudyRoom();
                    return;
                }
            }
            var sessionName = $"{message.StudyRoomId}_{DateTimeOffset.UtcNow.ToUnixTimeSeconds()}";

            await _videoProvider.CreateRoomAsync(sessionName, room.Tutor.User.Country,
                                                 message.RecordVideo,
                                                 message.CallbackUrl,
                                                 room.Type.GetValueOrDefault(StudyRoomType.PeerToPeer)
                                                 );

            var session = new StudyRoomSession(room, sessionName);

            room.AddSession(session);
        }
        public async Task HandleAsync(StudyRoomOnlineChangeEvent eventMessage, CancellationToken token)
        {
            var studyUser = eventMessage.StudyUser;
            var studyRoom = studyUser.Room;

            var onlineCount = studyRoom.Users.Count(f => f.Online);
            var totalOnline = 2; // //studyRoom.Users.Count;

            _telemetryClient.TrackEvent($"Users in room {studyRoom.Id}", metrics: new Dictionary <string, double>()
            {
                ["onlineCount"] = onlineCount,
                ["totalOnline"] = totalOnline
            });
            if (onlineCount == totalOnline)
            {
                var session = studyRoom.GetCurrentSession();
                if (session != null)
                {
                    var roomExists = await _videoProvider.GetRoomAvailableAsync(session.SessionId);

                    if (roomExists)
                    {
                        foreach (var user in studyRoom.Users)
                        {
                            var jwtToken =
                                await _videoProvider.ConnectToRoomAsync(session.SessionId, user.User.Id.ToString());


                            var message2 = new SignalRTransportType(SignalRType.StudyRoom,
                                                                    SignalRAction.Update, new
                            {
                                jwtToken
                            });

                            await _hubContext.Clients.User(user.User.Id.ToString())
                            .SendAsync(SbHub.MethodName, message2, token);
                        }

                        return;
                    }
                }
            }
            var message = new SignalRTransportType(SignalRType.StudyRoom,
                                                   SignalRAction.Update, new
            {
                onlineCount,
                totalOnline,
                users    = studyRoom.Users.Where(f => f.Online).Select(s => s.User.Id).ToArray(),
                allUsers = studyRoom.Users.Select(s => s.User.Id).ToArray()
            });


            await _hubContext.Clients.Group(studyRoom.Id.ToString()).SendAsync(SbHub.MethodName, message, token);
        }