public async Task <bool> CheckSessionForClientAsync(ClientRequestDetails clientRequestDetails, CancellationToken cancellationToken)
        {
            if (!ValidationHelper.ValidateObjectId(clientRequestDetails.SessionId))
            {
                return(false);
            }

            var session = await GetSessionByIdAsync(clientRequestDetails.SessionId, cancellationToken);

            if (session == null)
            {
                return(false);
            }

            if (session.SessionCode != clientRequestDetails.SessionCode.ToUpperInvariant())
            {
                return(false);
            }

            var user = await _userRepo.GetUserByIdAsync(clientRequestDetails.UserId, cancellationToken);

            if (user == null)
            {
                return(false);
            }

            if (user.AuthCode != clientRequestDetails.AuthCode)
            {
                return(false);
            }

            return(true);
        }
        public async Task GetSessionStateAsync(ClientRequestDetails clientRequestDetails)
        {
            if (!await _sessionProvider.CheckSessionForClientAsync(clientRequestDetails, default))
            {
                return;
            }

            var session = await _sessionProvider.GetSessionByIdAsync(clientRequestDetails.SessionId, default);

            var users = await _userRepo.GetUsersBySessionIdAsync(clientRequestDetails.SessionId, default);

            var stories = await _storyRepo.GetStoriesBySessionIdAsync(clientRequestDetails.SessionId, default);

            var sessionState = new SessionStateResponse
            {
                SessionId      = session.SessionId,
                SessionCode    = session.SessionCode,
                UserId         = clientRequestDetails.UserId,
                IsHost         = users.FirstOrDefault(i => i.UserId == clientRequestDetails.UserId)?.IsHost ?? false,
                Stories        = stories,
                Users          = users,
                PointChoices   = session.PointChoices,
                HasStarted     = session.HasStarted,
                HasFinished    = session.HasFinished,
                CurrentStoryId = session.CurrentStoryId
            };

            await Clients.Caller.SendAsync("GetSessionState", sessionState);
        }
 public ClientRequestDetailsViewModel(MerkatoDbContext context, ClientRequestDetails requestDetails) : this(context)
 {
     this.Id = requestDetails.Id;
     this.ClientRequestId  = requestDetails.ClientRequestId;
     this.Date             = requestDetails.Date;
     this.AssignedAgentId  = requestDetails.AssignedAgentId;
     this.AssignmentDate   = requestDetails.AssignmentDate;
     this.UserId           = requestDetails.UserId;
     this.LastDateModified = requestDetails.LastDateModified;
 }
        public ClientRequestDetails GetModel()
        {
            ClientRequestDetails details = new ClientRequestDetails();

            details.Id = this.Id;
            details.ClientRequestId  = this.ClientRequestId;
            details.Date             = this.Date;
            details.AssignedAgentId  = this.AssignedAgentId;
            details.AssignmentDate   = this.AssignmentDate;
            details.UserId           = this.UserId;
            details.LastDateModified = this.LastDateModified;


            return(details);
        }
        public async Task MakePointSelectionForCurrentStoryAsync(ClientRequestDetails clientRequestDetails, string points)
        {
            if (!await _sessionProvider.CheckSessionForClientAsync(clientRequestDetails, default))
            {
                return;
            }

            var session = await _sessionProvider.GetSessionByIdAsync(clientRequestDetails.SessionId, default);

            await _storyRepo.UpdateUserPointSelectionForStoryAsync(
                session.CurrentStoryId,
                clientRequestDetails.UserId,
                points,
                default);

            var story = await _storyRepo.GetStoryByIdAsync(session.CurrentStoryId, default);

            await Clients.Group(session.SessionId).SendAsync("MakePointSelection", story);
        }
        public async Task SubscribeAsync(ClientRequestDetails clientRequestDetails)
        {
            if (!await _sessionProvider.CheckSessionForClientAsync(clientRequestDetails, default))
            {
                return;
            }

            await AddToGroupAsync(clientRequestDetails.SessionId);

            await _userRepo.SetConnectionIdAsync(clientRequestDetails.UserId, Context.ConnectionId, default);

            var user = await _userRepo.GetUserByIdAsync(clientRequestDetails.UserId, default);

            await Clients.GroupExcept(clientRequestDetails.SessionId, Context.ConnectionId).SendAsync("UserConnected", user);

            var users = await _userRepo.GetUsersBySessionIdAsync(clientRequestDetails.SessionId, default);

            await Clients.Caller.SendAsync("UserList", users);
        }