Esempio n. 1
0
        internal void OnActionExecuting(
            ActionExecutingContext filterContext,
            ApplicationUserManager userManager,
            ClientIdCalculator clientIdCalculator)
        {
            if (filterContext.ActionParameters.ContainsKey(USER_CONTEXT_KEY))
            {
                ApplicationUser applicationUser;

                if (filterContext.HttpContext.User.Identity.IsAuthenticated)
                {
                    string userId = filterContext.HttpContext.User.Identity.GetUserId();
                    applicationUser = userManager.FindByIdAsync(userId).Result;
                }
                else
                {
                    applicationUser = new AnonymousApplicationUser();
                    if (this.RequiresGamingGroup)
                    {
                        filterContext.Result = new RedirectToRouteResult(MVC.Account.Login().GetRouteValueDictionary());
                    }
                }

                applicationUser.AnonymousClientId = clientIdCalculator.GetClientId(filterContext.HttpContext.Request, applicationUser);

                filterContext.ActionParameters[USER_CONTEXT_KEY] = applicationUser;
            }

            base.OnActionExecuting(filterContext);
        }
        public void It_Processes_Analytics_Events_Then_Badges_Then_Champions_Then_Nemeses_Then_Achievements()
        {
            //--arrange
            var playersInGame = new List <int> {
                10, 11
            };

            var playedGameEvent = new PlayedGameCreatedEvent(1, 2, playersInGame, TransactionSource.RestApi, new AnonymousApplicationUser());

            var anonymousApplicationUser = new AnonymousApplicationUser();

            //--act
            _autoMocker.ClassUnderTest.Handle(playedGameEvent);

            //--assert

            //--make sure event tracking was called but not yet the champion recalculator
            _autoMocker.Get <INemeStatsEventTracker>().AssertWasCalled(mock => mock.TrackPlayedGame(
                                                                           Arg <ApplicationUser> .Is.Equal(anonymousApplicationUser),
                                                                           Arg <TransactionSource> .Is.Equal(playedGameEvent.TransactionSource)),
                                                                       options => options.WhenCalled(y => _autoMocker.Get <IChampionRecalculator>().AssertWasNotCalled(
                                                                                                         mock => mock.RecalculateChampion(Arg <int> .Is.Anything, Arg <ApplicationUser> .Is.Anything, Arg <IDataContext> .Is.Anything))));

            //--make sure the champion recalculator was called but not yet the nemesis recalculator
            _autoMocker.Get <IChampionRecalculator>().AssertWasCalled(
                mock => mock.RecalculateChampion(
                    Arg <int> .Is.Equal(playedGameEvent.GameDefinitionId),
                    Arg <ApplicationUser> .Is.Equal(anonymousApplicationUser),
                    Arg <IDataContext> .Is.Anything,
                    Arg <bool> .Is.Anything),
                options => options.WhenCalled(y => _autoMocker.Get <INemesisRecalculator>().AssertWasNotCalled(
                                                  mock => mock.RecalculateNemesis(Arg <int> .Is.Equal(playersInGame[0]),
                                                                                  Arg <ApplicationUser> .Is.Equal(anonymousApplicationUser),
                                                                                  Arg <IDataContext> .Is.Anything))));

            //--make sure the nemesis recalculator was called for the first player in the game, but not yet the achievement processor
            _autoMocker.Get <INemesisRecalculator>().AssertWasCalled(
                mock => mock.RecalculateNemesis(
                    Arg <int> .Is.Equal(playersInGame[0]),
                    Arg <ApplicationUser> .Is.Equal(anonymousApplicationUser),
                    Arg <IDataContext> .Is.Anything),
                options => options.WhenCalled(y => _autoMocker.Get <IAchievementProcessor>().AssertWasNotCalled(
                                                  mock => mock.ProcessAchievements(playedGameEvent.TriggerEntityId))));

            //--make sure the nemesis recalculator was called for the second player in the game
            _autoMocker.Get <INemesisRecalculator>().AssertWasCalled(
                mock => mock.RecalculateNemesis(
                    Arg <int> .Is.Equal(playersInGame[1]),
                    Arg <ApplicationUser> .Is.Equal(anonymousApplicationUser),
                    Arg <IDataContext> .Is.Anything));

            _autoMocker.Get <IGamingGroupChampionRecalculator>().AssertWasCalled(mock => mock.RecalculateGamingGroupChampion(
                                                                                     Arg <int> .Is.Equal(playedGameEvent.TriggerEntityId)),
                                                                                 options => options.WhenCalled(y => _autoMocker.Get <IAchievementProcessor>().AssertWasNotCalled(
                                                                                                                   mock => mock.ProcessAchievements(playedGameEvent.TriggerEntityId))));

            //--make sure the achievement processor gets called
            _autoMocker.Get <IAchievementProcessor>().AssertWasCalled(
                mock => mock.ProcessAchievements(playedGameEvent.TriggerEntityId));
        }
Esempio n. 3
0
        public void It_Shows_The_Login_Widget_If_The_User_Is_Unauthenticated()
        {
            var user = new AnonymousApplicationUser();

            var viewResult = _autoMocker.ClassUnderTest.Index(user) as ViewResult;

            var model = viewResult.Model as HomeIndexViewModel;

            model.ShowLoginPartial.ShouldBe(true);
        }
Esempio n. 4
0
        public void The_Anonymous_User_Will_Have_No_Achievements_Unlocked()
        {
            //--arrange
            var anonymousUser = new AnonymousApplicationUser();

            //--act
            var results = _autoMocker.ClassUnderTest.GetAllAchievementSummaries(anonymousUser);

            //--assert
            results.Any(x => x.CurrentPlayerUnlockedThisAchievement).ShouldBeFalse();
        }
        internal void OnActionExecuting(
            ActionExecutingContext filterContext,
            ApplicationUserManager userManager,
            ClientIdCalculator clientIdCalculator)
        {
            if (filterContext.ActionParameters.ContainsKey(UserContextKey))
            {
                ApplicationUser applicationUser;

                if (filterContext.HttpContext.User.Identity.IsAuthenticated)
                {
                    var userId = filterContext.HttpContext.User.Identity.GetUserId();
                    applicationUser = userManager.FindByIdAsync(userId).Result;
                    if (RequiresGamingGroup &&
                        !applicationUser.CurrentGamingGroupId.HasValue &&
                        !filterContext.IsChildAction)
                    {
                        var url = CreateManageAccountUrl(filterContext.RequestContext);

                        filterContext.Result = new RedirectResult(url);
                    }
                }
                else
                {
                    applicationUser = new AnonymousApplicationUser();
                    if (RequiresGamingGroup)
                    {
                        filterContext.Result = new RedirectToRouteResult(MVC.Account.Login().GetRouteValueDictionary());
                    }
                }

                applicationUser.AnonymousClientId = clientIdCalculator.GetClientId(filterContext.HttpContext.Request, applicationUser);

                filterContext.ActionParameters[UserContextKey] = applicationUser;
            }

            base.OnActionExecuting(filterContext);
        }
Esempio n. 6
0
        private int UpdateBoardGameGeekDefinitions(List <BoardGameGeekGameDefinition> boardGameGeekGameDefinitions)
        {
            var anonymousUser     = new AnonymousApplicationUser();
            int totalGamesUpdated = 0;

            foreach (var existingBoardGameGeekGameDefinition in boardGameGeekGameDefinitions)
            {
                //delay between BGG calls to decrease likelyhood of getting blocked by BGG
                Thread.Sleep(400);
                var gameDetails = _boardGameGeekApiClient.GetGameDetails(existingBoardGameGeekGameDefinition.Id);

                if (gameDetails != null)
                {
                    existingBoardGameGeekGameDefinition.DateUpdated = DateTime.UtcNow;

                    existingBoardGameGeekGameDefinition.AverageWeight = gameDetails.AverageWeight;
                    existingBoardGameGeekGameDefinition.Description   = gameDetails.Description;
                    existingBoardGameGeekGameDefinition.MaxPlayTime   = gameDetails.MaxPlayTime;
                    existingBoardGameGeekGameDefinition.MinPlayTime   = gameDetails.MinPlayTime;
                    existingBoardGameGeekGameDefinition.MaxPlayers    = gameDetails.MaxPlayers;
                    existingBoardGameGeekGameDefinition.MinPlayers    = gameDetails.MinPlayers;
                    existingBoardGameGeekGameDefinition.Name          = gameDetails.Name;
                    existingBoardGameGeekGameDefinition.Thumbnail     = gameDetails.Thumbnail;
                    existingBoardGameGeekGameDefinition.Image         = gameDetails.Image;
                    existingBoardGameGeekGameDefinition.YearPublished = gameDetails.YearPublished;

                    foreach (var gameCategory in gameDetails.Categories)
                    {
                        if (
                            existingBoardGameGeekGameDefinition.Categories.All(
                                c => !c.CategoryName.Equals(gameCategory.Category, StringComparison.InvariantCultureIgnoreCase)))
                        {
                            var existentCategory =
                                _dataContext.GetQueryable <BoardGameGeekGameCategory>()
                                .FirstOrDefault(
                                    c =>
                                    c.CategoryName.Equals(gameCategory.Category,
                                                          StringComparison.InvariantCultureIgnoreCase));
                            if (existentCategory == null)
                            {
                                existentCategory = new BoardGameGeekGameCategory()
                                {
                                    BoardGameGeekGameCategoryId = gameCategory.Id,
                                    CategoryName = gameCategory.Category
                                };
                            }

                            existingBoardGameGeekGameDefinition.Categories.Add(existentCategory);
                        }
                    }

                    foreach (var gameMechanic in gameDetails.Mechanics)
                    {
                        if (
                            existingBoardGameGeekGameDefinition.Mechanics.All(
                                c => !c.MechanicName.Equals(gameMechanic.Mechanic, StringComparison.InvariantCultureIgnoreCase)))
                        {
                            var existentMechanic =
                                _dataContext.GetQueryable <BoardGameGeekGameMechanic>()
                                .FirstOrDefault(
                                    c =>
                                    c.MechanicName.Equals(gameMechanic.Mechanic,
                                                          StringComparison.InvariantCultureIgnoreCase));
                            if (existentMechanic == null)
                            {
                                existentMechanic = new BoardGameGeekGameMechanic()
                                {
                                    BoardGameGeekGameMechanicId = gameMechanic.Id,
                                    MechanicName = gameMechanic.Mechanic
                                };
                            }

                            existingBoardGameGeekGameDefinition.Mechanics.Add(existentMechanic);
                        }
                    }

                    _dataContext.Save(existingBoardGameGeekGameDefinition, anonymousUser);

                    if (totalGamesUpdated++ % 10 == 0)
                    {
                        _dataContext.CommitAllChanges();
                        Console.WriteLine("{0} BoardGameGeekGameDefinitions updated so far...", totalGamesUpdated);
                    }
                }
            }
            _dataContext.CommitAllChanges();

            return(totalGamesUpdated);
        }