Exemplo n.º 1
0
        public async Task SaveAccountClanInfoAsync(long accountId, AccountClanInfo accountClanInfo)
        {
            var existingClanInfo = await _dbContext.AccountClanInfo
                                   .FirstOrDefaultAsync(c => c.AccountId == accountId);

            if (accountClanInfo == null || accountClanInfo.ClanId == 0)
            {
                // Account not in clan - delete clan info from DB
                if (existingClanInfo != null)
                {
                    _dbContext.Entry(existingClanInfo).State = EntityState.Deleted;
                    await _dbContext.SaveChangesAsync();
                }
                return;
            }

            if (existingClanInfo == null)
            {
                // Insert new clan info
                await _dbContext.AccountClanInfo.AddAsync(accountClanInfo);

                await _dbContext.SaveChangesAsync();

                return;
            }

            // Update clan info
            _dbContext.Entry(existingClanInfo).State = EntityState.Detached;
            accountClanInfo.AccountClanInfoId        = existingClanInfo.AccountClanInfoId;
            _dbContext.AccountClanInfo.Attach(accountClanInfo);
            _dbContext.Entry(accountClanInfo).State = EntityState.Modified;
            await _dbContext.SaveChangesAsync();
        }
Exemplo n.º 2
0
        public async Task SaveAccountClanInfoTest(
            long accountId,
            long dbClanId,
            long wgClanId,
            string dbPlayerRole,
            string wgPlayerRole)
        {
            var accountDataAccessor = _container.Resolve <IAccountDataAccessor>();

            if (dbClanId > 0)
            {
                var dbAccountClanInfo = new AccountClanInfo
                {
                    AccountId  = accountId,
                    ClanId     = dbClanId,
                    PlayerRole = dbPlayerRole
                };
                await _dbContext.AccountClanInfo.AddAsync(dbAccountClanInfo);

                await _dbContext.SaveChangesAsync();

                _dbContext.Entry(dbAccountClanInfo).State = EntityState.Detached;
            }

            var wgAccountClanInfo = new AccountClanInfo
            {
                AccountId  = accountId,
                ClanId     = wgClanId,
                PlayerRole = wgPlayerRole
            };

            await accountDataAccessor.SaveAccountClanInfoAsync(accountId, wgAccountClanInfo);

            var savedClanInfo = await _dbContext.AccountClanInfo
                                .SingleOrDefaultAsync(c => c.AccountId == accountId);

            if (wgClanId > 0)
            {
                Assert.NotNull(savedClanInfo);
                Assert.Equal(wgClanId, savedClanInfo.ClanId);
                Assert.Equal(wgPlayerRole, savedClanInfo.PlayerRole);
            }
            else
            {
                Assert.Null(savedClanInfo);
            }
        }
        public static async Task MergeLanguages(this BlitzStaticianDbContext dbContext, List <DictionaryLanguage> languages)
        {
            var langIds  = languages.Select(l => l.LanguageId);
            var existing = await dbContext.DictionaryLanguage
                           .Where(l => langIds.Contains(l.LanguageId))
                           .Select(l => l.LanguageId)
                           .AsNoTracking()
                           .ToListAsync();

            languages.ForEach(l =>
            {
                dbContext.DictionaryLanguage.Attach(l);
                dbContext.Entry(l).State = existing.Contains(l.LanguageId)
                                        ? EntityState.Modified
                                        : EntityState.Added;
            });
        }
Exemplo n.º 4
0
        public static async Task MergeNations(this BlitzStaticianDbContext dbContext, List <DictionaryNations> nations)
        {
            var nationIds = nations.Select(l => l.NationId);
            var existing  = await dbContext.DictionaryNation
                            .Where(l => nationIds.Contains(l.NationId))
                            .Select(l => l.NationId)
                            .AsNoTracking()
                            .ToListAsync();

            nations.ForEach(l =>
            {
                dbContext.DictionaryNation.Attach(l);
                dbContext.Entry(l).State = existing.Contains(l.NationId)
                                        ? EntityState.Modified
                                        : EntityState.Added;
            });
        }
        public static async Task MergeVehicles(this BlitzStaticianDbContext dbContext,
                                               List <VehicleEncyclopedia> vehicles)
        {
            var ids      = vehicles.Select(l => l.TankId);
            var existing = await dbContext.VehicleEncyclopedia
                           .Where(l => ids.Contains(l.TankId))
                           .Select(l => l.TankId)
                           .ToListAsync();

            vehicles.ForEach(v =>
            {
                dbContext.VehicleEncyclopedia.Attach(v);
                dbContext.Entry(v).State = existing.Contains(v.TankId)
                                        ? EntityState.Modified
                                        : EntityState.Added;
            });
        }
        public static async Task MergeVehicleType(this BlitzStaticianDbContext dbContext,
                                                  List <DictionaryVehicleType> vehicleTypes)
        {
            var ids      = vehicleTypes.Select(l => l.VehicleTypeId);
            var existing = await dbContext.DictionaryVehicleType
                           .Where(l => ids.Contains(l.VehicleTypeId))
                           .Select(l => l.VehicleTypeId)
                           .AsNoTracking()
                           .ToListAsync();

            vehicleTypes.ForEach(l =>
            {
                dbContext.DictionaryVehicleType.Attach(l);
                dbContext.Entry(l).State = existing.Contains(l.VehicleTypeId)
                                        ? EntityState.Modified
                                        : EntityState.Added;
            });
        }
Exemplo n.º 7
0
        public static async Task MergeAchievementSection(this BlitzStaticianDbContext dbContext,
                                                         List <AchievementSection> achievementSections)
        {
            var ids      = achievementSections.Select(l => l.Section);
            var existing = await dbContext.AchievementSection
                           .Where(l => ids.Contains(l.Section))
                           .Select(l => l.Section)
                           .AsNoTracking()
                           .ToListAsync();

            achievementSections.ForEach(l =>
            {
                dbContext.AchievementSection.Attach(l);
                dbContext.Entry(l).State = existing.Contains(l.Section)
                                        ? EntityState.Modified
                                        : EntityState.Added;
            });
        }
Exemplo n.º 8
0
        public static async Task MergeClanRoles(this BlitzStaticianDbContext dbContext,
                                                List <DictionaryClanRole> clanRoles)
        {
            var stopwatch = Stopwatch.StartNew();
            var ids       = clanRoles.Select(l => l.ClanRoleId);
            var existing  = await dbContext.DictionaryClanRole
                            .Where(l => ids.Contains(l.ClanRoleId))
                            .Select(l => l.ClanRoleId)
                            .AsNoTracking()
                            .ToListAsync();

            clanRoles.ForEach(l =>
            {
                dbContext.DictionaryClanRole.Attach(l);
                dbContext.Entry(l).State = existing.Contains(l.ClanRoleId)
                                        ? EntityState.Modified
                                        : EntityState.Added;
            });
            stopwatch.Stop();
        }
Exemplo n.º 9
0
        public async Task CreateClanHistoryOperationTest(
            long accountId,
            int databaseClanId,
            int wgClanId,
            string databasePlayerRole,
            string wgPlayerRole,
            bool historyMustBeCreated)
        {
            var operation = _container.Resolve <CreateAccountClanHistoryOperation>();

            // FillingDatabase
            if (databaseClanId > 0)
            {
                var clanInfo = new AccountClanInfo
                {
                    AccountId  = accountId,
                    ClanId     = databaseClanId,
                    PlayerRole = databasePlayerRole
                };
                await _dbContext.AccountClanInfo.AddAsync(clanInfo);

                await _dbContext.SaveChangesAsync();

                _dbContext.Entry(clanInfo).State = EntityState.Detached;
            }
            var operationContext = new StatisticsCollectorOperationContext
            {
                Accounts = new List <SatisticsCollectorAccountOperationContext>
                {
                    new SatisticsCollectorAccountOperationContext
                    {
                        WargamingAccountInfo = new AccountInfo
                        {
                            AccountId       = accountId,
                            AccountClanInfo = new AccountClanInfo
                            {
                                ClanId     = wgClanId,
                                PlayerRole = wgPlayerRole
                            }
                        },
                        CurrentAccountInfo = new AccountInfo
                        {
                            AccountId = accountId
                        }
                    }
                }
            };

            await operation.Execute(operationContext);

            var history = operationContext.Accounts.Single().AccountClanHistory;

            if (historyMustBeCreated)
            {
                Assert.NotNull(history);
                Assert.Equal(wgClanId, history.ClanId ?? 0);
                Assert.Equal(wgPlayerRole, history.PlayerRole);
            }
            else
            {
                Assert.Null(history);
            }
        }