public async Task GetRankHistoryCommand(CommandContext ctx, [RemainingText] string accountName)
{
await ctx.Channel.TriggerTypingAsync();
using (var db = new DatabaseDbContext())
{
var account = db.ValorantAccount.Include(acc => acc.RankInfos)
.FirstOrDefault(acc => acc.DisplayName == accountName);
if (account == null)
{
await ctx.Channel.SendMessageAsync($"Could not find an account with name {accountName}");
return;
}
var playerRankHistory =
await ValorantApiService.GetPlayerRankHistory(account.Region.ToString(), account, DateTime.Today.AddDays(50 * -1));
var numberAdded = 0;
foreach (var rankInfo in playerRankHistory)
{
if (account.RankInfos.Any(info => info.DateTime == rankInfo.DateTime) == false)
{
account.RankInfos.Add(rankInfo);
numberAdded++;
}
}
await db.SaveChangesAsync();
await ctx.Channel.SendMessageAsync($"Updated {numberAdded} records");
}
}
public async Task SetRegionCommand(CommandContext ctx, string region, [RemainingText] string account)
{
Region reg;
var parsed = Enum.TryParse(region, true, out reg);
if (parsed == false)
{
await ctx.Channel.SendMessageAsync($"Could not parse region. Possible values: {string.Join(", ", Enum.GetNames(typeof(Region)))}");
return;
}
using (var db = new DatabaseDbContext())
{
var acc = db.ValorantAccount.FirstOrDefault(acc => acc.DisplayName == account);
if (acc == null)
{
await ctx.Channel.SendMessageAsync("Cannot find specified account");
return;
}
acc.Region = reg;
db.Update(acc);
await db.SaveChangesAsync();
await ctx.Channel.SendMessageAsync("Region updated");
}
}
public async Task <ActionResult <ApiResponse <Post> > > PutPost(int id, Post post)
{
var result = new ApiResponse <Post>(1, null, false, null);
if (id != post.Id)
{
result.ResultCode = 0;
result.ErrorDisplay = true;
result.ErrorMessage = "Bad request!";
return(result);
}
_context.Entry(post).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
result.ResultData = post;
}
catch (DbUpdateConcurrencyException dbx)
{
if (!PostExists(id))
{
result.ResultCode = 0;
result.ErrorDisplay = true;
result.ErrorMessage = "Not Found!";
return(result);
}
else
{
_logger.LogError("DbUpdateConcurrencyException", dbx);
result.ResultCode = 0;
result.ErrorDisplay = true;
result.ErrorMessage = "Bad request!";
return(result);
}
}
return(result);
}
public async Task SetHeaderCommand(CommandContext ctx, string headerName, [RemainingText] string headerValue)
{
Logger.LogInformation($"Added header {headerName} = {headerValue}");
using (var db = new DatabaseDbContext())
{
var customHeader = new CustomHeader {
Name = headerName, Value = headerValue
};
db.AddOrUpdate(customHeader);
await db.SaveChangesAsync();
}
}
public async Task SetUpdateChannelCommand(CommandContext ctx, DiscordChannel channel)
{
Logger.LogInformation($"Update channel for guild {ctx.Guild.Name} set to {channel.Name}");
// We can also access the channel from the Command Context.
using (var db = new DatabaseDbContext())
{
var guildConfig = new GuildConfig {
Guild = ctx.Guild.Id, UpdatesChannel = channel.Id
};
db.AddOrUpdate(guildConfig);
await db.SaveChangesAsync();
}
}
public async Task AddLastAccountMatch(ValorantAccount account, List <RankInfo> history)
{
using (var db = new DatabaseDbContext())
{
foreach (var rankInfo in history)
{
if (account.RankInfos.Any(info => info.DateTime == rankInfo.DateTime) == false)
{
account.RankInfos.Add(rankInfo);
}
}
db.Update(account);
await db.SaveChangesAsync();
}
}
public async Task <bool> LinkAccountToDiscordUser(ValorantAccount accountToAdd, DiscordUser user)
{
bool result = true;
using (var db = new DatabaseDbContext())
{
var dbUser = db.DiscordUsers.Include(u => u.ValorantAccounts).SingleOrDefault(u => u.ID == user.Id);
if (dbUser == null)
{
dbUser = new DbDiscordUser()
{
ID = user.Id,
Name = user.Username
};
await db.DiscordUsers.AddAsync(dbUser);
await db.SaveChangesAsync();
}
var valorantAccount = dbUser.ValorantAccounts.FirstOrDefault(a => a.Subject == accountToAdd.Subject);
if (valorantAccount == null)
{
dbUser.ValorantAccounts.Add(accountToAdd);
db.Update(dbUser);
}
else
{
accountToAdd.ID = valorantAccount.ID;
result = false;
db.Update(accountToAdd);
}
await db.SaveChangesAsync();
}
return(result);
}
public async Task RankCommand(CommandContext ctx, DiscordUser discordUser = null)
{
LogCommandExecuted(ctx);
discordUser ??= ctx.User;
using (var db = new DatabaseDbContext())
{
var user = await db.DiscordUsers.Include(user => user.ValorantAccounts)
.FirstOrDefaultAsync(user => user.ID == discordUser.Id);
if (user == null || user.ValorantAccounts.Count == 0)
{
await ctx.Channel.SendMessageAsync("You have no connected accounts");
Logger.LogInformation($"User {discordUser.Username} has no ValorantAccounts connected");
return;
}
var embed = new DiscordEmbedBuilder().WithTitle($"List of {user.Name} accounts");
foreach (var valorantAccount in user.ValorantAccounts.OrderByDescending(val => val.Rank)
.ThenByDescending(val => val.RankProgress))
{
var playerRank = await ValorantApiService.GetPlayerRank(valorantAccount.Region.ToString(), valorantAccount.Subject);
valorantAccount.UpdateRank(playerRank);
var playerIDs = await ValorantApiService.GetPlayerIds(valorantAccount.Region.ToString(), valorantAccount.Subject);
if (playerIDs != null)
{
valorantAccount.DisplayName = $"{playerIDs.Name}#{playerIDs.Tag}";
}
var guildEmote = ctx.Guild.Emojis.FirstOrDefault(emote =>
emote.Value.Name == valorantAccount.RankName.Replace(" ", ""));
embed.AddField("Name", valorantAccount.DisplayName, true);
embed.AddField("Rank", $"{guildEmote.Value}{valorantAccount.RankName}", true); //todo: add emoji
embed.AddField("Progress", $"{valorantAccount.RankProgress} / 100", true);
db.Update(valorantAccount);
}
await ctx.Channel.SendMessageAsync(embed : embed.Build());
await db.SaveChangesAsync();
}
}
public async Task AsignAccountToGuild(ValorantAccount accountToAssign, ulong guildId)
{
using (var db = new DatabaseDbContext())
{
var guild = accountToAssign.RegisteredGuilds.FirstOrDefault(g => g.GuildID == guildId);
if (guild == null)
{
accountToAssign.RegisteredGuilds.Add(new RegisteredGuild()
{
GuildID = guildId,
ValorantAccount = accountToAssign
});
db.Update(accountToAssign);
await db.SaveChangesAsync();
}
}
}
public async Task RankCommand(CommandContext ctx, [RemainingText] string account)
{
LogCommandExecuted(ctx);
using (var db = new DatabaseDbContext())
{
var acc = db.ValorantAccount.FirstOrDefault(acc => acc.DisplayName == account);
if (acc == null)
{
await ctx.Channel.SendMessageAsync($"Cannot find account {account}");
Logger.LogInformation($"Account {account} not found");
return;
}
var embed = new DiscordEmbedBuilder().WithTitle($"Rank of {account}");
var playerRank = await ValorantApiService.GetPlayerRank(acc.Region.ToString(), acc.Subject);
acc.UpdateRank(playerRank);
var playerIDs = await ValorantApiService.GetPlayerIds(acc.Region.ToString(), acc.Subject);
if (playerIDs != null)
{
acc.DisplayName = $"{playerIDs.Name}#{playerIDs.Tag}";
}
var guildEmote = ctx.Guild.Emojis.FirstOrDefault(emote =>
emote.Value.Name == acc.RankName.Replace(" ", ""));
embed.AddField("Name", acc.DisplayName, true);
embed.AddField("Rank", $"{guildEmote.Value}{acc.RankName}", true); //todo: add emoji
embed.AddField("Progress", $"{acc.RankProgress} / 100", true);
db.Update(acc);
await ctx.Channel.SendMessageAsync(embed : embed.Build());
await db.SaveChangesAsync();
}
}
private async Task UnlinkAccount(CommandContext ctx, DiscordUser dbDiscordUser, string subject)
{
using (var db = new DatabaseDbContext())
{
var user = db.DiscordUsers.Include(user => user.ValorantAccounts)
.SingleOrDefault(user => user.ID == dbDiscordUser.Id);
var acc = user?.ValorantAccounts.FirstOrDefault(acc => acc.Subject == subject || acc.DisplayName == subject);
if (acc != null)
{
user.ValorantAccounts.Remove(acc);
await db.SaveChangesAsync();
await ctx.Channel.SendMessageAsync($"Account {acc.DisplayName} unlinked from the user");
}
else
{
await ctx.Channel.SendMessageAsync("The user does not have assigned requested account");
}
}
}
private async Task Update()
{
using (var db = new DatabaseDbContext())
{
var accounts = db.ValorantAccount.Include(acc => acc.DbDiscordUser)
.Include(acc => acc.RegisteredGuilds).Include(acc => acc.RankInfos).ToList();
var valorantAccount = accounts[_currentAccount];
Logger.LogInformation($"Running RankChecker on player {valorantAccount.DisplayName}");
_currentAccount++;
if (_currentAccount >= accounts.Count)
{
_currentAccount = 0;
}
var playerRank = await _valorantApiService.GetPlayerRank(valorantAccount.Region.ToString(), valorantAccount.Subject);
if (playerRank == null)
{
Logger.LogError("Could not update playerRank");
return;
}
foreach (var valorantAccountRegisteredGuild in valorantAccount.RegisteredGuilds)
{
var guildConfig = db.GuildConfigs.FirstOrDefault(guild =>
guild.Guild == valorantAccountRegisteredGuild.GuildID && guild.UpdatesChannel != null);
if (guildConfig != null)
{
var channel = await _botService.DiscordClient.GetChannelAsync(guildConfig.UpdatesChannel.Value);
if (channel != null)
{
if (playerRank.RankInt < valorantAccount.Rank)
{
await channel.SendMessageAsync(
$"Account {valorantAccount.DisplayName} has been downgraded to {playerRank.RankString} . Current progress: {playerRank.Progress} / 100");
}
if (playerRank.RankInt > valorantAccount.Rank)
{
await channel.SendMessageAsync(
$"Account {valorantAccount.DisplayName} has been promoted to {playerRank.RankString} ! Current progress: {playerRank.Progress} / 100");
}
if (playerRank.LastMatch != null)
{
var dt = DateTimeOffset.FromUnixTimeMilliseconds(playerRank.LastMatch.MatchStartTime)
.DateTime;
var info = new RankInfo
{
DateTime = dt,
Progress = (int)playerRank.LastMatch.RankedRatingAfterUpdate,
RankInt = (int)playerRank.LastMatch.TierAfterUpdate,
ValorantAccount = valorantAccount
};
if (info.Progress != 0 || info.RankInt != 0)
{
if (valorantAccount.RankInfos.Any(rankInfo => rankInfo.DateTime == info.DateTime) ==
false)
{
valorantAccount.RankInfos.Add(info);
}
db.Update(valorantAccount);
await db.SaveChangesAsync();
}
}
else
{
}
var playerRankChanged = playerRank.RankInt != valorantAccount.Rank;
if (playerRankChanged)
{
valorantAccount.UpdateRank(playerRank);
db.Update(valorantAccount);
await db.SaveChangesAsync();
}
}
}
}
}
}
public Task <int> SaveChangesAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return(_context.SaveChangesAsync(cancellationToken));
}
