private async Task <CachedClan> PrepareNewCachedClanAsync(string formattedTag, bool downloadWars, bool downloadCwl, bool downloadMembers, CacheContext dbContext)
{
CachedClan cachedClan = new CachedClan(formattedTag)
{
DownloadCurrentWar = downloadWars,
DownloadCwl = downloadCwl,
DownloadMembers = downloadMembers
};
dbContext.Clans.Add(cachedClan);
CachedClanWar cachedClanWar = await dbContext.ClanWars
.Where(w => w.Tag == formattedTag)
.FirstOrDefaultAsync(_stopRequestedTokenSource.Token)
.ConfigureAwait(false);
if (cachedClanWar == null)
{
cachedClanWar = new CachedClanWar(formattedTag);
dbContext.ClanWars.Add(cachedClanWar);
}
dbContext.Groups.Add(new CachedClanWarLeagueGroup(formattedTag));
dbContext.WarLogs.Add(new CachedClanWarLog(formattedTag));
return(cachedClan);
}
public async Task AddOrUpdateAsync(IEnumerable <string> tags, bool downloadWars = true, bool downloadCwl = true, bool downloadMembers = false)
{
List <string> formattedTags = new List <string>();
foreach (string tag in tags)
{
formattedTags.Add(Clash.FormatTag(tag));
}
using var scope = Services.CreateScope();
CacheContext dbContext = scope.ServiceProvider.GetRequiredService <CacheContext>();
List <CachedClan> cachedClans = await dbContext.Clans
.Where(c => formattedTags.Contains(c.Tag))
.ToListAsync()
.ConfigureAwait(false);
foreach (string formattedTag in formattedTags)
{
CachedClan cachedClan = cachedClans.FirstOrDefault(c => c.Tag == formattedTag) ??
await PrepareNewCachedClanAsync(formattedTag, downloadWars, downloadCwl, downloadMembers, dbContext).ConfigureAwait(false);
cachedClan.Tag = formattedTag;
cachedClan.DownloadCurrentWar = downloadWars;
cachedClan.DownloadCwl = downloadCwl;
cachedClan.DownloadMembers = downloadMembers;
}
await dbContext.SaveChangesAsync().ConfigureAwait(false);
}
private async Task MonitorMembersAsync(CachedClan cached)
{
if (_stopRequestedTokenSource.IsCancellationRequested || cached.Data == null)
{
return;
}
List <Task> tasks = new List <Task>();
using var scope = Services.CreateScope();
CacheContext dbContext = scope.ServiceProvider.GetRequiredService <CacheContext>();
List <CachedPlayer> players = await dbContext.Players.Where(p => cached.Data.Members.Select(m => m.Tag).Contains(p.Tag)).ToListAsync();
foreach (Model.ClanMember member in cached.Data.Members.Where(m => !players.Any(p => p.Tag == m.Tag)))
{
CachedPlayer player = new CachedPlayer(member.Tag);
dbContext.Players.Add(player);
players.Add(player);
}
foreach (Model.ClanMember?member in cached.Data.Members)
{
tasks.Add(MonitorMemberAsync(players.Single(p => p.Tag == member.Tag)));
}
await Task.WhenAll(tasks);
await dbContext.SaveChangesAsync(_stopRequestedTokenSource.Token);
}
internal bool HasUpdated(CachedClan stored, CachedClan fetched)
{
if (stored.ServerExpiration > fetched.ServerExpiration)
{
return(false);
}
if (stored.Data == null || fetched.Data == null)
{
return(false);
}
return(HasUpdated(stored.Data, fetched.Data));
}
public async Task AddAsync(string tag, bool downloadWars = true, bool downloadCwl = true, bool downloadMembers = false)
{
string formattedTag = Clash.FormatTag(tag);
using var scope = Services.CreateScope();
CacheContext dbContext = scope.ServiceProvider.GetRequiredService <CacheContext>();
CachedClan cachedClan = await dbContext.Clans.Where(c => c.Tag == formattedTag).FirstOrDefaultAsync().ConfigureAwait(false);
cachedClan ??= await PrepareNewCachedClanAsync(formattedTag, downloadWars, downloadCwl, downloadMembers, dbContext).ConfigureAwait(false);
await dbContext.SaveChangesAsync().ConfigureAwait(false);
return;
}
public async Task DeleteAsync(string tag)
{
string formattedTag = Clash.FormatTag(tag);
using var scope = Services.CreateScope();
CacheContext dbContext = scope.ServiceProvider.GetRequiredService <CacheContext>();
while (!_clanMonitor.UpdatingClan.TryAdd(formattedTag, new byte()))
{
await Task.Delay(500);
}
while (!UpdatingClanWar.TryAdd(formattedTag, new byte()))
{
await Task.Delay(500);
}
try
{
CachedClan cachedClan = await dbContext.Clans.FirstOrDefaultAsync(c => c.Tag == formattedTag);
CachedClanWarLog cachedClanWarLog = await dbContext.WarLogs.FirstOrDefaultAsync(c => c.Tag == formattedTag);
if (cachedClan != null)
{
dbContext.Clans.Remove(cachedClan);
}
if (cachedClanWarLog != null)
{
dbContext.WarLogs.Remove(cachedClanWarLog);
}
await dbContext.SaveChangesAsync();
}
finally
{
_clanMonitor.UpdatingClan.TryRemove(formattedTag, out _);
UpdatingClanWar.TryRemove(formattedTag, out _);
}
}
private async Task MonitorClanAsync(CachedClan cached)
{
if (_stopRequestedTokenSource.IsCancellationRequested ||
UpdatingClan.TryAdd(cached.Tag, new byte()) == false)
{
return;
}
try
{
CachedClan fetched = await CachedClan.FromClanResponseAsync(cached.Tag, _clansClient, _clansApi, _stopRequestedTokenSource.Token);
if (cached.Data != null && fetched.Data != null && _clansClient.HasUpdated(cached, fetched))
{
_clansClient.OnClanUpdated(cached.Data, fetched.Data);
}
cached.UpdateFrom(fetched);
}
finally
{
UpdatingClan.TryRemove(cached.Tag, out _);
}
}
