public async Task GroupLogs(CommandContext ctx)
{
try {
using (var db = new JackTheStudentContext()){
var groups = db.Group.ToList();
if (groups.Count == 0)
{
await ctx.RespondAsync("No groups logged!");
}
else
{
string result = String.Empty;
foreach (Group group in groups)
{
result = result + "\n" + group.GroupId;
}
await ctx.RespondAsync(result);
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
return;
}
public async Task ReminderLog(CommandContext ctx, string date, string time, string about)
{
DateTime parsedEventDate;
DateTime parsedEventTime;
DateTime.TryParse(time, out parsedEventTime);
DateTime.TryParse(date, out parsedEventDate);
PersonalReminder reminder = new PersonalReminder {
SetForDate = parsedEventDate.Date.Add(parsedEventTime.TimeOfDay),
LogById = ctx.Message.Author.Id,
LogByUsername = ctx.Message.Author.Username + "#" + ctx.Message.Author.Discriminator,
About = about,
UserMention = ctx.Message.Author.Mention,
ChannelId = ctx.Channel.Id
};
try {
JackTheStudent.Program.reminderList.Add(reminder);
using (var db = new JackTheStudentContext()) {
db.PersonalReminder.Add(reminder);
await db.SaveChangesAsync();
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Log failed");
return;
}
await ctx.RespondAsync($"Reminder about \"{about}\" set for {date} {time}");
}
public async Task ClassesLogs(CommandContext ctx)
{
try {
using (var db = new JackTheStudentContext()){
var classes = db.Class.ToList();
if (classes.Count == 0)
{
await ctx.RespondAsync("No classes logged!");
}
else
{
string result = String.Empty;
foreach (Class uniClass in classes)
{
result = result + "\n" + "Class - " + uniClass.Name + ", short version - " + uniClass.ShortName;
}
await ctx.RespondAsync(result);
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
return;
}
public async Task Truncate(CommandContext ctx)
{
using (var db = new JackTheStudentContext()){
}
/* Send the message "I'm Alive!" to the channel the message was recieved from */
await ctx.RespondAsync("All tables have been cleared!");
}
public async Task RestoreClasses(List <Class> backupList, CommandContext ctx)
{
await ctx.RespondAsync("Failed, aborting and restoring from backup.");
using (var db = new JackTheStudentContext()) {
await db.Database.ExecuteSqlRawAsync("truncate table class");
foreach (Class backupClass in backupList)
{
db.Class.Add(backupClass);
}
await db.SaveChangesAsync();
}
await ctx.RespondAsync("Groups restored from backup.");
return;
}
private async Task Remind()
{
if (reminderList.Count == 0)
{
return;
}
for (int i = 1; i <= reminderList.Count(); i++)
{
if (DateTime.Now >= reminderList[i - 1].SetForDate)
{
await reminderList[i - 1].Ping(_discord);
try {
using (var db = new JackTheStudentContext()) {
db.PersonalReminder.Remove(reminderList[i - 1]);
await db.SaveChangesAsync();
}
reminderList.Remove(reminderList[i - 1]);
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
}
}
}
}
private async Task AutoRemind()
{
if (examList.Count == 0)
{
return;
}
TimeSpan interval = new TimeSpan(7, 00, 00, 00);
TimeSpan timeLeft = new TimeSpan();
TimeSpan checkTime = new TimeSpan(15, 20, 00);
bool isTime = DateTime.Now.TimeOfDay >= checkTime;
bool isLessThanAWeek = false;
if (!isTime)
{
return;
}
for (int i = 1; i <= examList.Count(); i++)
{
timeLeft = examList[i - 1].Date.Date - DateTime.Now.Date;
isLessThanAWeek = timeLeft <= interval;
if (isLessThanAWeek)
{
await examList[i - 1].Ping(_discord);
examList[i - 1].wasReminded = true;
using (var db = new JackTheStudentContext()) {
try {
var exam = db.Exam.Where(e => e.Id == examList[i - 1].Id).FirstOrDefault();
exam.wasReminded = true;
await db.SaveChangesAsync();
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
}
}
}
}
}
public async Task ProjectLog(CommandContext ctx,
[Description("\nTakes either 1 (true) or 0 (false)\n")] string isGroup = "",
[Description("\nTakes group IDs, type !group to retrieve all groups.\n")] string groupId = "",
[Description("\nTakes class' short names, type !class to retrive all classes.\n")] string classType = "",
[Description("\nTakes dates in dd/mm/yyyy format, accepts different separators.\n")] string eventDate = "",
[Description("\nTakes time in hh:mm format.\n")] string eventTime = "",
[Description("\nTakes additional information, multiple words must be wrapped with \"\".\n")] string additionalInfo = "")
{
DateTime parsedEventDate = new DateTime();
DateTime parsedEventTime = new DateTime();
if (isGroup == "")
{
await ctx.RespondAsync("Learn to read you dumbass. The command looks like: !project <isGroup> <group> <class> <projectDate> <projectTime> Try again!");
return;
}
else if (isGroup != "0" && isGroup != "1")
{
await ctx.RespondAsync("How stupid are you, really? isGroup argument takes either 1 (true) or 0 (false)!");
return;
}
else if (groupId == "")
{
await ctx.RespondAsync("Learn to read you dumbass. The command looks like: !project <isGroup> <group> <class> <projectDate> <projectTime> Try again!");
return;
}
else if (!JackTheStudent.Program.groupList.Contains(groupId))
{
await ctx.RespondAsync("There's no such group dumbass. Try again!");
return;
}
else if (classType == "")
{
await ctx.RespondAsync("Learn to read you dumbass. The command looks like: !project <isGroup> <group> <class> <projectDate> <projectTime> Try again!");
return;
}
else if (!JackTheStudent.Program.classList.Any(c => c.ShortName == classType))
{
await ctx.RespondAsync("There's no such class, you high bruh?");
return;
}
else if (eventDate == "")
{
await ctx.RespondAsync("There's date missing, fix it!");
return;
}
else if (!DateTime.TryParse(eventDate, out parsedEventDate))
{
await ctx.RespondAsync("That's not a valid date you retard, learn to type!");
return;
}
else if (eventTime == "")
{
await ctx.RespondAsync("There's time missing, fix it!");
return;
}
else if (!DateTime.TryParse(eventTime, out parsedEventTime))
{
await ctx.RespondAsync("That's not a valid time you retard, learn to type!");
return;
}
else if (isGroup == "0")
{
try {
using (var db = new JackTheStudentContext()){
var project = new Project {
Class = classType,
Date = parsedEventDate.Date.Add(parsedEventTime.TimeOfDay),
GroupId = groupId,
isGroup = Convert.ToBoolean(Convert.ToInt16(isGroup)),
LogById = ctx.Message.Author.Id.ToString(),
LogByUsername = ctx.Message.Author.Username + "#" + ctx.Message.Author.Discriminator,
AdditionalInfo = additionalInfo
};
db.Project.Add(project);
await db.SaveChangesAsync();
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Log failed");
return;
}
await ctx.RespondAsync("Project logged successfully");
return;
}
else
{
await ctx.RespondAsync("How many members does the project have?");
var intr = ctx.Client.GetInteractivity(); // Grab the interactivity module
var response = await intr.WaitForMessageAsync(
c => c.Author.Id == ctx.Message.Author.Id, // Make sure the response is from the same person who sent the command
TimeSpan.FromSeconds(5) // Wait 60 seconds for a response instead of the default 30 we set earlier!
);
short membersCount = 1;
while (!Int16.TryParse(response.Result.Content, out membersCount) && membersCount <= 2)
{
await ctx.RespondAsync("Ever heard of intigers? Try again.");
response = await intr.WaitForMessageAsync(
c => c.Author.Id == ctx.Message.Author.Id, // Make sure the response is from the same person who sent the command
TimeSpan.FromSeconds(5) // Wait 60 seconds for a response instead of the default 30 we set earlier!
);
}
try {
using (var db = new JackTheStudentContext()){
var project = new Project {
Class = classType,
Date = parsedEventDate.Date.Add(parsedEventTime.TimeOfDay),
GroupId = groupId,
isGroup = Convert.ToBoolean(Convert.ToInt16(isGroup)),
LogById = ctx.Message.Author.Id.ToString(),
LogByUsername = ctx.Message.Author.Username + "#" + ctx.Message.Author.Discriminator,
AdditionalInfo = additionalInfo,
GroupProjectMembers = new List <GroupProjectMember>()
};
for (int i = 1; i <= membersCount; i++)
{
await ctx.RespondAsync("What's the name of the " + i + " participant?");
var participant = await intr.WaitForMessageAsync(
c => c.Author.Id == ctx.Message.Author.Id, // Make sure the response is from the same person who sent the command
TimeSpan.FromSeconds(5) // Wait 60 seconds for a response instead of the default 30 we set earlier!
);
var groupProjectMember = new GroupProjectMember {
Member = participant.Result.Content
};
project.GroupProjectMembers.Add(groupProjectMember);
}
JackTheStudent.Program.projectList.Add(project);
db.Project.Add(project);
await db.SaveChangesAsync();
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Log failed");
return;
}
await ctx.RespondAsync("Project logged successfully");
return;
}
}
public async Task ProjectLogs(CommandContext ctx,
[Description("\nTakes group IDs or \".\", type !group to retrieve all groups, usage of \".\" will tell Jack to retrieve project for ALL groups.\n")] string group = ".",
[Description("\nTakes class' short names or \".\", type !class to retrieve all classes, usage of \".\" will tell Jack to retrieve project for ALL classes.\n")] string classType = ".",
[Description("\nTakes 0 for only individual projects, 1 for group projects or \".\" for all projects\n")] string isGroup = ".",
[Description("\nTakes \".\" or \"planned\", usage of \".\" will tell Jack to retrieve all LOGGED project, \"planned\" retrieves only future events.\n")] string span = "planned")
{
bool isParticipants = false;
if (!JackTheStudent.Program.groupList.Contains(group) && group != ".")
{
await ctx.RespondAsync("There's no such group dumbass. Try again!");
return;
}
else if (!JackTheStudent.Program.classList.Any(c => c.ShortName == classType) && classType != ".")
{
await ctx.RespondAsync("There's no such class, you high bruh?");
return;
}
else if (isGroup != "." && isGroup != "0" && isGroup != "1")
{
await ctx.RespondAsync("... isGroup only takes . , 0 i 1");
return;
}
if (group == "." && classType == "." && span == "planned")
{
try {
using (var db = new JackTheStudentContext()){
var projects = db.Project
.Where(x => x.Date > DateTime.Now)
.ToList();
if (projects.Count == 0)
{
await ctx.RespondAsync("Wait what!? There are literally no projects planned at all!");
}
else
{
string result = String.Empty;
string participantsString = String.Empty;
isParticipants = await ParticipantsQuestion(ctx);
foreach (Project project in projects)
{
if (project.isGroup && isParticipants)
{
participantsString = await GetParticipantsString(await project.GetParticipants());
}
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo
.ToTitleCase(JackTheStudent.Program.classList
.Where(c => c.ShortName == project.Class)
.Select(c => c.Name)
.FirstOrDefault()) + " project for group " + project.GroupId + ", deadline is " + project.Date + participantsString;
}
await ctx.RespondAsync(result);
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
return;
}
else if (classType == "." && span == "." && group != ".")
{
try {
using (var db = new JackTheStudentContext()){
var projects = db.Project
.Where(x => x.GroupId == group)
.ToList();
if (projects.Count == 0)
{
await ctx.RespondAsync("There are no projects logged for group " + group + "!");
}
else
{
string result = String.Empty;
string participantsString = String.Empty;
if (isGroup == "1" || isGroup == ".")
{
isParticipants = await ParticipantsQuestion(ctx);
}
foreach (Project project in projects)
{
if (project.isGroup && isParticipants)
{
participantsString = await GetParticipantsString(await project.GetParticipants());
}
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo
.ToTitleCase(JackTheStudent.Program.classList
.Where(c => c.ShortName == project.Class)
.Select(c => c.Name)
.FirstOrDefault()) + " project for group " + project.GroupId + ", deadline is/was " + project.Date + participantsString;
}
await ctx.RespondAsync(result);
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
return;
}
else if (classType == "." && span == "planned" && group != ".")
{
try {
using (var db = new JackTheStudentContext()){
var projects = db.Project
.Where(x => x.Date > DateTime.Now && x.GroupId == group)
.ToList();
if (projects.Count == 0)
{
await ctx.RespondAsync("Wait what!? There are no projects planned for any class for group " + group + "!");
}
else
{
string result = String.Empty;
string participantsString = String.Empty;
if (isGroup == "1" || isGroup == ".")
{
isParticipants = await ParticipantsQuestion(ctx);
}
foreach (Project project in projects)
{
if (project.isGroup && isParticipants)
{
participantsString = await GetParticipantsString(await project.GetParticipants());
}
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo
.ToTitleCase(JackTheStudent.Program.classList
.Where(c => c.ShortName == project.Class)
.Select(c => c.Name)
.FirstOrDefault()) + " project for group " + project.GroupId + ", deadline is " + project.Date + participantsString;
}
await ctx.RespondAsync(result);
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
return;
}
else if (classType != "." && span == "planned" && group != ".")
{
if (JackTheStudent.Program.classList.Any(c => c.ShortName == classType))
{
try {
using (var db = new JackTheStudentContext()){
var projects = db.Project
.Where(x => x.Date > DateTime.Now && x.Class == classType && x.GroupId == group)
.ToList();
if (projects.Count == 0)
{
string response = "There are no " + JackTheStudent.Program.classList
.Where(c => c.ShortName == classType)
.Select(c => c.Name)
.FirstOrDefault() + " projects planned for group " + group + "!";
await ctx.RespondAsync(response);
return;
}
else
{
string result = String.Empty;
string participantsString = String.Empty;
if (isGroup == "1" || isGroup == ".")
{
isParticipants = await ParticipantsQuestion(ctx);
}
foreach (Project project in projects)
{
if (project.isGroup && isParticipants)
{
participantsString = await GetParticipantsString(await project.GetParticipants());
}
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo
.ToTitleCase(JackTheStudent.Program.classList
.Where(c => c.ShortName == project.Class)
.Select(c => c.Name)
.FirstOrDefault()) + " project for group " + project.GroupId + ", deadline is " + project.Date + participantsString;
}
await ctx.RespondAsync(result);
return;
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
}
else
{
await ctx.RespondAsync("Learn to read you dumbass. The command looks like: !projects <group> <group> <projectDate> <projectTime> Try again!");
return;
}
}
else if (classType != "." && span == "." && group != ".")
{
if (JackTheStudent.Program.classList.Any(c => c.ShortName == classType))
{
try {
using (var db = new JackTheStudentContext()){
var projects = db.Project
.Where(x => x.Class == classType && x.GroupId == group)
.ToList();
if (projects.Count == 0)
{
string response = "There is no project logged for " + JackTheStudent.Program.classList
.Where(c => c.ShortName == classType)
.Select(c => c.Name)
.FirstOrDefault() + " class " + "for group " + group + "!";;
await ctx.RespondAsync(response);
return;
}
else
{
string result = String.Empty;
string participantsString = String.Empty;
if (isGroup == "1" || isGroup == ".")
{
isParticipants = await ParticipantsQuestion(ctx);
}
foreach (Project project in projects)
{
if (project.isGroup && isParticipants)
{
participantsString = await GetParticipantsString(await project.GetParticipants());
}
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo
.ToTitleCase(JackTheStudent.Program.classList
.Where(c => c.ShortName == project.Class)
.Select(c => c.Name)
.FirstOrDefault()) + " project for group " + project.GroupId + ", will happen / happened on " + project.Date + participantsString;
}
await ctx.RespondAsync(result);
return;
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
}
else
{
await ctx.RespondAsync("Ya know there's only either all possible events or the ones that didn't happen right? Get yo facts straight negro!");
return;
}
}
else
{
try {
using (var db = new JackTheStudentContext()){
var projects = db.Project.ToList();
if (projects.Count == 0)
{
string response = "There aren no projects logged!";
await ctx.RespondAsync(response);
return;
}
else
{
string result = String.Empty;
string participantsString = String.Empty;
if (isGroup == "1" || isGroup == ".")
{
isParticipants = await ParticipantsQuestion(ctx);
}
foreach (Project project in projects)
{
if (project.isGroup && isParticipants)
{
participantsString = await GetParticipantsString(await project.GetParticipants());
}
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo
.ToTitleCase(JackTheStudent.Program.classList
.Where(c => c.ShortName == project.Class)
.Select(c => c.Name)
.FirstOrDefault()) + " project for group " + project.GroupId + ", will happen / happened " + project.Date + participantsString;
}
await ctx.RespondAsync(result);
return;
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
}
}
public async Task HomeworkLog(CommandContext ctx,
[Description("\nTakes group IDs, type !group to retrieve all groups.\n")] string groupId = "",
[Description("\nTakes class' short names, type !class to retrive all classes.\n")] string classType = "",
[Description("\nTakes dates in dd/mm/yyyy format, accepts different separators.\n")] string eventDate = "",
[Description("\nTakes time in hh:mm format.\n")] string eventTime = "",
[Description("\nTakes additional information, multiple words must be wrapped with \"\".\n")] string additionalInfo = "",
[Description("\nTakes material links, multiple links must be wrapped with \"\".\n")] string materials = "")
{
DateTime parsedEventDate = new DateTime();
DateTime parsedEventTime = new DateTime();
if (groupId == "")
{
await ctx.RespondAsync("Learn to read you dumbass. The command looks like: !homework <group> <class> <deadlineDate> <deadlineTime> Try again!");
return;
}
else if (!JackTheStudent.Program.groupList.Contains(groupId))
{
await ctx.RespondAsync("There's no such group dumbass. Try again!");
return;
}
else if (classType == "")
{
await ctx.RespondAsync("Learn to read you dumbass. The command looks like: !homework <group> <class> <deadlineDate> <deadlineTime> Try again!");
return;
}
else if (!JackTheStudent.Program.classList.Any(c => c.ShortName == classType))
{
await ctx.RespondAsync("There's no such class, you high bruh?");
return;
}
else if (eventDate == "")
{
await ctx.RespondAsync("There's date missing, fix it!");
return;
}
else if (!DateTime.TryParse(eventDate, out parsedEventDate))
{
await ctx.RespondAsync("That's not a valid date you retard, learn to type!");
return;
}
else if (eventTime == "")
{
await ctx.RespondAsync("There's time missing, fix it!");
return;
}
else if (!DateTime.TryParse(eventTime, out parsedEventTime))
{
await ctx.RespondAsync("That's not a valid time you retard, learn to type!");
return;
}
else
{
try {
using (var db = new JackTheStudentContext()){
var homeWork = new Homework {
Class = classType,
Date = parsedEventDate.Date.Add(parsedEventTime.TimeOfDay),
GroupId = groupId,
LogById = ctx.Message.Author.Id.ToString(),
LogByUsername = ctx.Message.Author.Username + "#" + ctx.Message.Author.Discriminator,
AdditionalInfo = additionalInfo,
Materials = materials
};
JackTheStudent.Program.homeworkList.Add(homeWork);
db.Homework.Add(homeWork);
await db.SaveChangesAsync();
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Log failed");
return;
}
await ctx.RespondAsync("Homework logged successfully");
return;
}
}
public async Task HomeworkLogs(CommandContext ctx,
[Description("\nTakes group IDs or \".\", type !group to retrieve all groups, usage of \".\" will tell Jack to retrieve homework for ALL groups.\n")] string group = ".",
[Description("\nTakes class' short names or \".\", type !class to retrieve all classes, usage of \".\" will tell Jack to retrieve homework for ALL classes.\n")] string classType = ".",
[Description("\nTakes \".\" or \"planned\", usage of \".\" will tell Jack to retrieve all LOGGED homework, \"planned\" retrieves only future events.\n")] string span = "planned")
{
if (!JackTheStudent.Program.groupList.Contains(group) && group != ".")
{
await ctx.RespondAsync("There's no such group dumbass. Try again!");
return;
}
else if (!JackTheStudent.Program.classList.Any(c => c.ShortName == classType) && classType != ".")
{
await ctx.RespondAsync("There's no such class, you high bruh?");
return;
}
if (group == "." && classType == "." && span == "planned")
{
try {
using (var db = new JackTheStudentContext()){
var homeworks = db.Homework
.Where(x => x.Date > DateTime.Now)
.ToList();
if (homeworks.Count == 0)
{
await ctx.RespondAsync("Wait what!? There is literally no homework planned at all!");
}
else
{
string result = String.Empty;
foreach (Homework homework in homeworks)
{
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo
.ToTitleCase(JackTheStudent.Program.classList
.Where(c => c.ShortName == homework.Class)
.Select(c => c.Name)
.FirstOrDefault()) + " homework for group " + homework.GroupId + ", deadline is " + homework.Date;
}
await ctx.RespondAsync(result);
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
return;
}
else if (classType == "." && span == "." && group != ".")
{
try {
using (var db = new JackTheStudentContext()){
var homeworks = db.Homework
.Where(x => x.GroupId == group)
.ToList();
if (homeworks.Count == 0)
{
await ctx.RespondAsync("Wait what!? There is no homework logged for group " + group + "!");
}
else
{
string result = String.Empty;
foreach (Homework homework in homeworks)
{
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo
.ToTitleCase(JackTheStudent.Program.classList
.Where(c => c.ShortName == homework.Class)
.Select(c => c.Name)
.FirstOrDefault()) + " homework for group " + homework.GroupId + ", deadline is/was " + homework.Date;
}
await ctx.RespondAsync(result);
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
return;
}
else if (classType == "." && span == "planned" && group != ".")
{
try {
using (var db = new JackTheStudentContext()){
var homeworks = db.Homework
.Where(x => x.Date > DateTime.Now && x.GroupId == group)
.ToList();
if (homeworks.Count == 0)
{
await ctx.RespondAsync("Wait what!? There is no planned homework for group " + group + ", hmm... league?");
}
else
{
string result = String.Empty;
foreach (Homework homework in homeworks)
{
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo
.ToTitleCase(JackTheStudent.Program.classList
.Where(c => c.ShortName == homework.Class)
.Select(c => c.Name)
.FirstOrDefault()) + " homework for group " + homework.GroupId + ", deadline is " + homework.Date;
}
await ctx.RespondAsync(result);
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
return;
}
else if (classType != "." && span == "planned" && group != ".")
{
if (JackTheStudent.Program.classList.Any(c => c.ShortName == classType))
{
try {
using (var db = new JackTheStudentContext()){
var homeworks = db.Homework
.Where(x => x.Date > DateTime.Now && x.Class == classType && x.GroupId == group)
.ToList();
if (homeworks.Count == 0)
{
string response = "There is no " + JackTheStudent.Program.classList
.Where(c => c.ShortName == classType)
.Select(c => c.Name)
.FirstOrDefault() + " homework planned for group " + group + " at all!";
await ctx.RespondAsync(response);
return;
}
else
{
string result = String.Empty;
foreach (Homework homework in homeworks)
{
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo
.ToTitleCase(JackTheStudent.Program.classList
.Where(c => c.ShortName == homework.Class)
.Select(c => c.Name)
.FirstOrDefault()) + " homework for group " + homework.GroupId + ", deadline is " + homework.Date;
}
await ctx.RespondAsync(result);
return;
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
}
else
{
await ctx.RespondAsync("Learn to read you dumbass. The command looks like: !homeworks <group> <group> <eventDate> <eventTime> Try again!");
return;
}
}
else if (classType != "." && span == "." && group != ".")
{
if (JackTheStudent.Program.classList.Any(c => c.ShortName == classType))
{
try {
using (var db = new JackTheStudentContext()){
var homeworks = db.Homework
.Where(x => x.Class == classType && x.GroupId == group)
.ToList();
if (homeworks.Count == 0)
{
string response = "There is no homework logged for " + JackTheStudent.Program.classList
.Where(c => c.ShortName == classType)
.Select(c => c.Name)
.FirstOrDefault() + " class " + "for group " + group + "!";
await ctx.RespondAsync(response);
return;
}
else
{
string result = String.Empty;
foreach (Homework homework in homeworks)
{
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo
.ToTitleCase(JackTheStudent.Program.classList
.Where(c => c.ShortName == homework.Class)
.Select(c => c.Name)
.FirstOrDefault()) + " homework for group " + homework.GroupId + ", deadline is/was " + homework.Date;
}
await ctx.RespondAsync(result);
return;
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
}
else
{
await ctx.RespondAsync("Ya know there's only either all possible events or the ones that didn't happen right? Get yo facts straight negro!");
return;
}
}
else
{
try {
using (var db = new JackTheStudentContext()){
var homeworks = db.Homework.ToList();
if (homeworks.Count == 0)
{
string response = "There is no logged homework!";
await ctx.RespondAsync(response);
return;
}
else
{
string result = String.Empty;
foreach (Homework homework in homeworks)
{
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo
.ToTitleCase(JackTheStudent.Program.classList
.Where(c => c.ShortName == homework.Class)
.Select(c => c.Name)
.FirstOrDefault()) + " homework for group " + homework.GroupId + ", deadline is/was " + homework.Date;
}
await ctx.RespondAsync(result);
return;
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
}
}
public async Task SemeterGroup(CommandContext ctx)
{
List <Group> backupGroups = new List <Group>();
await ctx.RespondAsync("Are you absolutely sure you wanna do it?");
var intr = ctx.Client.GetInteractivity();
var sureResponse = await intr.WaitForMessageAsync(
c => c.Author.Id == ctx.Message.Author.Id,
TimeSpan.FromSeconds(5)
);
if (sureResponse.Result.Content.ToLower() != "yes" || sureResponse.Result == null)
{
await ctx.RespondAsync("Aborting, all good");
return;
}
using (var context = new JackTheStudentContext()) {
backupGroups = context.Group.ToList();
var truncateText = "truncate table `group`";
try {
await context.Database.ExecuteSqlRawAsync(truncateText);
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Truncate failed");
return;
}
await context.SaveChangesAsync();
await ctx.RespondAsync("Truncate successful");
}
using (var db = new JackTheStudentContext()){
await ctx.RespondAsync("Let's populate the table with new data, how many groups are there for the new semester?");
var amountOfGroupsResponse = await intr.WaitForMessageAsync(
c => c.Author.Id == ctx.Message.Author.Id,
TimeSpan.FromSeconds(10)
);
if (amountOfGroupsResponse.Result == null)
{
await RestoreGroups(backupGroups, ctx);
return;
}
short groupsCount = 0;
while (!Int16.TryParse(amountOfGroupsResponse.Result.Content, out groupsCount) || groupsCount < 1)
{
await ctx.RespondAsync("That's not a valid number, try again.");
amountOfGroupsResponse = await intr.WaitForMessageAsync(
c => c.Author.Id == ctx.Message.Author.Id,
TimeSpan.FromSeconds(10)
);
if (amountOfGroupsResponse.TimedOut)
{
await RestoreGroups(backupGroups, ctx);
return;
}
}
for (int i = 1; i <= groupsCount; i++)
{
await ctx.RespondAsync($"What's the ID of the {i} group? Answer with ID");
var groupId = await intr.WaitForMessageAsync(
c => c.Author.Id == ctx.Message.Author.Id,
TimeSpan.FromSeconds(30)
);
if (groupId.Result == null)
{
await RestoreGroups(backupGroups, ctx);
return;
}
var newGroup = new Group {
GroupId = groupId.Result.Content
};
db.Group.Add(newGroup);
await ctx.RespondAsync($"Added group with ID: {newGroup.GroupId}.");
Task.Delay(1000).Wait();
}
try {
await db.SaveChangesAsync();
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await RestoreGroups(backupGroups, ctx);
return;
}
await ctx.RespondAsync("Group table repopulated successfully");
}
return;
}
public async Task TeamsLinkLogs(CommandContext ctx,
[Description("\nTakes class' short names or \".\", type !class to retrieve all classes, usage of \".\" will tell Jack to retrieve teamsLink for ALL classes.\n")] string uniClass = ".",
[Description("\nTakes class' short names or \".\", type !class to retrieve all classes, usage of \".\" will tell Jack to retrieve teamsLink for ALL classes.\n")] string classType = ".",
[Description("\nTakes group IDs or \".\", type !group to retrieve all groups, usage of \".\" will tell Jack to retrieve teamsLink for ALL groups.\n")] string group = ".")
{
string chosenUniClass = String.Empty;
string chosenGroupString = String.Empty;
string chosenClassType = String.Empty;
string result = String.Empty;
if (!JackTheStudent.Program.classList.Any(c => c.ShortName == uniClass) && uniClass != ".")
{
await ctx.RespondAsync("There's no such class, you high bruh?");
return;
}
else if (!JackTheStudent.Program.classTypeList.Any(c => c.ShortName == classType) && classType != ".")
{
await ctx.RespondAsync("There's no such class type!");
return;
}
else if (!JackTheStudent.Program.groupList.Contains(group) && group != ".")
{
await ctx.RespondAsync("There's no such group dumbass. Try again!");
return;
}
if (uniClass == "." && classType == "." && group == ".")
{
try {
using (var db = new JackTheStudentContext()){
var teamsLinks = db.TeamsLink
.ToList();
if (teamsLinks.Count == 0)
{
await ctx.RespondAsync("There are no teams links logged!");
}
else
{
foreach (TeamsLink teamsLink in teamsLinks)
{
chosenClassType = teamsLink.GetFullClassType();
chosenUniClass = teamsLink.GetFullClassName();
if (teamsLink.GroupId == ".")
{
chosenGroupString = "everyone";
}
else
{
chosenGroupString = $"group {teamsLink.GroupId}";
}
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo.ToTitleCase(chosenUniClass) + $" {chosenClassType} teams link for {chosenGroupString}, takes place on {teamsLink.Date}. Link: {teamsLink.Link}";
}
await ctx.RespondAsync(result);
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
return;
}
else if (uniClass != "." && classType == "." && group == ".")
{
try {
chosenUniClass = JackTheStudent.Program.classList.Where(c => c.ShortName == uniClass).Select(c => c.Name).FirstOrDefault();
using (var db = new JackTheStudentContext()){
var teamsLinks = db.TeamsLink
.Where(x => x.Class == uniClass)
.ToList();
if (teamsLinks.Count == 0)
{
await ctx.RespondAsync($"There are no {chosenUniClass} teams links logged.");
}
else
{
foreach (TeamsLink teamsLink in teamsLinks)
{
chosenClassType = teamsLink.GetFullClassType();
if (teamsLink.GroupId == ".")
{
chosenGroupString = "everyone";
}
else
{
chosenGroupString = $"group {teamsLink.GroupId}";
}
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo.ToTitleCase(chosenUniClass) + $" {chosenClassType} teams link for {chosenGroupString}, takes place on {teamsLink.Date}. Link: {teamsLink.Link}";
}
await ctx.RespondAsync(result);
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
return;
}
else if (uniClass != "." && classType != "." && group == ".")
{
try {
chosenUniClass = JackTheStudent.Program.classList.Where(c => c.ShortName == uniClass).Select(c => c.Name).FirstOrDefault();
chosenClassType = JackTheStudent.Program.classTypeList.Where(c => c.ShortName == classType).Select(c => c.Name).FirstOrDefault();
using (var db = new JackTheStudentContext()){
var teamsLinks = db.TeamsLink
.Where(x => x.Class == uniClass && x.ClassType == classType)
.ToList();
if (teamsLinks.Count == 0)
{
await ctx.RespondAsync($"There are no {chosenUniClass} {chosenClassType} teams links logged.");
}
else
{
foreach (TeamsLink teamsLink in teamsLinks)
{
if (teamsLink.GroupId == ".")
{
chosenGroupString = "everyone";
}
else
{
chosenGroupString = $"group {teamsLink.GroupId}";
}
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo.ToTitleCase(chosenUniClass) + $" {chosenClassType} teams link for {chosenGroupString}, takes place on {teamsLink.Date}. Link: {teamsLink.Link}";
}
await ctx.RespondAsync(result);
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
return;
}
else if (uniClass == "." && classType != "." && group == ".")
{
chosenClassType = JackTheStudent.Program.classTypeList.Where(c => c.ShortName == classType).Select(c => c.Name).FirstOrDefault();
try {
using (var db = new JackTheStudentContext()){
var teamsLinks = db.TeamsLink
.Where(x => x.ClassType == classType)
.ToList();
if (teamsLinks.Count == 0)
{
string response = $"There are no {chosenClassType}s teams links logged!";
await ctx.RespondAsync(response);
return;
}
else
{
foreach (TeamsLink teamsLink in teamsLinks)
{
chosenUniClass = teamsLink.GetFullClassName();
if (teamsLink.GroupId == ".")
{
chosenGroupString = "everyone";
}
else
{
chosenGroupString = $"group {teamsLink.GroupId}";
}
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo.ToTitleCase(chosenUniClass) + $" {chosenClassType} teams link for {chosenGroupString}, takes place on {teamsLink.Date}. Link: {teamsLink.Link}";
}
await ctx.RespondAsync(result);
return;
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
}
else if (uniClass == "." && classType != "." && group != ".")
{
chosenClassType = JackTheStudent.Program.classTypeList.Where(c => c.ShortName == classType).Select(c => c.Name).FirstOrDefault();
chosenGroupString = $"group {group}";
try {
using (var db = new JackTheStudentContext()){
var teamsLinks = db.TeamsLink
.Where(x => x.ClassType == classType && x.GroupId == group)
.ToList();
if (teamsLinks.Count == 0)
{
string response = $"There are no {chosenClassType}s teams links logged for group {group}!";
await ctx.RespondAsync(response);
return;
}
else
{
result = String.Empty;
foreach (TeamsLink teamsLink in teamsLinks)
{
chosenUniClass = teamsLink.GetFullClassName();
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo.ToTitleCase(chosenUniClass) + $" {chosenClassType} teams link for {chosenGroupString}, takes place on {teamsLink.Date}. Link: {teamsLink.Link}";
}
await ctx.RespondAsync(result);
return;
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
}
else if (uniClass != "." && classType == "." && group != ".")
{
chosenUniClass = JackTheStudent.Program.classList.Where(c => c.ShortName == uniClass).Select(c => c.Name).FirstOrDefault();
chosenGroupString = $"group {group}";
try {
using (var db = new JackTheStudentContext()){
var teamsLinks = db.TeamsLink
.Where(x => x.Class == uniClass && x.GroupId == group)
.ToList();
if (teamsLinks.Count == 0)
{
string response = $"There are no {chosenUniClass} teams links logged for group {group} logged!";
await ctx.RespondAsync(response);
return;
}
else
{
foreach (TeamsLink teamsLink in teamsLinks)
{
teamsLink.GetFullClassType();
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo.ToTitleCase(chosenUniClass) + $" {chosenClassType} teams link for {chosenGroupString}, takes place on {teamsLink.Date}. Link: {teamsLink.Link}";
}
await ctx.RespondAsync(result);
return;
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
}
else
{
chosenUniClass = JackTheStudent.Program.classList.Where(c => c.ShortName == uniClass).Select(c => c.Name).FirstOrDefault();
chosenClassType = JackTheStudent.Program.classTypeList.Where(c => c.ShortName == classType).Select(c => c.Name).FirstOrDefault();
chosenGroupString = $"group {group}";
try {
using (var db = new JackTheStudentContext()){
var teamsLinks = db.TeamsLink
.Where(x => x.Class == uniClass && x.ClassType == classType && x.GroupId == group)
.ToList();
if (teamsLinks.Count == 0)
{
string response = $"There are no {chosenUniClass} {chosenClassType}s for group {group} logged!";
await ctx.RespondAsync(response);
return;
}
else
{
foreach (TeamsLink teamsLink in teamsLinks)
{
result = result + "\n" + CultureInfo.CurrentCulture.TextInfo.ToTitleCase(chosenUniClass) + $" {chosenClassType} teams link for {chosenGroupString}, takes place on {teamsLink.Date}. Link: {teamsLink.Link}";
}
await ctx.RespondAsync(result);
return;
}
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Show logs failed");
return;
}
}
}
async Task InitBot(string[] args)
{
try {
using (var db = new JackTheStudentContext()){
classTypeList = db.ClassType.ToList();
groupList = db.Group.Select(x => x.GroupId).ToList();
classList = db.Class.ToList();
reminderList = db.PersonalReminder.ToList();
examList = db.Exam.ToList();
shortTestList = db.ShortTest.ToList();
ClassMaterialList = db.ClassMaterial.ToList();
homeworkList = db.Homework.ToList();
labReportList = db.LabReport.ToList();
projectList = db.Project.ToList();
testList = db.Test.ToList();
teamsLinkList = db.TeamsLink.ToList();
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
}
try {
using (var fileStream = File.OpenRead(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "resource", "quotes.txt")))
using (var reader = new StreamReader(fileStream)) {
String quote;
while ((quote = reader.ReadLine()) != null)
{
quotes.Add(quote);
}
reader.Close();
fileStream.Close();
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
}
CultureInfo culture = (CultureInfo)CultureInfo.CurrentCulture.Clone();
culture.DateTimeFormat.ShortDatePattern = "dd-MM-yyyy HH:mm";
culture.DateTimeFormat.LongTimePattern = "";
Thread.CurrentThread.CurrentCulture = culture;
try {
Console.WriteLine("[Jack] Welcome!");
_cts = new CancellationTokenSource();
Console.WriteLine("[Jack] Loading config file..");
_config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("config.json", optional: false, reloadOnChange: true)
.Build();
Console.WriteLine("[Jack] Creating discord client..");
_discord = new DiscordClient(new DiscordConfiguration {
Token = Environment.GetEnvironmentVariable("BOT_TOKEN"),
TokenType = TokenType.Bot,
AutoReconnect = true
});
_discord.UseInteractivity(new InteractivityConfiguration()
{
PaginationBehaviour = PaginationBehaviour.WrapAround,
Timeout = TimeSpan.FromSeconds(30)
});
_commands = _discord.UseCommandsNext(new CommandsNextConfiguration {
StringPrefixes = new string[] { _config.GetValue <string>("discord:CommandPrefix") },
EnableDms = true,
EnableMentionPrefix = true,
DmHelp = true
});
Console.WriteLine("[Jack] Loading command modules..");
_commands.RegisterCommands(Assembly.GetExecutingAssembly());
Console.WriteLine("[Jack] Command modules loaded.");
_discord.Ready += OnClientReady;
RunAsync(args).Wait();
}
catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
}
}
public async Task SemesterClass(CommandContext ctx)
{
List <Class> backupClasses = new List <Class>();
await ctx.RespondAsync("Are you absolutely sure you want to do it?");
var intr = ctx.Client.GetInteractivity();
var sureResponse = await intr.WaitForMessageAsync(
c => c.Author.Id == ctx.Message.Author.Id,
TimeSpan.FromSeconds(5)
);
if (sureResponse.Result.Content.ToLower() != "yes" || sureResponse.Result == null)
{
await ctx.RespondAsync("Aborting, all good");
return;
}
using (var context = new JackTheStudentContext()) {
backupClasses = context.Class.ToList();
var truncateText = "truncate table class";
try {
await context.Database.ExecuteSqlRawAsync(truncateText);
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Truncate failed");
return;
}
await context.SaveChangesAsync();
await ctx.RespondAsync("Truncate successful");
}
using (var db = new JackTheStudentContext()){
await ctx.RespondAsync("Let's populate the table with new data, how many classes are there for the new semester?");
var amountOfClassesResponse = await intr.WaitForMessageAsync(
c => c.Author.Id == ctx.Message.Author.Id,
TimeSpan.FromSeconds(10)
);
if (amountOfClassesResponse.Result == null)
{
await RestoreClasses(backupClasses, ctx);
return;
}
short classesCount = 0;
while (!Int16.TryParse(amountOfClassesResponse.Result.Content, out classesCount) || classesCount < 2)
{
await ctx.RespondAsync("That's not a valid number, try again.");
amountOfClassesResponse = await intr.WaitForMessageAsync(
c => c.Author.Id == ctx.Message.Author.Id,
TimeSpan.FromSeconds(10)
);
if (amountOfClassesResponse.TimedOut)
{
await RestoreClasses(backupClasses, ctx);
return;
}
}
if (amountOfClassesResponse.Result == null)
{
await RestoreClasses(backupClasses, ctx);
return;
}
for (int i = 1; i <= classesCount; i++)
{
await ctx.RespondAsync($"What's the name and shortname of the {i} class? Answer with NAME SHORTNAME");
var newClassNames = await intr.WaitForMessageAsync(
c => c.Author.Id == ctx.Message.Author.Id,
TimeSpan.FromSeconds(30)
);
if (newClassNames.TimedOut)
{
await RestoreClasses(backupClasses, ctx);
return;
}
string[] classArray = newClassNames.Result.Content.Split(new Char[] { ' ' });
while (classArray.Count() != 2)
{
await ctx.RespondAsync("Try again -.-");
newClassNames = await intr.WaitForMessageAsync(
c => c.Author.Id == ctx.Message.Author.Id,
TimeSpan.FromSeconds(30)
);
classArray = newClassNames.Result.Content.Split(new Char[] { ' ' });
if (newClassNames.TimedOut)
{
await RestoreClasses(backupClasses, ctx);
return;
}
}
var newClass = new Class {
Name = classArray[0],
ShortName = classArray[1]
};
db.Class.Add(newClass);
await ctx.RespondAsync($"Added class: {newClass.Name} with short name: {newClass.ShortName}");
Task.Delay(1000).Wait();
}
try {
await db.SaveChangesAsync();
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await RestoreClasses(backupClasses, ctx);
return;
}
await db.SaveChangesAsync();
await ctx.RespondAsync("Class table repopulated successfully");
}
return;
}
public async Task TeamsLinkLog(CommandContext ctx,
[Description("\nTakes class' short names, type !class to retrive all classes.\n")] string uniClass = "",
[Description("\nTakes class' short names, type !class to retrive all classes.\n")] string classType = "",
[Description("\nTakes dates in dd/mm/yyyy format, accepts different separators.\n")] string eventDayOfWeek = "",
[Description("\nTakes time in hh:mm format.\n")] string eventTime = "",
[Description("\nTakes group IDs, type !group to retrieve all groups.\n")] string groupId = ".",
[Description("\nTakes time in hh:mm format.\n")] string link = "",
[Description("\nTakes additional information, multiple words must be wrapped with \"\".\n")] string additionalInfo = "")
{
DayOfWeek parsedEventDayOfWeek = new DayOfWeek();
DateTime parsedEventTime = new DateTime();
if (uniClass == "")
{
await ctx.RespondAsync("Learn to read you dumbass. The command looks like: !teamsLink <group> <class> <teamsLinkDate> <teamsLinkTime> Try again!");
return;
}
else if (!JackTheStudent.Program.classList.Any(c => c.ShortName == uniClass))
{
await ctx.RespondAsync("There's no such class, you high bruh?");
return;
}
else if (classType == "")
{
await ctx.RespondAsync("Class type is missing!");
return;
}
else if (!JackTheStudent.Program.classTypeList.Any(c => c.ShortName == classType))
{
await ctx.RespondAsync("There's no such class type -_- . Try again!");
return;
}
else if (eventDayOfWeek == "")
{
await ctx.RespondAsync("There's date missing, fix it!");
return;
}
else if (!DayOfWeek.TryParse(eventDayOfWeek, out parsedEventDayOfWeek))
{
await ctx.RespondAsync("That's not a valid date you retard, learn to type!");
return;
}
else if (eventTime == "")
{
await ctx.RespondAsync("There's time missing, fix it!");
return;
}
else if (!DateTime.TryParse(eventTime, out parsedEventTime))
{
await ctx.RespondAsync("That's not a valid time you retard, learn to type!");
return;
}
else if (link == "")
{
await ctx.RespondAsync("Learn to read you dumbass. The command looks like: !teamsLink <group> <class> <teamsLinkDate> <teamsLinkTime> Try again!");
return;
}
else if (!link.Contains("teams.microsoft.com/l/meetup-join/19%3ameeting"))
{
await ctx.RespondAsync("That's not a valid teams meetup link!");
return;
}
else if (!JackTheStudent.Program.groupList.Contains(groupId) && groupId != ".")
{
await ctx.RespondAsync("There's no such group dumbass. Try again!");
return;
}
else
{
try {
using (var db = new JackTheStudentContext()){
var teamsLink = new TeamsLink {
Class = uniClass,
ClassType = classType,
Date = $"{parsedEventDayOfWeek} {eventTime}",
GroupId = groupId,
Link = link,
LogById = ctx.Message.Author.Id.ToString(),
LogByUsername = ctx.Message.Author.Username + "#" + ctx.Message.Author.Discriminator,
AdditionalInfo = additionalInfo
};
JackTheStudent.Program.teamsLinkList.Add(teamsLink);
db.TeamsLink.Add(teamsLink);
await db.SaveChangesAsync();
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Log failed");
return;
}
await ctx.RespondAsync("Teams link logged successfully");
return;
}
}
public async Task ExamLog(CommandContext ctx,
[Description("\nTakes class' short names, type !class to retrive all classes.\n")] string classType = "",
[Description("\nTakes dates in dd/mm/yyyy format, accepts different separators.\n")] string examDate = "",
[Description("\nTakes time in hh:mm format.\n")] string examTime = "",
[Description("\nTakes additional information, multiple words must be wrapped with \"\".\n")] string additionalInfo = "",
[Description("\nTakes material links, multiple links must be wrapped with \"\".\n")] string materials = "")
{
DateTime parsedEventDate = new DateTime();
DateTime parsedEventTime = new DateTime();
if (classType == "")
{
await ctx.RespondAsync("Learn to read you dumbass. The command looks like: !exam <class> <examDate> <examTime> Try again!");
return;
}
else if (!JackTheStudent.Program.classList.Any(c => c.ShortName == classType))
{
await ctx.RespondAsync("There's no such class, you high bruh?");
return;
}
else if (examDate == "")
{
await ctx.RespondAsync("There's date missing, fix it!");
return;
}
else if (!DateTime.TryParse(examDate, out parsedEventDate))
{
await ctx.RespondAsync("That's not a valid date you retard, learn to type!");
return;
}
else if (examTime == "")
{
await ctx.RespondAsync("There's time missing, fix it!");
return;
}
else if (!DateTime.TryParse(examTime, out parsedEventTime))
{
await ctx.RespondAsync("That's not a valid time you retard, learn to type!");
return;
}
else
{
try {
using (var db = new JackTheStudentContext()){
var exam = new Exam {
ClassShortName = classType,
Class = JackTheStudent.Program.classList.Where(e => e.ShortName == classType).Select(e => e.Name).FirstOrDefault(),
Date = parsedEventDate.Date.Add(parsedEventTime.TimeOfDay),
LogById = ctx.Message.Author.Id.ToString(),
LogByUsername = ctx.Message.Author.Username + "#" + ctx.Message.Author.Discriminator,
AdditionalInfo = additionalInfo,
Materials = materials
};
JackTheStudent.Program.examList.Add(exam);
db.Exam.Add(exam);
await db.SaveChangesAsync();
}
} catch (Exception ex) {
Console.Error.WriteLine("[Jack] " + ex.ToString());
await ctx.RespondAsync("Exam log failed");
return;
}
await ctx.RespondAsync("Logged successfully");
return;
}
}
