public void ItReturnsTheCorrectFilterViewModel()
        {
            
            autoMocker.Get<IPlayedGameRetriever>().Expect(mock => mock.SearchPlayedGames(null))
                .IgnoreArguments()
                .Return(new List<PlayedGameSearchResult>());
            var filter = new PlayedGamesFilterViewModel
            {
                DatePlayedStart = new DateTime(2015, 1, 1),
                DatePlayedEnd = new DateTime(2015, 2, 2),
                GameDefinitionId = 1
            };

            var actualResults = autoMocker.ClassUnderTest.Search(filter, currentUser) as ViewResult;

            var actualViewModel = actualResults.ViewData.Model as SearchViewModel;
            Assert.That(actualViewModel, Is.TypeOf(typeof(SearchViewModel)));
            Assert.That(actualViewModel.Filter.DatePlayedEnd, Is.EqualTo(filter.DatePlayedEnd));
            Assert.That(actualViewModel.Filter.DatePlayedStart, Is.EqualTo(filter.DatePlayedStart));
            Assert.That(actualViewModel.Filter.GameDefinitionId, Is.EqualTo(filter.GameDefinitionId));
        }
Example #2
0
 public SearchViewModel()
 {
     Filter = new PlayedGamesFilterViewModel();
 }
Example #3
0
 public SearchViewModel()
 {
     Filter = new PlayedGamesFilterViewModel();
 }
        public virtual ActionResult Search(PlayedGamesFilterViewModel filter, ApplicationUser currentUser)
        {
            var playedGameFilter = new PlayedGameFilter
            {
                EndDateGameLastUpdated = filter.DatePlayedEnd == null ? null : filter.DatePlayedEnd.Value.ToString("yyyy-MM-dd"),
                GamingGroupId = currentUser.CurrentGamingGroupId,
                StartDateGameLastUpdated = filter.DatePlayedStart == null ? null : filter.DatePlayedStart.Value.ToString("yyyy-MM-dd"),
                GameDefinitionId = filter.GameDefinitionId
            };
            var searchResults = _playedGameRetriever.SearchPlayedGames(playedGameFilter);

            var playedGamesDetails = searchResults.Select(searchResult => new PlayedGameDetailsViewModel
            {
                DatePlayed = searchResult.DatePlayed,
                GameDefinitionId = searchResult.GameDefinitionId,
                GameDefinitionName = searchResult.GameDefinitionName,
                GamingGroupId = searchResult.GamingGroupId,
                GamingGroupName = searchResult.GamingGroupName,
                Notes = searchResult.Notes,
                PlayedGameId = searchResult.PlayedGameId,
                UserCanEdit = true,
                WinnerType = searchResult.WinnerType,
                PlayerResults = searchResult.PlayerGameResults.Select(playerResult => new GameResultViewModel
                {
                    DatePlayed = searchResult.DatePlayed,
                    GameDefinitionId = searchResult.GameDefinitionId,
                    GameDefinitionName = searchResult.GameDefinitionName,
                    GameRank = playerResult.GameRank,
                    NemePointsSummary = new NemePointsSummaryViewModel(playerResult.NemeStatsPointsAwarded, playerResult.GameDurationBonusNemePoints, playerResult.GameWeightBonusNemePoints),
                    PlayedGameId = searchResult.PlayedGameId,
                    PlayerId = playerResult.PlayerId,
                    PlayerName = playerResult.PlayerName,
                    PointsScored = playerResult.PointsScored,
                    WinnerType = searchResult.WinnerType
                }).ToList()
            }).ToList();

            var viewModel = new SearchViewModel
            {
                Filter =
                {
                    DatePlayedEnd = filter.DatePlayedEnd,
                    DatePlayedStart = filter.DatePlayedStart,
                    GameDefinitionId = filter.GameDefinitionId
                },
                GameDefinitions = GetAllGameDefinitionsForCurrentGamingGroup(currentUser.CurrentGamingGroupId),
                PlayedGames = new PlayedGamesViewModel
                {
                    PlayedGameDetailsViewModels = playedGamesDetails,
                    UserCanEdit = true,
                    GamingGroupId = currentUser.CurrentGamingGroupId,
                    ShowSearchLinkInResultsHeader = false
                }
            };
            return View(MVC.PlayedGame.Views.Search, viewModel);
        }
        public void ItReturnsTheCorrectSearchResults()
        {
            var filter = new PlayedGamesFilterViewModel
            {
                DatePlayedEnd = DateTime.Now.Date,
                DatePlayedStart = DateTime.Now.Date.AddDays(-1),
                GameDefinitionId = 1
            };
            var expectedSearchResults = new List<PlayedGameSearchResult>
            {
                new PlayedGameSearchResult
                {
                    BoardGameGeekGameDefinitionId = 1,
                    GameDefinitionId = 2,
                    GameDefinitionName = "some game definition name",
                    DatePlayed = new DateTime().Date,
                    PlayedGameId = 3,
                    PlayerGameResults = new List<PlayerResult>
                    {
                        new PlayerResult
                        {
                            GameRank = 1,
                            NemeStatsPointsAwarded = 3,
                            GameDurationBonusNemePoints = 1,
                            GameWeightBonusNemePoints = 4,
                            PlayerId = 4,
                            PlayerName = "some player name",
                            PointsScored = 5
                        }
                    },
                    WinnerType = WinnerTypes.TeamWin
                }
            };

            autoMocker.Get<IPlayedGameRetriever>().Expect(mock => mock.SearchPlayedGames(
                Arg<PlayedGameFilter>.Matches(
                    x => x.GamingGroupId == currentUser.CurrentGamingGroupId
                        && x.GameDefinitionId == filter.GameDefinitionId
                        && x.StartDateGameLastUpdated ==
                        filter.DatePlayedStart.Value.ToString("yyyy-MM-dd")
                        && x.EndDateGameLastUpdated ==
                        filter.DatePlayedEnd.Value.ToString("yyyy-MM-dd"))))
                          .Return(expectedSearchResults);

            var actualResults = autoMocker.ClassUnderTest.Search(filter, currentUser) as ViewResult;

            var actualPlayedGameSearchResult = ((SearchViewModel)actualResults.Model).PlayedGames.PlayedGameDetailsViewModels[0];
            var expectedPlayedGameSearchResult = expectedSearchResults[0];
            Assert.That(actualPlayedGameSearchResult.DatePlayed, Is.EqualTo(expectedPlayedGameSearchResult.DatePlayed));
            Assert.That(actualPlayedGameSearchResult.GameDefinitionId, Is.EqualTo(expectedPlayedGameSearchResult.GameDefinitionId));
            Assert.That(actualPlayedGameSearchResult.GameDefinitionName, Is.EqualTo(expectedPlayedGameSearchResult.GameDefinitionName));
            Assert.That(actualPlayedGameSearchResult.GamingGroupId, Is.EqualTo(expectedPlayedGameSearchResult.GamingGroupId));
            Assert.That(actualPlayedGameSearchResult.GamingGroupName, Is.EqualTo(expectedPlayedGameSearchResult.GamingGroupName));
            Assert.That(actualPlayedGameSearchResult.Notes, Is.EqualTo(expectedPlayedGameSearchResult.Notes));
            Assert.That(actualPlayedGameSearchResult.WinnerType, Is.EqualTo(expectedPlayedGameSearchResult.WinnerType));
            var actualPlayerResult = actualPlayedGameSearchResult.PlayerResults[0];
            var expectedPlayerResult = expectedPlayedGameSearchResult.PlayerGameResults[0];
            Assert.That(actualPlayerResult.DatePlayed, Is.EqualTo(expectedPlayedGameSearchResult.DatePlayed));
            Assert.That(actualPlayerResult.GameDefinitionId, Is.EqualTo(expectedPlayedGameSearchResult.GameDefinitionId));
            Assert.That(actualPlayerResult.GameDefinitionName, Is.EqualTo(expectedPlayedGameSearchResult.GameDefinitionName));
            Assert.That(actualPlayerResult.GameRank, Is.EqualTo(expectedPlayerResult.GameRank));
            var expectedNemePointsSummary = new NemePointsSummaryViewModel(expectedPlayerResult.NemeStatsPointsAwarded, expectedPlayerResult.GameDurationBonusNemePoints, expectedPlayerResult.GameWeightBonusNemePoints);
            Assert.That(actualPlayerResult.NemePointsSummary, Is.EqualTo(expectedNemePointsSummary));
            Assert.That(actualPlayerResult.PlayedGameId, Is.EqualTo(expectedPlayedGameSearchResult.PlayedGameId));
            Assert.That(actualPlayerResult.PlayerId, Is.EqualTo(expectedPlayerResult.PlayerId));
            Assert.That(actualPlayerResult.PlayerName, Is.EqualTo(expectedPlayerResult.PlayerName));
            Assert.That(actualPlayerResult.WinnerType, Is.EqualTo(expectedPlayedGameSearchResult.WinnerType));
        }