internal async Task UpdatePlayerAsync(CachedPlayer cachedPlayer)
{
if (_stopRequestedTokenSource.IsCancellationRequested ||
_playersClientBase.UpdatingVillage.TryAdd(cachedPlayer.Tag, null) == false)
{
return;
}
try
{
CachedPlayer?fetched = await CachedPlayer
.FromPlayerResponseAsync(cachedPlayer.Tag, _playersClientBase, _playersApi, _stopRequestedTokenSource.Token)
.ConfigureAwait(false);
if (fetched.Data != null && _playersClientBase.HasUpdated(cachedPlayer, fetched))
{
_playersClientBase.OnPlayerUpdated(cachedPlayer.Data, fetched.Data);
}
cachedPlayer.UpdateFrom(fetched);
}
finally
{
_playersClientBase.UpdatingVillage.TryRemove(cachedPlayer.Tag, out _);
}
}
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);
}
public async Task DeleteAsync(string tag)
{
string formattedTag = Clash.FormatTag(tag);
using var scope = Services.CreateScope();
CacheContext dbContext = scope.ServiceProvider.GetRequiredService <CacheContext>();
while (!UpdatingVillage.TryAdd(formattedTag, new byte()))
{
await Task.Delay(500);
}
try
{
CachedPlayer cachedPlayer = await dbContext.Players.FirstOrDefaultAsync(c => c.Tag == formattedTag);
if (cachedPlayer != null)
{
dbContext.Players.Remove(cachedPlayer);
}
await dbContext.SaveChangesAsync();
}
finally
{
UpdatingVillage.TryRemove(formattedTag, out _);
}
}
public async Task <CachedPlayer> UpdateAsync(string tag, bool download = true)
{
string formattedTag = Clash.FormatTag(tag);
using var scope = Services.CreateScope();
CacheContext cacheContext = scope.ServiceProvider.GetRequiredService <CacheContext>();
CachedPlayer cachedPlayer = await cacheContext.Players
.FirstOrDefaultAsync(v => v.Tag == formattedTag)
.ConfigureAwait(false);
if (cachedPlayer != null && cachedPlayer.Download == download)
{
return(cachedPlayer);
}
if (cachedPlayer == null)
{
cachedPlayer = new CachedPlayer(formattedTag);
cacheContext.Players.Add(cachedPlayer);
}
cachedPlayer.Download = download;
await cacheContext.SaveChangesAsync().ConfigureAwait(false);
return(cachedPlayer);
}
private async Task MonitorMemberAsync(CachedPlayer cached)
{
if (cached.ServerExpiration > DateTime.UtcNow.AddSeconds(3) || cached.LocalExpiration > DateTime.UtcNow)
{
return;
}
await _playersClientBase.PlayerMontitor.UpdatePlayerAsync(cached);
}
private static void OnPlayerJoined(Player player)
{
if (player.prop_APIUser_0 == null || (player.prop_APIUser_0.IsSelf && cachedPlayers.Any(user => user.id == APIUser.CurrentUser.id)))
{
return;
}
for (int i = 0; i < cachedPlayers.Count; i++)
{
if ((cachedPlayers[i].timeJoined - DateTime.Now).TotalHours > 0)
{
cachedPlayers[i] = new CachedPlayer(cachedPlayers[i].id, cachedPlayers[i].name, null, cachedPlayers[i].timeJoined);
}
}
cachedPlayers.Insert(0, new CachedPlayer(player.prop_APIUser_0.id, player.prop_APIUser_0.displayName, player.prop_APIUser_0, DateTime.Now));
}
internal bool HasUpdated(CachedPlayer stored, CachedPlayer fetched)
{
if (stored.Data == null && fetched.Data != null)
{
return(true);
}
if (stored.ServerExpiration > fetched.ServerExpiration)
{
return(false);
}
if (stored.Data == null || fetched.Data == null)
{
return(false);
}
return(HasUpdated(stored.Data, fetched.Data));
}
internal async Task <Player?> GetAsync(string tag, CancellationToken?cancellationToken = default)
{
CachedPlayer result = await GetCachedPlayerAsync(tag, cancellationToken);
return(result.Data);
}
