Example #1
0
        public int Get(string username, SongRequestType songRequestType)
        {
            using (var context = _chatbotContextFactory.Create())
            {
                var songRequests = context.SongRequests.Where(sr => sr.RequestUsername == username && !sr.Played);

                SongRequest singleRequest = null;

                switch (songRequestType)
                {
                case SongRequestType.Regular:
                    singleRequest = songRequests.SingleOrDefault(sr =>
                                                                 sr.SuperVipRequestTime == null &&
                                                                 sr.VipRequestTime == null);
                    break;

                case SongRequestType.Vip:
                    singleRequest = songRequests.SingleOrDefault(sr =>
                                                                 sr.SuperVipRequestTime == null &&
                                                                 sr.VipRequestTime != null);
                    break;

                case SongRequestType.SuperVip:
                    singleRequest = songRequests.SingleOrDefault(sr =>
                                                                 sr.SuperVipRequestTime != null);
                    break;
                }

                return(singleRequest?.SongRequestId ?? 0);
            }
        }
        public async Task <bool> ArchiveAndRefundVips(string username, SongRequestType songRequestType, int currentSongRequestId)
        {
            var usersRequests = _getUsersRequestsRepository.GetUsersRequests(username);

            int songRequestId = 0;

            switch (songRequestType)
            {
            case SongRequestType.Regular:
                songRequestId = usersRequests.SingleOrDefault(r => !r.IsVip)?.SongRequestId ?? 0;
                break;

            case SongRequestType.Vip:
                songRequestId = usersRequests.SingleOrDefault(r => r.IsVip && !r.IsSuperVip)?.SongRequestId ?? 0;
                break;

            case SongRequestType.SuperVip:
                songRequestId = usersRequests.SingleOrDefault(r => r.IsSuperVip)?.SongRequestId ?? 0;
                break;

            default:
                return(false);
            }

            if (songRequestId == 0 || songRequestId == currentSongRequestId)
            {
                return(false);
            }

            await _archiveRequestCommand.ArchiveRequest(songRequestId, true).ConfigureAwait(false);

            return(true);
        }
        public async Task <AddSongResult> ProcessAddingSongRequest(string username, string requestText,
                                                                   SongRequestType songRequestType)
        {
            switch (songRequestType)
            {
            case SongRequestType.SuperVip:
                return(await _processSuperVipSongRequestCommand.Process(username, requestText).ConfigureAwait(false));

            case SongRequestType.Vip:
                return(await _processVipSongRequestCommand.Process(username, requestText).ConfigureAwait(false));

            case SongRequestType.Regular:
                return(_processRegularSongRequestCommand.Process(username, requestText));

            default:
                throw new Exception(
                          $"Requested a new song of type Any, Username: {username}, RequestText: {requestText}");
            }
        }
Example #4
0
        public int GetUsersCurrentRequestCounts(string username, SongRequestType songRequestType)
        {
            switch (songRequestType)
            {
            case SongRequestType.Regular:
                return(_getUsersCurrentRegularRequestCountRepository.GetUsersCurrentRegularRequestCount(username));

            case SongRequestType.Vip:
                return(_getUsersCurrentVipRequestCountRepository.GetUsersCurrentVipRequestCount(username));

            case SongRequestType.SuperVip:
                return(_getUsersCurrentSuperVipRequestCountRepository.GetUsersCurrentSuperVipRequestCount(username));

            case SongRequestType.Any:
                return(_getUsersCurrentRequestCountRepository.GetUsersCurrentRequestCount(username));

            default:
                return(_getUsersCurrentRequestCountRepository.GetUsersCurrentRequestCount(username));
            }
        }
        public async Task Test(PlaylistState state, string username, string requestText, SongRequestType requestType, AddRequestResult expectedResult)
        {
            // Arrange
            SetupTest(state);

            // Act
            var result = await _subject.AddSongRequest(username, requestText, requestType);

            // Assert
            Assert.AreEqual(expectedResult, result.AddRequestResult);
        }
        public async Task <AddSongResult> AddSongRequest(string username, string requestText, SongRequestType songRequestType)
        {
            if (string.IsNullOrWhiteSpace(requestText))
            {
                return new AddSongResult
                       {
                           AddRequestResult = AddRequestResult.NoRequestEntered
                       }
            }
            ;

            if (string.IsNullOrWhiteSpace(username) || songRequestType == SongRequestType.Any)
            {
                return new AddSongResult
                       {
                           AddRequestResult = AddRequestResult.UnSuccessful
                       }
            }
            ;

            var playlistState = _getPlaylistStateQuery.GetPlaylistState();

            switch (playlistState)
            {
            case PlaylistState.VeryClosed:
                if (songRequestType != SongRequestType.SuperVip)
                {
                    return(new AddSongResult
                    {
                        AddRequestResult = AddRequestResult.PlaylistVeryClosed
                    });
                }

                break;

            case PlaylistState.Closed:
                if (songRequestType == SongRequestType.Regular)
                {
                    return(new AddSongResult
                    {
                        AddRequestResult = AddRequestResult.PlaylistClosed
                    });
                }

                break;
            }
            return(await _processSongRequestCommand.ProcessAddingSongRequest(username, requestText, songRequestType).ConfigureAwait(false));
        }
    }
}
 public int Get(string username, SongRequestType songRequestType)
 {
     return(_getSingleSongRequestIdRepository.Get(username, songRequestType));
 }
Example #8
0
 public void ExceptionTest(string username, string requestText, SongRequestType requestType)
 {
     Assert.ThrowsAsync <Exception>(async() => await _subject.ProcessAddingSongRequest(username, requestText, requestType));
 }
Example #9
0
        public async Task SuccessTest(string username, string requestText, SongRequestType requestType)
        {
            var result = await _subject.ProcessAddingSongRequest(username, requestText, requestType);

            Assert.AreEqual(AddRequestResult.Success, result.AddRequestResult);
        }