Esempio n. 1
0
        /// <summary>
        /// Inserts the missing achievements.
        /// </summary>
        /// <param name="missingAchievements">The missing achievements.</param>
        public void InsertMissingAchievements(ICollection <Achievement> missingAchievements)
        {
            if (missingAchievements == null)
            {
                throw new ArgumentNullException("missingAchievements");
            }

            if (missingAchievements.Count == 0)
            {
                return;
            }

            foreach (Achievement achievement in missingAchievements)
            {
                Achievement newAchievement = new Achievement
                {
                    ApiName  = achievement.ApiName,
                    GameId   = achievement.GameId,
                    ImageUrl = achievement.ImageUrl
                };
                AchievementName name = achievement.AchievementNames.First();
                AchievementName newAchievementName = new AchievementName
                {
                    Language    = name.Language,
                    Name        = name.Name,
                    Description = name.Description
                };
                newAchievement.AchievementNames.Add(newAchievementName);
                _repository.InsertOnSubmit(newAchievement);
            }

            _repository.SubmitChanges();
        }
Esempio n. 2
0
        /// <summary>
        /// Inserts the missing achievement names.
        /// </summary>
        /// <param name="missingAchievementNames">The missing achievement names.</param>
        /// <returns></returns>
        private void InsertMissingAchievementNames(ICollection <AchievementName> missingAchievementNames)
        {
            if (missingAchievementNames == null)
            {
                throw new ArgumentNullException("missingAchievementNames");
            }

            if (missingAchievementNames.Count == 0)
            {
                return;
            }

            foreach (AchievementName achievementName in missingAchievementNames)
            {
                AchievementName newAchievementName = new AchievementName
                {
                    AchievementId = achievementName.AchievementId,
                    Language      = achievementName.Language,
                    Name          = achievementName.Name,
                    Description   = achievementName.Description
                };
                _repository.InsertOnSubmit(newAchievementName);
            }

            _repository.SubmitChanges();
        }
Esempio n. 3
0
        /// <summary>
        /// Gets the missing database achievement names.
        /// </summary>
        /// <param name="communityAchievements">The community achievements.</param>
        /// <returns></returns>
        private ICollection <AchievementName> GetMissingAchievementNames(ICollection <Achievement> communityAchievements)
        {
            if (communityAchievements == null)
            {
                throw new ArgumentNullException("communityAchievements");
            }

            if (communityAchievements.Count == 0)
            {
                return(new AchievementName[0]);
            }

            var communityAchievementKeys =
                from achievement in communityAchievements
                from name in achievement.AchievementNames
                select new
            {
                achievement.GameId,
                achievement.ApiName,
                name.Language
            };

            IEnumerable <int>    gameIds  = communityAchievementKeys.Select(key => key.GameId).Distinct();
            IEnumerable <string> apiNames = communityAchievementKeys.Select(key => key.ApiName).Distinct();

            var dbAchievementNames =
                (from achievement in _repository.Achievements
                 where gameIds.Contains(achievement.GameId) &&
                 apiNames.Contains(achievement.ApiName)
                 select
                 new
            {
                achievement.Id,
                achievement.GameId,
                achievement.ApiName,
                Languages = achievement.AchievementNames.Select(name => name.Language)
            }).ToList();

            List <AchievementName> missingAchievementNames = new List <AchievementName>();

            //if (communityAchievements.Count != dbAchievementNames.Count)
            {
                foreach (AchievementName achievementName in communityAchievements.SelectMany(a => a.AchievementNames))
                {
                    AchievementName communityName = achievementName;
                    var             key           =
                        dbAchievementNames.Where(
                            a => a.GameId == communityName.Achievement.GameId &&
                            a.ApiName == communityName.Achievement.ApiName)
                        .SingleOrDefault();

                    if (key != null && !key.Languages.Contains(communityName.Language))
                    {
                        missingAchievementNames.Add(new AchievementName
                        {
                            AchievementId = key.Id,
                            Language      = communityName.Language,
                            Name          = communityName.Name,
                            Description   = communityName.Description
                        });
                    }
                }
            }

            return(missingAchievementNames);
        }
 /// <summary>
 /// Inserts the on submit.
 /// </summary>
 /// <param name="achievementName">Name of the achievement.</param>
 public void InsertOnSubmit(AchievementName achievementName)
 {
     _context.AchievementNames.InsertOnSubmit(achievementName);
 }
 partial void DeleteAchievementName(AchievementName instance);
 partial void UpdateAchievementName(AchievementName instance);
 partial void InsertAchievementName(AchievementName instance);
 private void detach_AchievementNames(AchievementName entity)
 {
     this.SendPropertyChanging();
     entity.Achievement = null;
 }