private BoardGameGeekGameCategory GetOrCreateGameCategory(GameCategory gameCategory)
        {
            BoardGameGeekGameCategory category;

            category = _dataContext.GetQueryable <BoardGameGeekGameCategory>()
                       .FirstOrDefault(
                c =>
                c.CategoryName.Equals(gameCategory.Category,
                                      StringComparison.InvariantCultureIgnoreCase));
            if (category == null)
            {
                category = new BoardGameGeekGameCategory()
                {
                    BoardGameGeekGameCategoryId = gameCategory.Id,
                    CategoryName = gameCategory.Category
                };
            }
            return(category);
        }
예제 #2
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);
        }
        public BoardGameGeekGameDefinition CreateBoardGameGeekGameDefinition(int boardGameGeekGameDefinitionId, ApplicationUser currentUser)
        {
            try
            {
                var existingRecord = _dataContext.FindById <BoardGameGeekGameDefinition>(boardGameGeekGameDefinitionId);
                if (existingRecord != null)
                {
                    return(existingRecord);
                }
            }
            catch (EntityDoesNotExistException)
            {
                //this is OK, just means we need to create a new one
            }

            var gameDetails = _boardGameGeekApiClient.GetGameDetails(boardGameGeekGameDefinitionId);

            if (gameDetails == null)
            {
                return(null);
            }

            var newRecord = new BoardGameGeekGameDefinition
            {
                Id            = boardGameGeekGameDefinitionId,
                Name          = gameDetails.Name,
                Thumbnail     = gameDetails.Thumbnail,
                Image         = gameDetails.Image,
                MaxPlayers    = gameDetails.MaxPlayers,
                MinPlayers    = gameDetails.MinPlayers,
                MaxPlayTime   = gameDetails.MaxPlayTime,
                MinPlayTime   = gameDetails.MinPlayTime,
                AverageWeight = gameDetails.AverageWeight,
                Description   = gameDetails.Description,
                YearPublished = gameDetails.YearPublished,
                IsExpansion   = gameDetails.IsExpansion,
                Rank          = gameDetails.Rank
            };

            _dataContext.Save(newRecord, currentUser);

            // Save categories to BGG definition

            foreach (var category in gameDetails.Categories)
            {
                var existentCategory = _dataContext.GetQueryable <BoardGameGeekGameCategory>().FirstOrDefault(c => c.BoardGameGeekGameCategoryId == category.Id);

                if (existentCategory == null)
                {
                    existentCategory = new BoardGameGeekGameCategory()
                    {
                        BoardGameGeekGameCategoryId = category.Id,
                        CategoryName = category.Category
                    };
                }

                newRecord.Categories.Add(existentCategory);
            }

            foreach (var mechanic in gameDetails.Mechanics)
            {
                var existentMechanic = _dataContext.GetQueryable <BoardGameGeekGameMechanic>().FirstOrDefault(c => c.BoardGameGeekGameMechanicId == mechanic.Id);

                if (existentMechanic == null)
                {
                    existentMechanic = new BoardGameGeekGameMechanic()
                    {
                        BoardGameGeekGameMechanicId = mechanic.Id,
                        MechanicName = mechanic.Mechanic
                    };
                }

                newRecord.Mechanics.Add(existentMechanic);
            }

            return(newRecord);
        }
        public BoardGameGeekGameDefinition CreateBoardGameGeekGameDefinition(int boardGameGeekGameDefinitionId, ApplicationUser currentUser)
        {
            try
            {
                var existingRecord = _dataContext.FindById<BoardGameGeekGameDefinition>(boardGameGeekGameDefinitionId);
                if (existingRecord != null)
                {
                    return existingRecord;
                }
            }
            catch (EntityDoesNotExistException)
            {
                //this is OK, just means we need to create a new one
            }

            var gameDetails = _boardGameGeekApiClient.GetGameDetails(boardGameGeekGameDefinitionId);

            if (gameDetails == null)
            {
                return null;
            }

            var newRecord = new BoardGameGeekGameDefinition
            {
                Id = boardGameGeekGameDefinitionId,
                Name = gameDetails.Name,
                Thumbnail = gameDetails.Thumbnail,
                Image = gameDetails.Image,
                MaxPlayers = gameDetails.MaxPlayers,
                MinPlayers = gameDetails.MinPlayers,
                MaxPlayTime = gameDetails.MaxPlayTime,
                MinPlayTime = gameDetails.MinPlayTime,
                AverageWeight = gameDetails.AverageWeight,
                Description = gameDetails.Description,
                YearPublished = gameDetails.YearPublished,
                IsExpansion = gameDetails.IsExpansion,
                Rank = gameDetails.Rank
            };

            _dataContext.Save(newRecord, currentUser);

            // Save categories to BGG definition

            foreach (var category in gameDetails.Categories)
            {
                var existentCategory = _dataContext.GetQueryable<BoardGameGeekGameCategory>().FirstOrDefault(c => c.BoardGameGeekGameCategoryId == category.Id);

                if (existentCategory == null)
                {
                    existentCategory = new BoardGameGeekGameCategory()
                    {
                        BoardGameGeekGameCategoryId = category.Id,
                        CategoryName = category.Category
                    };
                }

                newRecord.Categories.Add(existentCategory);
            }

            foreach (var mechanic in gameDetails.Mechanics)
            {
                var existentMechanic = _dataContext.GetQueryable<BoardGameGeekGameMechanic>().FirstOrDefault(c => c.BoardGameGeekGameMechanicId == mechanic.Id);

                if (existentMechanic == null)
                {
                    existentMechanic = new BoardGameGeekGameMechanic()
                    {
                        BoardGameGeekGameMechanicId = mechanic.Id,
                        MechanicName = mechanic.Mechanic
                    };
                }

                newRecord.Mechanics.Add(existentMechanic);
            }

            return newRecord;
        }
        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;
        }