public StickerController(
DatabaseDbContext context,
ILogger <CouponController> logger)
{
_context = context;
_logger = logger;
}
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 SurveyController(
DatabaseDbContext context,
ILogger <SurveyController> logger)
{
_context = context;
_logger = logger;
}
private static async Task MainAsync()
{
DotEnv.AutoConfig();
using (var services = ConfigureServices())
{
var envCheckerService = services.GetRequiredService <EnvCheckerService>();
var checkEnvironmentValues = envCheckerService.CheckEnvironmentValues();
if (checkEnvironmentValues == false)
{
Console.WriteLine("Error: CheckEnvironmentValues ");
return;
}
var valorantApiService = services.GetRequiredService <ValorantApiService>();
await using (var db = new DatabaseDbContext())
{
await db.Database.MigrateAsync();
}
var discord = services.GetRequiredService <BotService>();
await discord.StartAsync();
services.GetRequiredService <PlayerRankChecker>().Start();
await Task.Delay(-1);
}
}
public async Task HistoryCommand(CommandContext ctx, string accountName)
{
LogCommandExecuted(ctx);
using (var db = new DatabaseDbContext())
{
var account = await db.ValorantAccount.Include(user => user.RankInfos)
.FirstOrDefaultAsync(acc => acc.DisplayName == accountName);
if (account == null)
{
await ctx.Channel.SendMessageAsync(
"No account with specified ID found. You must specify valorant account name");
Logger.LogInformation($"Cannot find Valorant Account {accountName}");
}
if (account.RankInfos.Count != 0)
{
var historyPlot = PlotService.GetHistoryPlot(account);
// await ctx.Channel.SendFileAsync(historyPlot, "history.png"); // todo: Add sending plot
await ctx.Channel.SendFileAsync("history.png", historyPlot);
}
else
{
await ctx.Channel.SendMessageAsync($"No history entries for {accountName}");
}
}
}
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 void Setup()
{
var booklist = new List <Book>
{
new Book {
Id = 1, Book_Id = 1, Book_Name = "Mathematics", Author = "RS Agarwal", Language = "English", No_of_pages = 200, Price = 400
},
new Book {
Id = 2, Book_Id = 2, Book_Name = "Physics", Author = "RS Agarwal", Language = "English", No_of_pages = 300, Price = 200
},
new Book {
Id = 3, Book_Id = 3, Book_Name = "Chemistry", Author = "RS Agarwal", Language = "English", No_of_pages = 400, Price = 400
}, new Book {
Id = 1, Book_Id = 1, Book_Name = "Mathematics", Author = "RS Agarwal", Language = "English", No_of_pages = 200, Price = 400
},
};
var issue = new List <IssueDetails>
{
new IssueDetails {
Id = 1, Book_Id = 1, User_Id = 1, User_Name = "shubham", Book_Name = "Mathematics", Book_Author = "RS Agarwal", Issue_Date = "20/10/2020", Phone_Number = "6128128221"
}
};
var books = booklist.AsQueryable();
var mockSet = new Mock <DbSet <Book> >();
mockSet.As <IQueryable <Book> >().Setup(m => m.Provider).Returns(books.Provider);
mockSet.As <IQueryable <Book> >().Setup(m => m.Expression).Returns(books.Expression);
mockSet.As <IQueryable <Book> >().Setup(m => m.ElementType).Returns(books.ElementType);
mockSet.As <IQueryable <Book> >().Setup(m => m.GetEnumerator()).Returns(books.GetEnumerator());
var mockContext = new Mock <DatabaseDbContext>();
mockContext.Setup(c => c.Books).Returns(mockSet.Object);
context = mockContext.Object;
}
public PostController(
DatabaseDbContext context,
ILogger <PostController> logger)
{
_context = context;
_logger = logger;
}
private async Task LinkAccount(CommandContext ctx, DiscordUser discordUser, string subject)
{
using (var db = new DatabaseDbContext())
{
var guild = db.GuildConfigs.FirstOrDefault(g => g.Guild == ctx.Guild.Id);
var playerRank = await ValorantApiService.GetPlayerRank(guild.Region, subject);
if (playerRank == null)
{
await ctx.Channel.SendMessageAsync("Could not retrieve Player rank for selected id");
Logger.LogError($"Could not retrieve Player rank for {subject}");
return;
}
var playerIDs = await ValorantApiService.GetPlayerIds(guild.Region, subject);
if (playerIDs == null)
{
await ctx.Channel.SendMessageAsync("Could not retrieve Player IDs for selected id");
Logger.LogError($"Could not retrieve Player IDs for {subject}");
return;
}
var newValorantAccount = new ValorantAccount
{
Subject = subject,
Rank = playerRank.RankInt,
RankName = playerRank.RankString,
RankProgress = playerRank.Progress,
DisplayName = $"{playerIDs.Name}#{playerIDs.Tag}"
};
var valorantDbService = new ValorantDbService();
var accountLinked = await valorantDbService.LinkAccountToDiscordUser(newValorantAccount, discordUser);
await valorantDbService.AsignAccountToGuild(newValorantAccount, ctx.Guild.Id);
var playerRankHistoty =
await ValorantApiService.GetPlayerRankHistory(guild.Region, newValorantAccount, DateTime.Today.AddDays(-50));
await valorantDbService.AddLastAccountMatch(newValorantAccount, playerRankHistoty);
if (accountLinked)
{
await ctx.Channel.SendMessageAsync(
$"Account {newValorantAccount.DisplayName} ( {newValorantAccount.RankName} ) lined to user {discordUser.Username}");
}
else
{
await ctx.Channel.SendMessageAsync(
$"Account {newValorantAccount.DisplayName} ( {newValorantAccount.RankName} ) already linked to user {discordUser.Username}");
}
}
}
public void TestTravelLikes_0()
{
//var conn = new NpgsqlConnection("Server=127.0.0.1;Port=5432;User Id=joe;Password=secret;Database=joedata;");
var db = new DatabaseDbContext();
var likesRepository = new LikesRepository(db);
var result = likesRepository.GetTravelLikesModel(null, 0);
Assert.IsNotNull(result);
Assert.AreEqual(LikeStatuses.Neultral, result.UserLikeStatus);
}
public static void CleanDatabase(TestContext context)
{
using (var db = new DatabaseDbContext())
{
//db.students.RemoveRange(db.students);
//db.parents.RemoveRange(db.parents);
//db.tutors.RemoveRange(db.tutors);
db.SaveChanges();
}
}
public void TestTravelLikes_null()
{
//var conn = new NpgsqlConnection("Server=127.0.0.1;Port=5432;User Id=joe;Password=secret;Database=joedata;");
var db = new DatabaseDbContext();
var likesRepository = new LikesRepository(db);
var result = likesRepository.GetTravelLikesModel(null, 14);
db.Database.Log = Console.WriteLine;
Console.WriteLine($"Likes: {result.LikesCount}, Dislikes {result.DislikesCount}, User: {result.UserLikeStatus}");
Assert.IsNotNull(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();
}
}
protected UnitTest()
{
_connection = new SqliteConnection(InMemoryConnectionString);
_connection.Open();
var options = new DbContextOptionsBuilder <DatabaseDbContext>()
.UseSqlite(_connection)
.Options;
dbContext = new DatabaseDbContext(options);
dbContext.Database.EnsureCreated();
dbAccess = new DbAccess(dbContext);
mapper = AutoMapperFactory.Create();
}
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 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");
}
}
}
public async Task UnlinkCommand(CommandContext ctx)
{
await ctx.Channel.TriggerTypingAsync();
using (var db = new DatabaseDbContext())
{
var user = db.DiscordUsers.Include(user => user.ValorantAccounts)
.SingleOrDefault(user => user.ID == ctx.User.Id);
if (user == null || user.ValorantAccounts.Count == 0)
{
await ctx.Channel.SendMessageAsync("User does not have assigned valorant accounts");
}
else
{
var msg = "Assigned accounts:\n";
foreach (var valorantAccount in user.ValorantAccounts)
{
msg += $"`{valorantAccount.Subject}\t:\t{valorantAccount.DisplayName}`\n";
}
await ctx.Channel.SendMessageAsync(msg);
}
}
}
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);
}
protected EntityDbAccessBase(DatabaseDbContext context)
{
_context = context;
}
public DatabaseHandler(DatabaseDbContext dbContext)
{
DbContext = dbContext;
}
protected AbstractIndependentRepository(DatabaseDbContext dbContext)
{
DbContext = dbContext;
DDbset = DbContext.Set <TEntity>();
}
public ActivityDbAccess(DatabaseDbContext context) : base(context)
{
}
public UserRepository(DatabaseDbContext context) : base(context)
{
}
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 TravelsRepository(DatabaseDbContext context) : base(context)
{
}
public PointRepository(DatabaseDbContext context) : base(context)
{
}
