private Func <Task <CacheResult <StoredGuild> > > GetFromSource(string guildName, int profileId, StoredRealm realm)
{
return(async() =>
{
var json = await this.blizzardService.GetGuildAsync(
guildName,
realm.Name,
BlizzardUtilities.GetBlizzardRegionFromEfRegion((EfEnums.GameRegionEnum)realm.Region.Id));
if (BlizzardService.DidGetFail(json))
{
return null;
}
var guild = ExternalServices.Blizzard.JsonParsing.GuildParsing.GetGuild(json);
return new CacheResult <StoredGuild>()
{
Found = true,
Result = new StoredGuild()
{
Name = guild.Name,
ProfileId = profileId,
RealmId = realm.Id
}
};
});
}
private async Task SendStatsCompleteNotifications(IServiceProvider serviceProvider, string key, BlizzardRegion region, string realm, string guild)
{
using (var serviceScope = serviceProvider.CreateScope())
{
var repo = serviceScope.ServiceProvider.GetService <IDataRepository>();
var notifications = await repo.GetAndClearNotifications(NotificationRequestTypeEnum.RaiderIoStatsRequestComplete, key);
string url = $"raideriostats/{region.ToString()}/{BlizzardService.FormatGuildName(guild)}/{BlizzardService.FormatRealmName(realm)}";
List <Task> mailTasks = new List <Task>();
var generatedEmail = this.mailGenerator.GenerateStatsCompleteEmail(url);
foreach (var notification in notifications)
{
mailTasks.Add(this.mailSender.SendMailAsync(
notification.Email,
this.commonValues.AdminEmail,
generatedEmail.Subject,
generatedEmail.TextContent,
generatedEmail.HtmlContent));
}
await Task.WhenAll(mailTasks);
}
}
public async Task TestRealmsGetter()
{
const string connectionString = "Data Source=(LocalDb)\\MSSQLLocalDB;Initial Catalog=GuildTools;Integrated Security=True";
KeyedResourceManager manager = new KeyedResourceManager();
BlizzardApiSecrets blizzardSecrets = new BlizzardApiSecrets()
{
ClientId = this.config.GetValue <string>("BlizzardApiSecrets:ClientId"),
ClientSecret = this.config.GetValue <string>("BlizzardApiSecrets:ClientSecret")
};
HttpClient client = new HttpClient();
IMemoryCache memoryCache = new MemoryCache(new MemoryCacheOptions());
GuildToolsContext context = new GuildToolsContext(SqlServerDbContextOptionsExtensions.UseSqlServer(new DbContextOptionsBuilder(), connectionString).Options as DbContextOptions);
IDatabaseCache dbCache = new DatabaseCache(context) as IDatabaseCache;
IDataRepository repo = new DataRepository(context);
IBlizzardService blizzardService = new BlizzardService(repo, this.config, client);
RealmsCache cache = new RealmsCache(blizzardService, memoryCache, dbCache, manager);
DateTime initial = DateTime.Now;
var realms = await cache.GetRealms(EF.Models.Enums.GameRegionEnum.US);
DateTime second = DateTime.Now;
TimeSpan sinceInitial = second - initial;
var realms2 = await cache.GetRealms(EF.Models.Enums.GameRegionEnum.US);
DateTime third = DateTime.Now;
TimeSpan sinceSecond = third - second;
int x = 42;
}
public async Task <FriendGuild> AddFriendGuild([FromBody] AddFriendGuild input)
{
InputValidators.ValidateGuildName(input.GuildName);
InputValidators.ValidateRealmName(input.RealmName);
input.GuildName = BlizzardService.FormatGuildName(input.GuildName);
input.RealmName = BlizzardService.FormatRealmName(input.RealmName);
var regionEnum = GameRegionUtilities.GetGameRegionFromString(input.RegionName);
var user = await this.userManager.GetUserAsync(HttpContext.User);
if (!(await this.UserCanAddRemoveFriendGuilds(input.ProfileId, user)))
{
throw new UserReportableError($"This user does not have permission to add friend guilds for profile '{input.ProfileId}'.",
(int)HttpStatusCode.Unauthorized);
}
var storedRealm = await this.realmStoreByValues.GetRealmAsync(input.RealmName, regionEnum);
if (storedRealm == null)
{
throw new UserReportableError($"Could not locate realm '{input.RealmName}'.", (int)HttpStatusCode.BadRequest);
}
var storedGuild = await this.guildStore.GetGuildAsync(input.GuildName, storedRealm, input.ProfileId);
if (storedGuild == null)
{
throw new UserReportableError($"Could not locate guild '{input.GuildName}'.", (int)HttpStatusCode.BadRequest);
}
var efFriendGuild = await this.dataRepo.AddFriendGuild(input.ProfileId, storedGuild);
return(this.mapper.Map <FriendGuild>(efFriendGuild));
}
private string GetKey(string realm, string guild)
{
realm = BlizzardService.FormatRealmName(realm);
guild = BlizzardService.FormatRealmName(guild);
return($"{realm}:{guild}");
}
public async Task <int> CreateGuildProfile([FromBody] CreateNewGuildProfile input)
{
InputValidators.ValidateProfileName(input.ProfileName);
InputValidators.ValidateGuildName(input.GuildName);
InputValidators.ValidateRealmName(input.GuildRealmName);
input.GuildName = BlizzardService.FormatGuildName(input.GuildName);
input.GuildRealmName = BlizzardService.FormatRealmName(input.GuildRealmName);
var regionEnum = GameRegionUtilities.GetGameRegionFromString(input.RegionName);
var user = await this.userManager.GetUserAsync(HttpContext.User);
if (user == null && !input.IsPublic)
{
throw new UserReportableError("Must be authenticated to create a private profile.", (int)HttpStatusCode.Unauthorized);
}
var locatedRealm = await this.realmStoreByValues.GetRealmAsync(input.GuildRealmName, regionEnum);
if (locatedRealm == null)
{
throw new UserReportableError($"Couldn't locate realm '{input.GuildRealmName}'.", 404);
}
var locatedGuild = await this.guildCache.GetGuild(regionEnum, input.GuildName, input.GuildRealmName);
if (locatedGuild == null)
{
throw new UserReportableError("Could not locate this guild.", 404);
}
return(await this.dataRepo.CreateGuildProfileAsync(user?.Id, input.ProfileName, locatedGuild, locatedRealm, regionEnum, input.IsPublic));
}
public async Task <GuildFound> GuildExists(string region, string guild, string realm)
{
InputValidators.ValidateGuildName(guild);
InputValidators.ValidateRealmName(realm);
guild = BlizzardService.FormatGuildName(guild);
realm = BlizzardService.FormatRealmName(realm);
var regionEnum = GameRegionUtilities.GetGameRegionFromString(region);
var locatedGuild = await this.guildCache.GetGuild(regionEnum, guild, realm);
if (locatedGuild == null)
{
return(new GuildFound()
{
Found = false
});
}
return(new GuildFound()
{
Found = true,
RealmName = locatedGuild.Realm,
GuildName = locatedGuild.Name
});
}
public async Task <RaiderIoStatsResponse> GetRaiderIoStats(string region, string guild, string realm)
{
guild = BlizzardService.FormatGuildName(guild);
realm = BlizzardService.FormatRealmName(realm);
BlizzardRegion regionEnum = BlizzardService.GetRegionFromString(region);
return(await this.GetRaiderIoResponse(regionEnum, realm, guild));
}
public async Task <string> GetMythicPlusDungeonData(BlizzardRegion region, string playerName, string realm)
{
string url = $"https://raider.io/api/v1/characters/profile?region={region.ToString().ToLower()}&"
+ $"realm={BlizzardService.FormatRealmName(realm)}&name={playerName}&fields=mythic_plus_scores";
var result = await this.throttler.Throttle(async() => { return(await client.GetAsync(url)); });
return(await result.Content.ReadAsStringAsync());
}
private Func <Task <StoredRealm> > GetFromDatabase(string name, EfEnums.GameRegionEnum region)
{
return(async() =>
{
return await this.context.StoredRealms
.Include(r => r.Region)
.SingleOrDefaultAsync(x => x.Slug == BlizzardService.BuildRealmSlug(name) &&
x.RegionId == (int)region);
});
}
public async Task <Realm> GetRealmAsync(string realmName, BlizzardRegion region)
{
var result = await this.blizzardService.GetRealmAsync(realmName, region);
if (BlizzardService.DidGetFail(result))
{
return(null);
}
return(RealmParsing.GetSingleRealm(result));
}
public async Task PlayerStoreTest()
{
const string connectionString = "Data Source=(LocalDb)\\MSSQLLocalDB;Initial Catalog=GuildTools;Integrated Security=True";
KeyedResourceManager manager = new KeyedResourceManager();
BlizzardApiSecrets blizzardSecrets = new BlizzardApiSecrets()
{
ClientId = this.config.GetValue <string>("BlizzardApiSecrets:ClientId"),
ClientSecret = this.config.GetValue <string>("BlizzardApiSecrets:ClientSecret")
};
IMemoryCache memoryCache = new MemoryCache(new MemoryCacheOptions());
GuildToolsContext context = new GuildToolsContext(SqlServerDbContextOptionsExtensions.UseSqlServer(new DbContextOptionsBuilder(), connectionString).Options as DbContextOptions);
HttpClient client = new HttpClient();
IDataRepository repo = new DataRepository(context);
IBlizzardService blizzardService = new BlizzardService(repo, this.config, client);
PerRequestCallThrottler throttler = new PerRequestCallThrottler(TimeSpan.FromSeconds(1));
IGuildService guildService = new GuildService(blizzardService, throttler);
int profileId = 1;
GameRegion region = new GameRegion()
{
Id = 1,
RegionName = "US"
};
StoredRealm realm = context.StoredRealms.Include(a => a.Region).First();
StoredGuild guild = context.StoredGuilds.First();
PlayerStoreByValue playerStore = new PlayerStoreByValue(guildService, memoryCache, context, manager);
DateTime initial = DateTime.Now;
var realms = await playerStore.GetPlayerAsync("Kromp", realm, guild, profileId);
DateTime second = DateTime.Now;
TimeSpan sinceInitial = second - initial;
var realms2 = await playerStore.GetPlayerAsync("Kromp", realm, guild, profileId);
DateTime third = DateTime.Now;
TimeSpan sinceSecond = third - second;
var realms3 = await playerStore.GetPlayerAsync("Kromp", realm, guild, profileId);
DateTime fourth = DateTime.Now;
TimeSpan sinceThird = fourth - third;
int x = 42;
}
public async Task <GuildSlim> GetGuild(BlizzardRegion region, string realmName, string guildName)
{
guildName = BlizzardService.FormatGuildName(guildName);
realmName = BlizzardService.FormatRealmName(realmName);
var result = await this.blizzardService.GetGuildAsync(guildName, realmName, region);
if (BlizzardService.DidGetFail(result))
{
return(null);
}
return(GuildParsing.GetGuild(result));
}
public async Task RequestStatsCompleteNotification([FromBody] RequestStatsCompleteNotification input)
{
input.Guild = BlizzardService.FormatGuildName(input.Guild);
input.Realm = BlizzardService.FormatRealmName(input.Realm);
BlizzardRegion regionEnum = BlizzardService.GetRegionFromString(input.Region);
if (!RegexUtilities.IsValidEmail(input.Email))
{
throw new UserReportableError("Email is not in a valid format.", (int)HttpStatusCode.BadRequest);
}
var key = this.guildStatsRetriever.GetKey(regionEnum, input.Realm, input.Guild);
await this.dataRepo.AddNotification(input.Email, key, (NotificationRequestTypeEnum)input.RequestType);
}
public async Task <IEnumerable <GuildMemberStats> > GetLargeGuildMembersDataAsync(BlizzardRegion region, string guild, string realm, IProgress <double> progress)
{
var guildDataJson = await this.blizzardService.GetGuildMembersAsync(guild, realm, region);
var members = GuildMemberParsing.GetSlimPlayersFromGuildPlayerList(guildDataJson).ToList();
foreach (var member in members)
{
member.RegionName = BlizzardService.GetRegionString(region);
member.GuildName = guild;
}
int totalCount = members.Count();
int count = 0;
var taskList = new List <Task <GuildMemberStats> >();
foreach (var member in members)
{
taskList.Add(Task.Run(async() =>
{
try
{
if (await this.PopulateMemberDataAsync(member, region))
{
return(member);
}
return(null);
}
catch (Exception e)
{
return(null);
}
finally
{
progress.Report((double)count++ / totalCount);
}
}));
}
await Task.WhenAll(taskList);
return(taskList.Select(x => x.Result).Where(x => x != null));
}
public async Task CachedStoredValueTest()
{
const string connectionString = "Data Source=(LocalDb)\\MSSQLLocalDB;Initial Catalog=GuildTools;Integrated Security=True";
KeyedResourceManager manager = new KeyedResourceManager();
BlizzardApiSecrets blizzardSecrets = new BlizzardApiSecrets()
{
ClientId = this.config.GetValue <string>("BlizzardApiSecrets:ClientId"),
ClientSecret = this.config.GetValue <string>("BlizzardApiSecrets:ClientSecret")
};
IMemoryCache memoryCache = new MemoryCache(new MemoryCacheOptions());
GuildToolsContext context = new GuildToolsContext(SqlServerDbContextOptionsExtensions.UseSqlServer(new DbContextOptionsBuilder(), connectionString).Options as DbContextOptions);
HttpClient client = new HttpClient();
IDataRepository repo = new DataRepository(context);
IBlizzardService blizzardService = new BlizzardService(repo, this.config, client);
PerRequestCallThrottler throttler = new PerRequestCallThrottler(TimeSpan.FromSeconds(1));
IGuildService guildService = new GuildService(blizzardService, throttler);
RealmStoreByValues store = new RealmStoreByValues(guildService, memoryCache, context, manager);
DateTime initial = DateTime.Now;
var realms = await store.GetRealmAsync("Burning Blade", EF.Models.Enums.GameRegionEnum.US);
DateTime second = DateTime.Now;
TimeSpan sinceInitial = second - initial;
var realms2 = await store.GetRealmAsync("Burning Blade", EF.Models.Enums.GameRegionEnum.US);
DateTime third = DateTime.Now;
TimeSpan sinceSecond = third - second;
var realms3 = await store.GetRealmAsync("Akama", EF.Models.Enums.GameRegionEnum.US);
DateTime fourth = DateTime.Now;
TimeSpan sinceThird = fourth - third;
int x = 42;
}
public async Task <BlizzardPlayer> GetSinglePlayerAsync(BlizzardRegion region, string realmName, string playerName)
{
var playerJson = await this.blizzardService.GetPlayerAsync(playerName, realmName, region);
if (BlizzardService.DidGetFail(playerJson))
{
return(null);
}
var player = PlayerParsing.GetSinglePlayerFromJson(playerJson);
return(new BlizzardPlayer()
{
PlayerName = player.Name,
Class = player.Class,
Level = player.Level,
GuildName = player.GuildName,
GuildRealm = player.GuildRealm,
PlayerRealmName = player.Realm
});
}
public static PlayerItemDetails GetItemsDetailsFromJson(string json)
{
PlayerItemDetails itemDetails = new PlayerItemDetails();
var jObject = JsonConvert.DeserializeObject(json) as JObject;
var items = jObject.SelectToken("items");
var lastModified = jObject.SelectToken("lastModified").ToString();
itemDetails.LastModifiedDateTime = BlizzardService.FromUnixTime(long.Parse(lastModified));
itemDetails.EquippedIlvl = int.Parse(items["averageItemLevelEquipped"].ToString());
itemDetails.MaximumIlvl = int.Parse(items["averageItemLevel"].ToString());
var neckNode = items.SelectToken("neck");
if (neckNode["name"].ToString() == "Heart of Azeroth")
{
itemDetails.AzeriteLevel = int.Parse(neckNode.SelectToken("azeriteItem.azeriteLevel").ToString());
}
return(itemDetails);
}
public async Task <PlayerFound> PlayerExists(string region, string playerName, string realm)
{
InputValidators.ValidateRealmName(realm);
InputValidators.ValidatePlayerName(playerName);
realm = BlizzardService.FormatRealmName(realm);
var regionEnum = GameRegionUtilities.GetGameRegionFromString(region);
var locatedPlayer = await this.playerCache.GetPlayer(regionEnum, playerName, realm);
if (locatedPlayer == null)
{
return(new PlayerFound()
{
Found = false
});
}
return(new PlayerFound()
{
Found = true,
PlayerDetails = locatedPlayer
});
}
private string GetKey(BlizzardRegion region, string realm, string guild)
{
return($"{BlizzardService.GetRegionString(region)}:{realm}:{guild}");
}
public static string GetRealmKey(string realmName)
{
return(BlizzardService.BuildRealmSlug(realmName));
}
