public async Task <AddRequestResult> AddWebRequest(AddWebSongRequest requestSongViewModel, string username)
        {
            var requestText =
                $"{requestSongViewModel.Artist} - {requestSongViewModel.Title} ({requestSongViewModel.SelectedInstrument})";

            var result = await _addSongRequestCommand.AddSongRequest(username, requestText,
                                                                     requestSongViewModel.IsSuperVip?SongRequestType.SuperVip :
                                                                     requestSongViewModel.IsVip?SongRequestType.Vip : SongRequestType.Regular).ConfigureAwait(false);


            if (_currentRequest == null)
            {
                _currentRequest = new PlaylistItem
                {
                    songRequestId   = result.SongRequestId,
                    songRequestText = requestText,
                    songRequester   = username,
                    isEvenIndex     = false,
                    isInChat        = true,
                    isVip           = requestSongViewModel.IsVip,
                    isSuperVip      = requestSongViewModel.IsSuperVip,
                    isInDrive       = false
                };
            }

            if (result.AddRequestResult == AddRequestResult.Success)
            {
                UpdateFullPlaylist();
            }
            //TODO SignalR Update

            return(result.AddRequestResult);
        }
        public async Task <IActionResult> AddWebRequest([FromBody] AddWebSongRequest addWebSongRequest)
        {
            try
            {
                var requestSongViewModel = new AddWebSongRequest
                {
                    Title              = addWebSongRequest.Title,
                    Artist             = addWebSongRequest.Artist,
                    SelectedInstrument = addWebSongRequest.SelectedInstrument,
                    IsVip              = addWebSongRequest.IsVip,
                    IsSuperVip         = addWebSongRequest.IsSuperVip
                };

                var result = await _playlistService.AddWebRequest(requestSongViewModel, addWebSongRequest.Username)
                             .ConfigureAwait(false);

                var responseModel = new AddRequestResponse
                {
                    Result           = result,
                    PlaylistPosition = 0
                };

                return(new JsonResult(responseModel));
            }
            catch (Exception e)
            {
                _logger.LogError(e, "Error in AddWebRequest", addWebSongRequest);
                return(BadRequest());
            }
        }
        public async Task <AddRequestResponse> AddWebRequest(AddWebSongRequest addWebSongRequest)
        {
            try
            {
                var result =
                    await _playlistClient.PostAsync("AddWebRequest", HttpClientHelper.GetJsonData(addWebSongRequest));

                return(JsonConvert.DeserializeObject <AddRequestResponse>(await result.Content.ReadAsStringAsync()));
            }
            catch (Exception e)
            {
                return(HttpClientHelper.LogError <AddRequestResponse>(_logger, e, new object[] { addWebSongRequest }));
            }
        }
        public IActionResult RequestSong([FromBody] RequestSongModel requestData)
        {
            if (User.Identity.IsAuthenticated)
            {
                var requestModel = new AddWebSongRequest
                {
                    SongRequestId      = int.Parse(requestData.SongRequestId),
                    Title              = requestData.Title,
                    Artist             = requestData.Artist,
                    SelectedInstrument = requestData.SelectedInstrument,
                    IsVip              = requestData.IsVip,
                    IsSuperVip         = requestData.IsSuperVip,
                    Username           = User.Identity.Name
                };

                var requestResult = _playlistApiClient.AddWebRequest(requestModel).Result.Result;

                var maxRegularRequests = _playlistApiClient.GetMaxUserRequests().Result.MaxRequests;

                switch (requestResult)
                {
                case AddRequestResult.Success:
                    return(Ok());

                case AddRequestResult.MaximumRegularRequests:
                    return(BadRequest(new
                    {
                        Message =
                            $"You cannot have more than {maxRegularRequests} regular request{(maxRegularRequests > 1 ? "s" : "")}"
                    }));

                case AddRequestResult.PlaylistClosed:
                    return(BadRequest(new
                    {
                        Message =
                            "The playlist is currently closed, you can still use a VIP token to request though!"
                    }));

                case AddRequestResult.PlaylistVeryClosed:
                    return(BadRequest(new
                    {
                        Message =
                            "The playlist is completely closed, please wait until the playlist opens to request a song"
                    }));

                case AddRequestResult.UnSuccessful:
                    return(BadRequest(new
                    {
                        Message = "An error occurred, please wait until the issue is resolved"
                    }));

                case AddRequestResult.NoRequestEntered:
                    return(BadRequest(new
                    {
                        Message = "You haven't entered a request. Please enter a Song Name and/or Artist"
                    }));
                }
            }

            return(BadRequest(new { Message = "It looks like you're not logged in, log in and try again" }));
        }