public async Task <RuntimeResult> SubscribeToThread()
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODMAIL))
{
return(CustomResult.FromIgnored());
}
var bot = Global.Bot;
using (var db = new Database())
{
var existing = db.ThreadSubscribers.AsQueryable().Where(sub => sub.ModMailThreadId == Context.Channel.Id && sub.UserId == Context.User.Id);
if (existing.Count() > 0)
{
return(CustomResult.FromError("You are already subscribed!"));
}
}
var subscription = new ThreadSubscriber();
subscription.ModMailThreadId = Context.Channel.Id;
subscription.UserId = Context.User.Id;
using (var db = new Database())
{
db.ThreadSubscribers.Add(subscription);
db.SaveChanges();
}
await Task.CompletedTask;
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> ShowEmoteStats([Optional] string range)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.EMOTE_TRACKING))
{
return(CustomResult.FromIgnored());
}
TimeSpan fromWhere;
DateTime startDate;
if (range != null)
{
fromWhere = Extensions.GetTimeSpanFromString(range);
startDate = DateTime.Now - fromWhere;
}
else
{
startDate = DateTime.MinValue;
}
var embedsToPost = new List <Embed>();
AddEmbedsOfEmotes(embedsToPost, startDate, false, "Static emotes");
AddEmbedsOfEmotes(embedsToPost, startDate, true, "Animated emotes");
foreach (var embed in embedsToPost)
{
await Context.Channel.SendMessageAsync(embed : embed);
await Task.Delay(500);
}
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> ShowProfanities(IGuildUser user)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.PROFANITY))
{
return(CustomResult.FromIgnored());
}
using (var db = new Database()){
var allProfanities = db.Profanities.AsQueryable().Where(pro => pro.UserId == user.Id);
var actualProfanities = allProfanities.AsQueryable().Where(pro => pro.Valid == true).Count();
var falseProfanities = allProfanities.AsQueryable().Where(pro => pro.Valid == false).Count();
var builder = new EmbedBuilder();
builder.AddField(f => {
f.Name = "Actual";
f.Value = actualProfanities;
f.IsInline = true;
});
builder.AddField(f => {
f.Name = "False positives";
f.Value = falseProfanities;
f.IsInline = true;
});
builder.WithAuthor(new EmbedAuthorBuilder().WithIconUrl(user.GetAvatarUrl()).WithName(Extensions.FormatUserName(user)));
await Context.Channel.SendMessageAsync(embed : builder.Build());
return(CustomResult.FromSuccess());
}
}
public async Task <RuntimeResult> UnsubscribeFromThread()
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODMAIL))
{
return(CustomResult.FromIgnored());
}
var bot = Global.Bot;
using (var db = new Database())
{
var existing = db.ThreadSubscribers.AsQueryable().Where(sub => sub.ModMailThreadId == Context.Channel.Id && sub.UserId == Context.User.Id);
if (existing.Count() == 0)
{
return(CustomResult.FromError("You are not subscribed!"));
}
}
using (var db = new Database())
{
var existing = db.ThreadSubscribers.AsQueryable().Where(sub => sub.ModMailThreadId == Context.Channel.Id && sub.UserId == Context.User.Id).First();
db.ThreadSubscribers.Remove(existing);
db.SaveChanges();
}
await Task.CompletedTask;
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> OBanAsync(ulong name, [Remainder] string reason = null)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODERATION))
{
return(CustomResult.FromIgnored());
}
var banLogChannel = Context.Guild.GetTextChannel(Global.PostTargets[PostTarget.BAN_LOG]);
await Context.Guild.AddBanAsync(name, 0, reason);
MuteTimerManager.UnMuteUserCompletely(name);
if (reason == null)
{
reason = "No reason provided.";
}
var banMessage = new EmbedBuilder()
.WithColor(9896005)
.WithTitle("⛔️ Banned User")
.AddField("UserId", name, true)
.AddField("By", Extensions.FormatUserNameDetailed(Context.User), true)
.AddField("Reason", reason)
.AddField("Link", Extensions.FormatLinkWithDisplay("Jump!", Context.Message.GetJumpUrl()));
await banLogChannel.SendMessageAsync(embed : banMessage.Build());
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> UnMuteUser(IGuildUser user)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODERATION))
{
return(CustomResult.FromIgnored());
}
return(await MuteTimerManager.UnMuteUser(user.Id, ulong.MaxValue));
}
public async Task <RuntimeResult> ShowLeaderboard([Optional] int page)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.EXPERIENCE))
{
return(CustomResult.FromIgnored());
}
var embedBuilder = new EmbedBuilder();
using (var db = new Database())
{
var allUsers = db.Users.AsQueryable().OrderByDescending(us => us.XP).ToList();
var usersInLeaderboard = db.Users.AsQueryable().OrderByDescending(us => us.XP);
System.Collections.Generic.List <User> usersToDisplay;
if (page > 1)
{
usersToDisplay = usersInLeaderboard.Skip((page - 1) * 10).Take(10).ToList();
}
else
{
usersToDisplay = usersInLeaderboard.Take(10).ToList();
}
embedBuilder = embedBuilder.WithTitle("Leaderboard of gained experience");
var description = new StringBuilder();
if (page * 10 > allUsers.Count())
{
description.Append("Page not found. \n");
}
else
{
description.Append("Rank | Name | Experience | Level | Messages \n");
foreach (var user in usersToDisplay)
{
var rank = allUsers.IndexOf(user) + 1;
var userInGuild = Context.Guild.GetUser(user.Id);
var name = userInGuild != null?Extensions.FormatUserName(userInGuild) : "User left guild " + user.Id;
description.Append($"[#{rank}] → **{name}**\n");
description.Append($"XP: {user.XP} | Level: {user.Level} | Messages: {user.MessageCount} \n \n");
}
description.Append("\n");
}
description.Append("Your placement: \n");
var caller = db.Users.AsQueryable().Where(us => us.Id == Context.Message.Author.Id).FirstOrDefault();
if (caller != null)
{
var callRank = allUsers.IndexOf(caller) + 1;
var userInGuild = Context.Guild.GetUser(caller.Id);
description.Append($"[#{callRank}] → *{Extensions.FormatUserName(userInGuild)}* XP: {caller.XP} messages: {caller.MessageCount} \n");
description.Append($"Level: {caller.Level}");
}
embedBuilder = embedBuilder.WithDescription(description.ToString());
embedBuilder.WithFooter(new EmbedFooterBuilder().WithText("Use leaderboard <page> to view more of the leaderboard"));
await Context.Channel.SendMessageAsync(embed : embedBuilder.Build());
}
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> SetupInfoPost()
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.ASSIGNABLE_ROLES))
{
return(CustomResult.FromIgnored());
}
await new SelfAssignabeRolesManager().SetupInfoPost();
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> PrintStarStats()
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.STARBOARD))
{
return(CustomResult.FromIgnored());
}
var mostStars = new Dictionary <ulong, ulong>();
using (var db = new Database())
{
var mostStarredMessages = db.StarboardMessages.AsQueryable().Where(p => !p.Ignored).OrderByDescending(p => p.Starcount).Take(3).ToArray();
var starMessagesCount = db.StarboardMessages.AsQueryable().Where(p => !p.Ignored).Count();
// we could either store the ignored flag in the relation as well and duplicate the flag, or we could join here...
var totalStarsCount = db.StarboardPostRelations.Include(message => message.Message).Where(message => !message.Message.Ignored).Count();
var mostStarerUser = db.StarboardPostRelations
.Include(message => message.Message)
.Where(message => !message.Message.Ignored)
.GroupBy(p => p.UserId)
.Select(g => new { id = g.Key, count = g.Count() })
.OrderByDescending(p => p.count)
.Select(p => new KeyValuePair <ulong, int>(p.id, p.count))
.ToArray();
var mostStarRecieverUser = db.StarboardMessages
.AsQueryable().Where(p => !p.Ignored)
.GroupBy(p => p.AuthorId)
.Select(g => new { id = g.Key, count = g.Sum(p => p.Starcount) })
.OrderByDescending(p => p.count)
.Select(p => new KeyValuePair <ulong, int>(p.id, (int)p.count))
.ToArray();
var embed = new EmbedBuilder();
embed.WithTitle("Server Starboard stats");
embed.WithDescription($"{starMessagesCount} starred messages with {totalStarsCount} stars in total");
var badges = new List <String>();
badges.Add("🥇");
badges.Add("🥈");
badges.Add("🥉");
var firstPostField = new EmbedFieldBuilder()
.WithName("Top starred posts")
.WithValue(BuildStringForMessage(mostStarredMessages, badges));
var secondPostField = new EmbedFieldBuilder()
.WithName("Top star receiver")
.WithValue(BuildStringForPoster(mostStarRecieverUser, badges));
var thirdPostField = new EmbedFieldBuilder()
.WithName("Top star givers")
.WithValue(BuildStringForPoster(mostStarerUser, badges));
embed.WithFields(firstPostField);
embed.WithFields(secondPostField);
embed.WithFields(thirdPostField);
await Context.Channel.SendMessageAsync(embed : embed.Build());
}
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> CloseThreadSilently([Optional][Remainder] string note)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODMAIL))
{
return(CustomResult.FromIgnored());
}
await new ModMailManager().CloseThreadSilently(Context.Channel, note);
return(CustomResult.FromIgnored());
}
public async Task <RuntimeResult> PostNicknameResponse()
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODMAIL))
{
return(CustomResult.FromIgnored());
}
await new ModMailManager().RespondWithUsernameTemplateAndSetReminder(Context.Channel, Context.User, Context.Message);
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> ReplyToModMailAnonymously([Remainder] string message)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODMAIL))
{
return(CustomResult.FromIgnored());
}
await new ModMailManager().CreateModeratorReply(Context.Message, Context.Channel, Context.User, message, true, true);
return(CustomResult.FromIgnored());
}
public async Task <RuntimeResult> BanAsync(IGuildUser user, [Remainder] string reason = null)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODERATION))
{
return(CustomResult.FromIgnored());
}
if (user.IsBot)
{
return(CustomResult.FromError("You can't ban bots."));
}
if (user.GuildPermissions.PrioritySpeaker)
{
return(CustomResult.FromError("You can't ban staff."));
}
if (reason == null)
{
reason = "No reason provided.";
}
try
{
try
{
const string banDMMessage = "You were banned on r/OnePlus for the following reason: {0}\n" +
"If you believe this to be a mistake, please send an appeal e-mail with all the details to [email protected]";
await user.SendMessageAsync(string.Format(banDMMessage, reason));
} catch (HttpException) {
await Context.Channel.SendMessageAsync("Seems like user disabled DMs, cannot send message about the ban.");
}
await Context.Guild.AddBanAsync(user, 0, reason);
MuteTimerManager.UnMuteUserCompletely(user.Id);
var banLogChannel = Context.Guild.GetTextChannel(Global.PostTargets[PostTarget.BAN_LOG]);
var banlog = new EmbedBuilder()
.WithColor(9896005)
.WithTitle("⛔️ Banned User")
.AddField("User", Extensions.FormatUserNameDetailed(user), true)
.AddField("By", Extensions.FormatUserNameDetailed(Context.User), true)
.AddField("Reason", reason)
.AddField("Link", Extensions.FormatLinkWithDisplay("Jump!", Context.Message.GetJumpUrl()));
await banLogChannel.SendMessageAsync(embed : banlog.Build());
return(CustomResult.FromSuccess());
}
catch (Exception ex)
{
// may not be needed
// await Context.Guild.AddBanAsync(user, 0, reason);
return(CustomResult.FromError(ex.Message));
}
}
public async Task <RuntimeResult> SetNicknameTo(IGuildUser user, [Optional][Remainder] string newNickname)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODERATION))
{
return(CustomResult.FromIgnored());
}
await user.ModifyAsync((user) => user.Nickname = newNickname);
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> SetExpGainEnabled(IGuildUser user, bool newValue)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.EXPERIENCE))
{
return(CustomResult.FromIgnored());
}
new ExpManager().SetXPDisabledTo(user, newValue);
await Task.CompletedTask;
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> EnableModmailForUser(IGuildUser user)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODMAIL))
{
return(CustomResult.FromIgnored());
}
new ModMailManager().EnableModmailForUser(user);
await new ModMailManager().SendModmailUnmutedNotification(user, Context.User);
await Task.CompletedTask;
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> DisableCurrentThread(string duration, [Remainder][Optional] string note)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODMAIL))
{
return(CustomResult.FromIgnored());
}
TimeSpan mutedTime = Extensions.GetTimeSpanFromString(duration);
var until = DateTime.Now + mutedTime;
var manager = new ModMailManager();
await manager.LogForDisablingAction(Context.Channel, note, until, Context.User);
manager.DisableModMailForUserWithExistingThread(Context.Channel, until);
return(CustomResult.FromIgnored());
}
public async Task <RuntimeResult> DeleteMessage(params string[] parameters)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODMAIL))
{
return(CustomResult.FromIgnored());
}
if (parameters.Length < 1)
{
return(CustomResult.FromError("Required parameter: <messageId>"));
}
ulong messageId = (ulong)Convert.ToUInt64(parameters[0]);
await new ModMailManager().DeleteMessage(messageId, Context.Channel, Context.User);
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> NewsAsync([Remainder] string news)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.NEWS))
{
return(CustomResult.FromIgnored());
}
var guild = Context.Guild;
var user = (SocketGuildUser)Context.Message.Author;
var newsChannel = guild.GetTextChannel(Global.PostTargets[PostTarget.NEWS]) as SocketNewsChannel;
var newsRole = guild.GetRole(Global.Roles["news"]);
if (news.Contains("@everyone") || news.Contains("@here") || news.Contains("@news"))
{
return(CustomResult.FromError("Your news article contained one or more illegal pings!"));
}
await newsRole.ModifyAsync(x => x.Mentionable = true);
IMessage posted;
var messageToPost = news + Environment.NewLine + Environment.NewLine + newsRole.Mention + Environment.NewLine + "- " + Context.Message.Author;
try {
if (Context.Message.Attachments.Any())
{
var builder = new EmbedBuilder();
if (Context.Message.Attachments.Any())
{
var attachment = Context.Message.Attachments.First();
builder.WithImageUrl(attachment.ProxyUrl).Build();
}
posted = await newsChannel.SendMessageAsync(messageToPost, embed : builder.Build());
}
else
{
posted = await newsChannel.SendMessageAsync(messageToPost);
}
}
finally
{
await newsRole.ModifyAsync(x => x.Mentionable = false);
}
Global.NewsPosts[Context.Message.Id] = posted.Id;
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> ShowLevels([Optional] IGuildUser user)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.EXPERIENCE))
{
return(CustomResult.FromIgnored());
}
IUser userToUse = null;
if (user != null)
{
userToUse = user;
}
else
{
userToUse = Context.Message.Author;
}
if (userToUse.IsBot)
{
return(CustomResult.FromIgnored());
}
var embedBuilder = new EmbedBuilder();
using (var db = new Database())
{
var userInDb = db.Users.AsQueryable().Where(us => us.Id == userToUse.Id).FirstOrDefault();
if (userInDb != null)
{
var rank = db.Users.AsQueryable().OrderByDescending(us => us.XP).ToList().IndexOf(userInDb) + 1;
var nextLevel = db.ExperienceLevels.AsQueryable().Where(lv => lv.Level == userInDb.Level + 1).FirstOrDefault();
embedBuilder.WithAuthor(new EmbedAuthorBuilder().WithIconUrl(userToUse.GetAvatarUrl()).WithName(Extensions.FormatUserName(userToUse)));
embedBuilder.AddField("XP", userInDb.XP, true);
embedBuilder.AddField("Level", userInDb.Level, true);
embedBuilder.AddField("Messages", userInDb.MessageCount, true);
if (nextLevel != null)
{
embedBuilder.AddField("XP to next Level", nextLevel.NeededExperience - userInDb.XP, true);
}
embedBuilder.AddField("Rank", rank, true);
}
else
{
embedBuilder.WithTitle("No experience tracked.").WithDescription("Please check back in a minute.");
}
}
await Context.Channel.SendMessageAsync(embed : embedBuilder.Build());
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> PrintHelp([Optional] string commandOrModule)
{
StringBuilder sb = new StringBuilder();
string footerText;
if (commandOrModule == null)
{
foreach (var mod in _commands.Modules.Where(m => m.Parent == null))
{
sb.Append(HelpBuilder.BuildGeneralModuleDescription(mod));
sb.Append(Environment.NewLine);
}
footerText = "Use 'help <module name>' for a list of commands of this module (case insensitive).";
}
else
{
commandOrModule = commandOrModule.ToLower();
var probableModule = _commands.Modules.Where(m => m.Name.ToLower().Equals(commandOrModule));
if (probableModule.Any())
{
sb.Append(HelpBuilder.BuildDetailedModuleDescription(probableModule.First(), Context, _services));
footerText = "Use 'help <command name>' for a detailed description of the command.";
}
else
{
var probableCommand = _commands.Commands.Where(c => c.Name.ToLower().Equals(commandOrModule));
if (probableCommand.Any())
{
var command = probableCommand.First();
sb.Append(HelpBuilder.BuildDetailedCommandDescription(command));
}
else
{
sb.Append("No module/command found for that name.");
}
footerText = "";
}
}
var builder = new EmbedBuilder();
builder.WithDescription(sb.ToString());
builder.WithFooter(new EmbedFooterBuilder().WithText(footerText));
builder.WithTitle("OneplusBot - Help");
await Context.Channel.SendMessageAsync(embed : builder.Build());
return(CustomResult.FromIgnored());
}
public async Task <RuntimeResult> DisableModMailForUser(IGuildUser user, [Remainder] string duration)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODMAIL))
{
return(CustomResult.FromIgnored());
}
if (duration is null)
{
return(CustomResult.FromError("You need to provide a duration."));
}
TimeSpan mutedTime = Extensions.GetTimeSpanFromString(duration);
var until = DateTime.Now + mutedTime;
new ModMailManager().DisableModmailForUser(user, until);
await new ModMailManager().SendModmailMuteNofication(user, Context.User, until);
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> EditMessage(params string[] parameters)
{
if (parameters.Length < 2)
{
return(CustomResult.FromError("Required parameters: <messageId> <new text>"));
}
ulong messageId = (ulong)Convert.ToUInt64(parameters[0]);
string newText = "";
string[] reasons = new string[parameters.Length - 1];
Array.Copy(parameters, 1, reasons, 0, parameters.Length - 1);
newText = string.Join(" ", reasons);
await new ModMailManager().EditMessage(newText, messageId, Context.Channel, Context.User);
await Context.Message.DeleteAsync();
return(CustomResult.FromIgnored());
}
public async Task <RuntimeResult> ClearwarnAsync(uint index)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODERATION))
{
return(CustomResult.FromIgnored());
}
var monitor = Context.Message.Author;
using (var db = new Database())
{
IQueryable <WarnEntry> warnings = db.Warnings;
var selection = warnings.First(x => x.ID == index);
db.Warnings.Remove(selection);
await db.SaveChangesAsync();
}
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> ChangeModMode(String newState)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODERATION))
{
return(CustomResult.FromIgnored());
}
var role = Context.Guild.GetRole(Global.ModModeRoleId);
if (newState == "on")
{
await role.ModifyAsync(role => role.Color = new Color(Global.ModModeRoleColor));
}
else
{
await role.ModifyAsync(role => role.Color = new Color(0));
}
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> ContactUser(IGuildUser user)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODMAIL))
{
return(CustomResult.FromIgnored());
}
var existing = ModMailManager.GetOpenModmailForUser(user);
if (existing != null)
{
await Context.Channel.SendMessageAsync(embed : ModMailEmbedHandler.GetThreadAlreadyExistsEmbed(existing));
}
else
{
await ModMailManager.ContactUser(user, Context.Channel, true);
}
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> PurgeAsync([Remainder] double delmsg)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODERATION))
{
return(CustomResult.FromIgnored());
}
if (delmsg > 100 || delmsg <= 0)
{
return(CustomResult.FromError("Use a number between 1-100"));
}
int delmsgInt = (int)delmsg;
ulong oldmessage = Context.Message.Id;
var isInModmailContext = Global.ModMailThreads.Exists(ch => ch.ChannelId == Context.Channel.Id);
// Download all messages that the user asks for to delete
var messages = await Context.Channel.GetMessagesAsync(oldmessage, Direction.Before, delmsgInt).FlattenAsync();
var saveMessagesToDelete = new List <IMessage>();
if (isInModmailContext)
{
var manager = new ModMailManager();
foreach (var message in messages)
{
var messageCanBeDeleted = await manager.DeleteMessageInThread(Context.Channel.Id, message.Id, false);
if (messageCanBeDeleted)
{
saveMessagesToDelete.Add(message);
}
}
}
else
{
saveMessagesToDelete.AddRange(messages);
}
await((ITextChannel)Context.Channel).DeleteMessagesAsync(saveMessagesToDelete);
await Context.Message.DeleteAsync();
return(CustomResult.FromIgnored());
}
public async Task <RuntimeResult> ShowActiveReminders()
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.REMINDER))
{
return(CustomResult.FromIgnored());
}
using (var db = new Database())
{
var activeReminders = db.Reminders.AsQueryable().Where(r => !r.Reminded && r.RemindedUserId == Context.User.Id).ToList();
var currentEmbedBuilder = new EmbedBuilder();
var embedsToPost = new List <Embed>();
currentEmbedBuilder.WithTitle("Active reminders");
if (activeReminders.Count() > 0)
{
var count = 0;
foreach (var reminder in activeReminders)
{
var reminderLink = Extensions.GetMessageUrl(Global.ServerID, reminder.ChannelId, reminder.MessageId, $"**Reminder**");
currentEmbedBuilder.AddField($"Reminder {reminder.ID}", $"{reminderLink} set on {Extensions.FormatDateTime(reminder.ReminderDate)} and due on {Extensions.FormatDateTime(reminder.TargetDate)} with text: " + reminder.RemindText, true);
count++;
if (((count % EmbedBuilder.MaxFieldCount) == 0) && reminder != activeReminders.Last())
{
embedsToPost.Add(currentEmbedBuilder.Build());
currentEmbedBuilder = new EmbedBuilder();
var currentPage = count / EmbedBuilder.MaxFieldCount + 1;
currentEmbedBuilder.WithFooter(new EmbedFooterBuilder().WithText($"Page {currentPage}"));
}
}
embedsToPost.Add(currentEmbedBuilder.Build());
}
else
{
currentEmbedBuilder.WithDescription("No active reminders");
embedsToPost.Add(currentEmbedBuilder.Build());
}
foreach (var embed in embedsToPost)
{
await Context.Channel.SendMessageAsync(embed : embed);
await Task.Delay(400);
}
}
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> SetRoleToLevel([Optional] uint level, [Optional] ulong roleId)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.EXPERIENCE))
{
return(CustomResult.FromIgnored());
}
if (level == 0 && roleId == 0)
{
await new ExpManager().ShowLevelconfiguration(Context.Channel);
}
else
{
new ExpManager().SetRoleToLevel(level, roleId);
}
await Task.CompletedTask;
return(CustomResult.FromSuccess());
}
public async Task <RuntimeResult> AddUserNote(IGuildUser user, [Remainder] String text)
{
if (CommandHandler.FeatureFlagDisabled(FeatureFlag.MODERATION))
{
return(CustomResult.FromIgnored());
}
using (var db = new Database())
{
var note = new UserNote()
{
UserId = user.Id,
NoteText = text,
CreatedDate = DateTime.Now
};
db.UserNotes.Add(note);
db.SaveChanges();
}
return(CustomResult.FromSuccess());
}
