public async Task B()
{
var pages = new List <PaginatedMessage.Page>();
var sb = new StringBuilder();
foreach (var blacklistw in Context.Server.Antispam.Blacklist.BlacklistWordSet)
{
if (sb.ToString().Length >= 800)
{
pages.Add(new PaginatedMessage.Page
{
description = sb.ToString()
});
sb.Clear();
}
sb.Append("**Word(s)**\n" +
$"{string.Join("\n", blacklistw.WordList)}\n" +
"**Response**\n" +
$"{blacklistw.BlacklistResponse ?? Context.Server.Antispam.Blacklist.DefaultBlacklistMessage}\n\n");
}
pages.Add(new PaginatedMessage.Page
{
description = sb.ToString()
});
var pager = new PaginatedMessage
{
Title = "Blacklisted Messages :stop_button: to remove",
Pages = pages
};
await PagedReplyAsync(pager, true, true, true);
}
public static async Task SendMessageOrPaginatedAsync(this EduardoContext context, List <Embed> embeds)
{
PaginatedMessage paginatedMsg = PaginatedMessage.Default;
paginatedMsg.Embeds = embeds;
await SendMessageOrPaginatedAsync(context, paginatedMsg);
}
public async Task USTickets()
{
if (!Context.Server.Tickets.tickets.Any())
{
await ReplyAsync("There are no tickets in this server");
return;
}
var pages = new List <PaginatedMessage.Page>();
foreach (var ticket in Context.Server.Tickets.tickets.OrderBy(x => x.id).Where(x => !x.solved))
{
pages.Add(new PaginatedMessage.Page
{
description = $"Ticket By: {Context.Socket.Guild.GetUser(ticket.InitUser)?.Username ?? $"Missing User [{ticket.InitUser}]"}\n" +
$"Message: {ticket.message}\n\n" +
$"^ [{ticket.Up.Count}] v [{ticket.Down.Count}]\n" +
$"ID: {ticket.id}\n" +
$"Comment Count: {ticket.comments.Count}"
});
}
var pager = new PaginatedMessage
{
Title = "Server Tickets",
Pages = pages
};
await PagedReplyAsync(pager);
}
public async Task <Message> SendPaginatedMessageAsync(EspeonContext context, PaginatedMessage pager)
{
var callback = new PaginatedMessageCallback(this, context, pager);
await callback.DisplayAsync().ConfigureAwait(false);
return(callback.Message);
}
public async Task Comment(int id)
{
var targetticket = Context.Server.Tickets.tickets.FirstOrDefault(x => x.id == id);
if (targetticket == null)
{
await ReplyAsync("There is no ticket with that ID.");
return;
}
var pages = new List <PaginatedMessage.Page>
{
new PaginatedMessage.Page
{
Description = $"Ticket By: {Context.Socket.Guild.GetUser(targetticket.InitUser)?.Username ?? $"Missing User [{targetticket.InitUser}]"}\n" +
$"Message: {targetticket.message}\n\n" +
$"^ [{targetticket.Up.Count}] v [{targetticket.Down.Count}]\n" +
$"ID: {targetticket.id}",
}
};
var desc = "";
foreach (var c in targetticket.comments.OrderByDescending(x => x.id))
{
desc += $"User: {Context.Socket.Guild.GetUser(c.UserID)?.Username ?? $"Unknown User `[{c.UserID}]`"}\n" +
$"Comment:\n" +
$"{c.Comment}\n" +
$"ID: {c.id}\n";// +
//$"^ [{c.Up.Count}] v [{c.Down.Count}]\n\n";
if (desc.Length > 800)
{
pages.Add(new PaginatedMessage.Page
{
Description = desc
});
desc = "";
}
}
pages.Add(new PaginatedMessage.Page
{
Description = desc
});
var paginator = new PaginatedMessage
{
Title = $"Ticket #{targetticket.id} Comments",
Pages = pages,
Color = Color.DarkOrange
};
await PagedReplyAsync(paginator, new ReactionList
{
Forward = true,
Backward = true,
Trash = true
});
}
public async Task RoleList()
{
var rol = Context.Guild.Roles;
var rolepage = new List <string>();
var list = "";
foreach (var role in rol.OrderByDescending(x => x.Position))
{
list += $"{role.Name}\n";
if (list.Split('\n').Length >= 20)
{
rolepage.Add(list);
list = "";
}
}
rolepage.Add(list);
var msg = new PaginatedMessage
{
Title = $"Roles for {Context.Guild.Name}",
Pages = rolepage.Select(x => new PaginatedMessage.Page
{
description = x
}),
Color = new Color(114, 137, 218)
};
await PagedReplyAsync(msg);
}
private async Task HandleUpdateMessagePagesAsync(PaginatedMessage msg)
{
var message = await(_client.GetChannel(msg.DiscordChannelId) as SocketTextChannel).GetMessageAsync(msg.DiscordMessageId) as SocketUserMessage;
var oldEmbed = message.Embeds.First();
var newEmbed = new EmbedBuilder()
{
Title = $"{oldEmbed.Title.Split('|').First()}| Page {msg.CurrentPage}",
Color = oldEmbed.Color,
Url = oldEmbed.Url
}
.WithFooter(oldEmbed.Footer.Value.Text, oldEmbed.Footer.Value.IconUrl);
if (msg.DisplayMessages != null)
{
// get correct messages to display
var displayMessages = msg.DisplayMessages.Skip((msg.CurrentPage - 1) * 10).Take(10);
newEmbed.Description = string.Join("\n", displayMessages);
}
else
{
var displayFields = msg.DisplayFields.Skip((msg.CurrentPage - 1) * 10).Take(10).ToArray();
for (int i = 0; i < displayFields.Length; i++)
{
newEmbed.AddField(displayFields[i].Name, displayFields[i].Value, displayFields[i].Inline);
}
}
await message.ModifyAsync(x => x.Embed = newEmbed.Build());
}
public async Task AllRoles(params string[] _)
{
//string rlx = "```" + string.Join('\n', Context.Guild.Roles.OrderByDescending(x => x.Position).Select(x => $"{x.Name} ID: {x.Id}")) + "```";
var paginatedMessage = new PaginatedMessage(PaginatedAppearanceOptions.Default, Context.Channel,
new PaginatedMessage.MessagePage("Loading..."))
{
Title = $"All roles in {Context.Guild.Name}",
Timestamp = DateTimeOffset.Now,
Color = Blurple
};
var embb = new List <EmbedFieldBuilder>();
for (var y = 0; y < Context.Guild.Roles.Count; y++)
{
var x = Context.Guild.Roles.OrderByDescending(x => x.Position).ElementAt(y);
embb.Add(new EmbedFieldBuilder
{
Name = x.Name,
Value =
$"ID: {x.Id}\nPermValue: [{x.Permissions.RawValue}](http://discordapi.com/permissions.html#{x.Permissions.RawValue})\n",
IsInline = y % 2 == 0
});
}
;
paginatedMessage.SetPages("Here's a list of all roles in the Server", embb, 5);
await paginatedMessage.Resend();
}
public static void CreatePaginatedMessage(
ulong userId,
IUserMessage message,
int pageCount,
int initialPage,
PageAction action,
int timeout = 300000,
Action onTimeout = null
)
{
if (pageCount == 1)
{
return;
}
message.AddReactionsAsync(
new[]
{
new Emoji(PaginatedMessage.FirstPage), new Emoji(PaginatedMessage.PreviousPage), new Emoji(PaginatedMessage.NextPage),
new Emoji(PaginatedMessage.LastPage)
}
);
var paginatedMessage = new PaginatedMessage(userId, message, pageCount, initialPage, action);
ReactionMessageCache.Add(
message.Id.ToString(),
paginatedMessage,
new CacheItemPolicy
{
SlidingExpiration = TimeSpan.FromMilliseconds(timeout),
RemovedCallback = onTimeout == null ? null : (CacheEntryRemovedCallback)(_ => onTimeout())
}
);
}
public async Task <IUserMessage> HandleNewPaginatedMessageAsync(SocketCommandContext context, IEnumerable <EmbedField> displayFields, IEnumerable <string> displayTexts, Embed embed)
{
var message = await context.Channel.SendMessageAsync("", false, embed, component : CreateMessageComponents());
var paginatedMessage = new PaginatedMessage()
{
DiscordMessageId = message.Id,
DiscordChannelId = message.Channel.Id,
DiscordUserId = context.User.Id,
};
if (displayFields == null)
{
paginatedMessage.DisplayMessages = displayTexts.ToArray();
}
else
{
paginatedMessage.DisplayFields = displayFields.ToArray();
}
_activeMessages.Add(paginatedMessage);
if (paginatedMessage.TotalPages == 1)
{
return(message);
}
AddNewTimer(message.Id);
return(message);
}
public static RpcApiResult ListExchangePaginated(int offset,
int limit,
out ExchangeList exchanges)
{
exchanges = null;
PaginatedMessage message = new PaginatedMessage();
message.Offset = offset;
message.Limit = limit;
JObject receive = SendCommand(RpcCommand.AssetIssue.ListExchange, new JArray()
{
message.ToByteArray()
});
if (receive.TryGetValue("error", out JToken value))
{
return(new RpcApiResult(false, value["code"].ToObject <int>(), value["message"].ToObject <string>()));
}
exchanges = ExchangeList.Parser.ParseFrom(receive["result"].ToObject <byte[]>());
return(RpcApiResult.Success);
}
public async Task InitPaginationAsync(DiscordMessage message, CacheContentType contentType, string parameter)
{
using (var databaseContext = new DatabaseContext())
{
var paginatedMessage = new PaginatedMessage
{
GuildId = message.Channel.GuildId.ToString(),
MessageId = message.Id.ToString(),
ContentType = contentType,
Parameter = parameter,
CurrentPage = 1
};
await databaseContext.PaginatedMessages.AddAsync(paginatedMessage);
await databaseContext.SaveChangesAsync();
}
await message.CreateReactionAsync(DiscordEmoji.FromName(Bot.Client, FirstEmojiName));
await message.CreateReactionAsync(DiscordEmoji.FromName(Bot.Client, LeftEmojiName));
await message.CreateReactionAsync(DiscordEmoji.FromName(Bot.Client, RightEmojiName));
await message.CreateReactionAsync(DiscordEmoji.FromName(Bot.Client, LastEmojiName));
_logger.Info($"New pagination for {contentType} added");
}
public async Task Ranking()
{
using (var db = Database.Open())
{
var ranking = db.Features.AsQueryable().Include(p => p.User).Where(p => p.GuildId == Context.Guild.Id && p.HasLeft == false).OrderByDescending(p => p.Exp).ToList();
List <string> pages = new List <string>();
int pageSize = 10;
var pageCount = (int)Math.Ceiling((ranking.Count() / (double)pageSize));
for (int i = 1; i <= pageCount; i++)
{
var users = ranking.ToPagedList(i, pageSize);
string pageContent = "";
pageContent += $"**Level Ranking**\n\n\n";
int count = users.PageSize * users.PageNumber - (users.PageSize - 1);
foreach (var user in users)
{
int level = Helper.GetLevel(user.Exp);
pageContent += $"{count}. **{user.User.Name}**\nLevel {level} ({user.Exp.ToFormattedString()} EXP)\n\n";
count++;
}
pages.Add(pageContent);
}
var paginatedMessage = new PaginatedMessage()
{
Pages = pages.ToArray(),
Options = Globals.PaginatorOptions,
Color = new Color(239, 220, 7)
};
await PagedReplyAsync(paginatedMessage);
}
}
public async Task WhoIs([Remainder] string roles)
{
if (roles.Split(", ").Any(role => !Context.Guild.Roles.Any(r => r.Name.ToLower().Contains(role.ToLower()))))
{
await SendErrorAsync("One of the roles you provided is not valid. Make sure the role exists");
return;
}
IEnumerable <SocketGuildUser> users = Context.Guild.Users;
users = roles.Split(", ").Aggregate(users,
(current, role) => current.Where(u => u.Roles.Any(r => r.Name.ToLower().Contains(role.ToLower()))));
var dict = new Dictionary <int, List <SocketGuildUser> >();
for (var i = 0; i < ((double)users.Count() / 25); i++)
{
dict.Add(i, new List <SocketGuildUser>(users.Skip(i * 25).Take(25)));
}
var pages = new List <EmbedBuilder>();
for (var i = 0; i < dict.Count; i++)
{
var desc = (dict.GetValueOrDefault(i) ?? new List <SocketGuildUser>()).Aggregate("",
(current, user) => current + $"{user.Mention}\n");
pages.Add(new EmbedBuilder().WithDescription(desc).WithColor(Color.Teal));
}
var paginator = new PaginatedMessage(pages, $"Users who have the following roles {roles}", Color.Teal,
Context.User);
await Interactivity.SendMessageAsync(Context.Channel, paginator);
}
private void GetBlock(string league)
{
EmbedBuilder embed = new EmbedBuilder();
var path = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
var dbFolder = "Database/";
var dbDir = Path.Combine(path, dbFolder);
using var database = new LiteDatabase($"Filename={dbDir}LGFA.db;connection=shared");
var col = database.GetCollection <TradeBlock.BlockProperties>("TradeBlock");
var listing = "";
var author = new EmbedAuthorBuilder()
.WithName("Trade Block");
var result = col.Query()
.Where(x => x.Team.Contains(league))
.OrderBy(x => x.Name)
.ToList();
var paginatedMessage = new PaginatedMessage
{
Author = author,
Options = _Options
};
var list = new List <string>();
foreach (var tBloc in result)
{
listing += $"**{tBloc.Team}**\n`{tBloc.Id}`\n`{tBloc.Value}`";
list.Add(listing);
listing = null;
}
paginatedMessage.Pages = list;
}
public async Task <IUserMessage> HandleNewPaginatedMessageAsync(SocketCommandContext context, IEnumerable <string> displayTexts, Embed embed)
{
var message = await context.Channel.SendMessageAsync("", false, embed);
var paginatedMessage = new PaginatedMessage()
{
DiscordMessageId = message.Id,
DiscordChannelId = message.Channel.Id,
DiscordUserId = context.User.Id,
DisplayMessages = displayTexts.ToArray()
};
_activeMessages.Add(paginatedMessage);
if (paginatedMessage.TotalPages == 1)
{
return(message);
}
await AddPaginatorReactions(message);
AddNewTimer(message.Id);
return(message);
}
public async Task Paginator()
{
PaginatedMessage pages = new PaginatedMessage {
Pages = new[] { "Page 1", "Page 2", "Page 3", "aaaaaa", "Page 5" }, Content = "gay", Color = Color.Blue, Title = new[] { "Page 1", "Page 2", "Page 3", "aaaaaa", "Page 5" }
};
await PagedReplyAsync(pages);
}
private async Task SendGfys(string title, IEnumerable <Gfy> gfys)
{
var gfyUrls = gfys.Select(d => "https://gfycat.com/" + d.Name).ToList().AsReadOnly();
var message = new PaginatedMessage(gfyUrls, title, Context.User);
await paginator.SendPaginatedMessageAsync(Context.Channel, message);
}
public async Task Help2Async()
{
var Guild = Context.Guild as SocketGuild;
var gldConfig = GuildHandler.GuildConfigs[Guild.Id];
if (Context.Channel is IDMChannel)
{
var builder = new EmbedBuilder
{
Color = new Color(114, 137, 218),
Title = $"Here are my commands:"
};
foreach (var module in _service.Modules)
{
var description =
(from cmd in module.Commands let result = module.Name where result != "Owner" select cmd)
.Aggregate <CommandInfo, string>(null,
(current, cmd) => current + $"{gldConfig.Prefix}{cmd.Name} - {cmd.Summary}\n");
if (!string.IsNullOrWhiteSpace(description))
{
builder.AddField(x =>
{
x.Name = module.Name;
x.Value = description;
});
}
}
await ReplyAsync("", false, builder.Build());
}
else
{
var pages = new List <string>();
foreach (var module in _service.Modules)
{
string description = null;
foreach (var cmd in module.Commands)
{
var result = module.Name;
if (result != "Owner")
{
description += $"{gldConfig.Prefix}{cmd.Name} - {cmd.Summary}\n";
}
}
if (!string.IsNullOrWhiteSpace(description))
{
pages.Add($"**{module.Name}**\n{description}");
}
}
var message = new PaginatedMessage(pages, "Help Commands", new Color(0xb100c1), Context.User);
await _paginator.SendPaginatedMessageAsync(Context.Channel, message);
}
}
public async Task SendPages(IMessageChannel channel, PageFormat pageFormat)
{
var channelObj = await _messageChannelRepository.FindAsync(channel.Id);
if (channelObj == null)
{
channelObj = (channel is IDMChannel dmChannel)
? _messageChannelFactory.CreateNewDM(channel.Id, dmChannel.Recipient.Id)
: null;
channelObj = (channel is IGuildChannel guildChannel)
? _messageChannelFactory.CreateNewServerMessage(channel.Id, guildChannel.GuildId)
: channelObj;
if (channelObj == null)
{
return;
}
await _messageChannelRepository.PostAsync(channelObj);
}
var paginatedMessage = new PaginatedMessage()
{
Pages = BuildPages(pageFormat),
HasHiddenContent = pageFormat.HasHiddenColumns
};
if (paginatedMessage.Pages.Count == 0)
{
return;
}
if (paginatedMessage.HasHiddenContent)
{
var revealedPages = BuildPages(pageFormat.RevealedPageFormat);
revealedPages.ForEach(p => p.IsHidden = true);
paginatedMessage.Pages.AddRange(revealedPages);
}
var message = await channel.SendMessageAsync(paginatedMessage.Pages.First().Content);
paginatedMessage.Id = message.Id;
paginatedMessage.MessageChannelId = channelObj.Id;
if (paginatedMessage.Pages.Count != 1)
{
if (paginatedMessage.StandardPages.Count > 1)
{
await message.AddReactionAsync(new Emoji(ArrowBackward));
await message.AddReactionAsync(new Emoji(ArrowForward));
}
if (pageFormat.HasHiddenColumns)
{
await message.AddReactionAsync(pageFormat.RevealEmote);
}
}
await _paginatedMessageRepository.PostAsync(paginatedMessage);
await _messageChannelRepository.SaveAllChangesAsync();
}
public Task <IUserMessage> PagedReplyAsync(IEnumerable <object> pages, bool fromSourceUser = true)
{
var pager = new PaginatedMessage
{
Pages = pages
};
return(PagedReplyAsync(pager, fromSourceUser));
}
public async Task Help()
{
int pagesize = 15;
List <CommandInfo> commands = _commandService.Commands.Where(p => p.Summary != null && p.Module.Name != "Administration" && !p.Module.IsSubmodule).ToList();
List <string> pages = new List <string>();
for (int i = 1; i <= Math.Ceiling((commands.Count() / (double)pagesize)); i++)
{
string help = $"**Alle Commands:**\n\n`(Parameter) -> Optionaler Parameter`\n`[Parameter] -> Pflicht Parameter`\n\n";
foreach (var command in commands.OrderBy(p => p.Name).Skip((pagesize * (i - 1))).Take(pagesize))
{
string param = "";
string aliases = "";
foreach (var parameter in command.Parameters)
{
if (parameter.IsOptional)
{
param += $"({parameter}) ";
}
else
{
param += $"[{parameter}] ";
}
}
foreach (var alias in command.Aliases)
{
if (alias != command.Name)
{
aliases += $"{Config.Bot.CmdPrefix}{alias} ";
}
}
aliases = aliases.TrimEnd();
if (!string.IsNullOrWhiteSpace(aliases))
{
help += $"**{Config.Bot.CmdPrefix}{command.Name} {param}**\n*Alternativen: {aliases}*\n`{command.Summary}`\n";
}
else
{
help += $"**{Config.Bot.CmdPrefix}{command.Name} {param}**\n`{command.Summary}`\n";
}
}
pages.Add(help);
}
var paginatedMessage = new PaginatedMessage()
{
Pages = pages.ToArray(),
Options = Globals.PaginatorOptions,
Color = new Color(255, 242, 212)
};
await PagedReplyAsync(paginatedMessage);
}
public async Task Bulk([Remainder] string operationString)
{
// Instantiate the bulk operation and get the query results.
Taxa.IBulkOperation bulkOperation = new Taxa.BulkOperation(operationString);
ISearchResult queryResult = await Db.GetSearchResultsAsync(SearchContext, bulkOperation.Query);
if (queryResult.TotalResults() <= 0)
{
await ReplyInfoAsync("No species matching this query could be found.");
}
else
{
// Perform the requested operation.
switch (bulkOperation.OperationName)
{
case "addto": {
// Move the species into the given zone.
if (bulkOperation.Arguments.Count() != 1)
{
throw new Exception(string.Format("This operation requires **{0}** argument(s), but was given **{1}**.", 1, bulkOperation.Arguments.Count()));
}
string zoneName = bulkOperation.Arguments.First();
IZone zone = await Db.GetZoneAsync(zoneName);
if (await BotUtils.ReplyValidateZoneAsync(Context, zone, zoneName))
{
IPaginatedMessage message = new PaginatedMessage(string.Format("**{0}** species will be added to **{1}**. Is this OK?", queryResult.TotalResults(), zone.GetFullName()))
{
Restricted = true
};
message.AddReaction(PaginatedMessageReactionType.Yes, async(args) => {
foreach (ISpecies species in await queryResult.GetResultsAsync())
{
await Db.AddZonesAsync(species, new IZone[] { zone });
}
await ReplySuccessAsync("Operation completed successfully.");
});
await ReplyAsync(message);
}
}
break;
default:
await ReplyErrorAsync($"Unknown operation {bulkOperation.OperationName.ToBold()}.");
break;
}
}
}
public async Task <IUserMessage> SendPaginatedMessageAsync(SocketCommandContext context,
PaginatedMessage pager,
ICriterion <SocketReaction> criterion = null)
{
var callback = new PaginatedMessageCallback(this, context, pager, criterion);
await callback.DisplayAsync().ConfigureAwait(false);
return(callback.Message);
}
private async Task ReceiveInput(int amount, IList <Card> cards)
{
var author = new EmbedAuthorBuilder()
.WithIconUrl(Context.Client.CurrentUser.GetAvatarUrl())
.WithName($"There are {amount} results from your search!");
var paginator = new PaginatedMessage()
{
Author = author,
Color = _random.NextColor(),
Pages = GenDescriptions(cards.Select(card => card.Name)),
Options = PagedOptions
};
var criteria = new BaseCriteria()
.AddCriterion(new IntegerCriteria(amount));
var display = await PagedComponentReplyAsync(paginator);
var cts = new CancellationTokenSource();
var token = cts.Token;
#region CheckMessage
//cancel if pagination is deleted
Task CheckMessage(Cacheable <IMessage, ulong> cache, Cacheable <IMessageChannel, ulong> _)
{
if (cache.Id == display.Id)
{
cts.Cancel();
}
Context.Client.MessageDeleted -= CheckMessage;
return(Task.CompletedTask);
}
#endregion CheckMessage
Context.Client.MessageDeleted += CheckMessage;
var input = await NextMessageAsync(criteria, TimeSpan.FromSeconds(60), token);
if (
token.IsCancellationRequested ||
input is null ||
!int.TryParse(input.Content, out var selection) ||
selection < 0 ||
selection > amount
)
{
return;
}
await SendCardEmbedAsync(cards[selection - 1].GetEmbedBuilder(), GuildConfig.Minimal);
}
public async Task <ITaxon> ReplyNoSuchTaxonExistsAsync(string input, ITaxon suggestion, TaxonRankType rank = TaxonRankType.None)
{
string taxonName = rank == TaxonRankType.None ? "taxon" : rank.GetName();
if (suggestion != null)
{
taxonName = suggestion.GetRank().GetName();
}
StringBuilder sb = new StringBuilder();
if (string.IsNullOrWhiteSpace(input))
{
sb.Append($"No such {taxonName} exists.");
}
else
{
sb.Append($"No {taxonName} named \"{input}\" exists.");
}
if (suggestion != null)
{
string suggestionText = (suggestion is ISpecies species) ? species.GetFullName() : suggestion.GetName().ToTitle();
sb.Append($" Did you mean **{suggestionText}**?");
}
IPaginatedMessage message = new PaginatedMessage(sb.ToString())
{
Restricted = true
};
if (suggestion != null)
{
bool confirmed = false;
message.AddReaction(PaginatedMessageReactionType.Yes, async(args) => {
confirmed = true;
await Task.CompletedTask;
});
await ReplyAndWaitAsync(message);
if (!confirmed)
{
suggestion = null;
}
}
else
{
await ReplyAsync(message);
}
return(suggestion);
}
public async Task BansAsync()
{
var pages = new List <PaginatedMessage.Page>();
foreach (var banGroup in Context.Server.Users.Where(x => x.Banned.Banned).ToList().SplitList(20))
{
var splitList = banGroup.SplitList(5);
var fields = splitList.Select(x => new EmbedFieldBuilder
{
Name = "Bans",
Value = string.Join("\n", x.Select(b => $"User: {b.Username} [{b.UserID}]\n" +
$"Mod: {Context.Guild.GetUser(b.Banned.Moderator)?.Mention ?? $"{b.Banned.Moderator}"}\n" +
$"Expires: {(b.Banned.ExpiryTime - DateTime.UtcNow).TotalMinutes} minutes\n" +
$"Reason: {b.Banned.Reason}"))
}).ToList();
pages.Add(new PaginatedMessage.Page
{
Fields = fields
});
}
foreach (var users in Context.Server.Users.Where(x => x.Banned.ExpiryTime < DateTime.UtcNow && x.Banned.Banned).ToList().SplitList(5))
{
var userStrings = users.Select(b => new EmbedFieldBuilder
{
Name = "Expired Bans",
Value = $"User: {b.Username} [{b.UserID}]\n" +
$"Mod: {Context.Guild.GetUser(b.Banned.Moderator)?.Mention ?? $"{b.Banned.Moderator}"}\n" +
$"Reason: {b.Banned.Reason}"
}).ToList();
pages.Add(new PaginatedMessage.Page
{
Fields = userStrings
});
foreach (var user in users)
{
Context.Server.Users.FirstOrDefault(x => x.UserID == user.UserID).Banned = new GuildModel.User.Ban();
}
}
await Context.Server.Save();
var pager = new PaginatedMessage
{
Pages = pages,
Title = "Bans"
};
await PagedReplyAsync(pager, new ReactionList
{
Forward = true,
Backward = true, Trash = true
});
}
public Task <IUserMessage> NewPagedReplyAsync(PaginatedMessage pager, bool fromSourceUser = true)
{
var criterion = new Criteria <SocketReaction>();
if (fromSourceUser)
{
criterion.AddCriterion(new EnsureReactionFromSourceUserCriterion());
}
return(NewPagedReplyAsync(pager, criterion));
}
public static async Task <IUserMessage> NewSendPaginatedMessageAsync(this InteractiveService IS,
SocketCommandContext context,
PaginatedMessage pager,
ICriterion <SocketReaction> criterion = null)
{
var callback = new CustomPMC(IS, context, pager, criterion);
await callback.DisplayAsync().ConfigureAwait(false);
return(callback.Message);
}
public async Task ServerList()
{
List <SocketGuild> guilds = new List <SocketGuild>(Context.Client.Guilds);
List <PaginatedMessage.Page> pages = new List <PaginatedMessage.Page>();
foreach (SocketGuild g in guilds)
{
List <EmbedFieldBuilder> fields = new List <EmbedFieldBuilder>();
fields.Add(new EmbedFieldBuilder()
{
Name = $"Owner",
Value = $"{g.Owner.Username}#{g.Owner.Discriminator} | ``{g.Owner.Id}``",
IsInline = false
});
fields.Add(new EmbedFieldBuilder()
{
Name = $"Server ID",
Value = g.Id,
IsInline = false
});
fields.Add(new EmbedFieldBuilder()
{
Name = $"Members",
Value = g.MemberCount,
IsInline = false
});
pages.Add(new PaginatedMessage.Page
{
Author = new EmbedAuthorBuilder {
Name = g.Name
},
Fields = new List <EmbedFieldBuilder>(fields),
ThumbnailUrl = (Uri.IsWellFormedUriString(g.IconUrl, UriKind.Absolute) ? g.IconUrl : null)
});
}
var pager = new PaginatedMessage
{
Pages = pages,
Color = Color.DarkGreen,
Content = "Here are a list of servers that I am in!",
FooterOverride = null,
Options = PaginatedAppearanceOptions.Default,
TimeStamp = DateTimeOffset.UtcNow
};
await PagedReplyAsync(pager, new ReactionList
{
Forward = true,
Backward = true,
Jump = true,
Trash = true
}, true);
}