private void Vnc_VoiceDisconnected(DiscordGuild guild)
{
VoiceNextConnection vnc = null;
if (this.ActiveConnections.ContainsKey(guild.Id))
{
this.ActiveConnections.TryRemove(guild.Id, out vnc);
}
var vsd = new VoiceDispatch
{
OpCode = 4,
Payload = new VoiceStateUpdatePayload
{
GuildId = guild.Id,
ChannelId = null
}
};
var vsj = JsonConvert.SerializeObject(vsd, Formatting.None);
(guild.Discord as DiscordClient)._webSocketClient.SendMessage(vsj);
}
private async Task Vnc_VoiceDisconnected(DiscordGuild guild)
{
VoiceNextConnection vnc = null;
if (this.ActiveConnections.ContainsKey(guild.Id))
{
this.ActiveConnections.TryRemove(guild.Id, out vnc);
}
var vsd = new VoiceDispatch
{
OpCode = 4,
Payload = new VoiceStateUpdatePayload
{
GuildId = guild.Id,
ChannelId = null
}
};
var vsj = JsonConvert.SerializeObject(vsd, Formatting.None);
await(guild.Discord as DiscordClient).WsSendAsync(vsj).ConfigureAwait(false);
}
public static IEnumerable <IMention> ParseAllMentions(this string input, bool allowEveryone = false,
DiscordGuild guild = null)
{
var mentions = new List <IMention>();
mentions.AddRange(USER_MENTION.Matches(input)
.Select(x => new UserMention(ulong.Parse(x.Groups[1].Value)) as IMention));
// Only allow role mentions through where the role is actually listed as *mentionable*
// (ie. any user can @ them, regardless of permissions)
// Still let the allowEveryone flag override this though (privileged users can @ *any* role)
// Original fix by Gwen
mentions.AddRange(ROLE_MENTION.Matches(input)
.Select(x => ulong.Parse(x.Groups[1].Value))
.Where(x => allowEveryone || guild != null && guild.GetRole(x).IsMentionable)
.Select(x => new RoleMention(x) as IMention));
if (EVERYONE_HERE_MENTION.IsMatch(input) && allowEveryone)
{
mentions.Add(new EveryoneMention());
}
return(mentions);
}
protected override async Task UpdateInternal(DiscordLink plugin, DLEventType trigger, object data)
{
if (!(data is WorkOrderAction craftingEvent))
{
return;
}
if (craftingEvent.Citizen == null)
{
return; // Happens when a crafting table contiues crafting after finishing an item
}
if (craftingEvent.MarkedUpName != "Create Work Order")
{
return; // Happens when a player feeds materials to a blocked work order
}
string itemName = craftingEvent.OrderCount > 1 ? craftingEvent.CraftedItem.DisplayNamePlural : craftingEvent.CraftedItem.DisplayName;
string message = $"**{craftingEvent.Citizen.Name}** started crafting {craftingEvent.OrderCount} `{itemName}` at {(craftingEvent.WorldObject as WorldObject).Name}.";
foreach (ChannelLink craftingChannel in DLConfig.Data.CraftingChannels)
{
if (!craftingChannel.IsValid())
{
continue;
}
DiscordGuild discordGuild = plugin.GuildByNameOrId(craftingChannel.DiscordGuild);
if (discordGuild == null)
{
continue;
}
DiscordChannel discordChannel = discordGuild.ChannelByNameOrId(craftingChannel.DiscordChannel);
if (discordChannel == null)
{
continue;
}
await DiscordUtil.SendAsync(discordChannel, message);
++_opsCount;
}
}
private async Task OnMessage(DiscordClient client, DiscordGuild guild, DiscordUser author, DiscordChannel channel, DiscordMessage message)
{
if (guild.Id != this._Guild.Id)
{
return;
}
var member = await this._Guild.GetMemberAsync(author.Id);
if (member == null)
{
return;
}
if (channel.Parent != this._ParentChannel)
{
return;
}
// if player is not bot
if (member != client.CurrentUser)
{
var player = await GetOrCreatePlayer(member);
if (player.Room is null)
{
player.Reply("Please join a voice channel");
}
else if (_PlayerNameToDiscordChannel.TryGetValue(player.NormalizedName, out DiscordChannel playerChannel))
{
if (channel is not null && channel == playerChannel)
{
var cmd = new BaseCommand <TGame, TPlayer, TRoom, TContainer, TThing>(player, message.Content);
Game.RaiseCommand(cmd);
}
}
}
}
public async Task Birth(CommandContext context)
{
if (interactivity == null)
{
nickname = Nickname(context.User.ToString());
interactivity = context.Client.GetInteractivity();
museifu = context.Guild;
LoadAlerts(context);
string schedule = await Schedule.GenerateSchedule();
timer = await context.RespondAsync($"Aloha! Let me get the timer running!\n\n" +
$"{schedule}\n" +
$"Please feel free to help us keep track of **field bosses** and **Golden Bells** by letting me know where you spot them!\n\n" +
$"You are also welcome to share this timer with any friendly spirits who cross your path.\n\n" +
$"https://discord.gg/ndVAvQ3");
lastComment = await context.RespondAsync($"Health, wealth, and stealth, dachi! :wink: I hope you're having a lovely grind!");
}
if (context != null)
{
await context.Message.DeleteAsync();
}
try
{
await Existence();
}
catch (Exception error)
{
await CommandRespond(context, $"An strange error occurred! {error}");
await Rebirth();
}
}
public List <TransactionItem> GetTopTransactions(DiscordGuild guild)
{
var data = MultiBotDb.Transactions
.Join(
MultiBotDb.Mcmember,
trans => trans.UserId,
mem => mem.UserId,
(trans, mem) => new
{
memberName = mem.Username,
orgId = mem.OrgId.GetValueOrDefault(),
amount = trans.Amount,
merits = trans.Merits
}
).Where(x => x.orgId == new OrgController().GetOrgId(guild) && x.amount != 0).OrderByDescending(x => x.amount).ToList();
var transactions = new List <TransactionItem>();
var length = data.Count;
if (length < 3)
{
for (int i = 0; i < length; i++)
{
transactions.Add(new TransactionItem(data[i].memberName, data[i].orgId, data[i].amount.GetValueOrDefault(), data[i].merits.GetValueOrDefault()));
}
}
else
{
for (int i = 0; i <= 2; i++)
{
transactions.Add(new TransactionItem(data[i].memberName, data[i].orgId, data[i].amount.GetValueOrDefault(), data[i].merits.GetValueOrDefault()));
}
}
return(transactions);
}
public async Task <bool> RemoveModuleLimitAsync(DiscordGuild guild, IMessageChannel channel, string module)
{
using (var db = new ModixContext())
{
var limit = await db.ChannelLimits
.Where(c =>
c.ModuleName.ToUpper() == module.ToUpper() &&
c.Guild.Id == guild.Id &&
c.ChannelId == channel.Id.ToLong())
.FirstOrDefaultAsync();
if (limit != null)
{
db.ChannelLimits.Remove(limit);
await db.SaveChangesAsync();
return(true);
}
}
return(false);
}
public static async Task LogFleetCreationAsync(DiscordGuild guild, DiscordMember member, DiscordChannel fleetCategory)
{
var embed = new DiscordEmbedBuilder
{
Title = $"{fleetCategory.Name} создан",
Description = $"`{fleetCategory.Id}`",
Color = DiscordColor.SpringGreen
};
var channels = "";
foreach (var channel in fleetCategory.Children.OrderBy(x => x.Position))
{
channels += $"**{channel.Name}** \t\t `{channel.Id}` \n";
}
embed.AddField("Каналы", channels);
embed.WithAuthor($"{member.Username}#{member.Discriminator}", iconUrl: member.AvatarUrl);
embed.WithTimestamp(DateTime.Now);
await guild.GetChannel(Bot.BotSettings.FleetLogChannel).SendMessageAsync(embed: embed.Build());
}
public async Task SetColor(DiscordMember user, DiscordGuild server, DiscordChannel channel, DiscordColor color)
{
IReadOnlyDictionary <ulong, DiscordRole> roles = server.Roles;
DiscordRole existingRole = null;
string UserId = user.Id.ToString();
if (roles.Any(xr => xr.Value.Name == UserId))
{
existingRole = roles.First(xr => xr.Value.Name == UserId).Value;
await existingRole.ModifyAsync(color : color, reason : "Coloring role edit");
}
else
{
DiscordRole CreatedRole = await server.CreateRoleAsync(user.Id.ToString(), Permissions.None, color, null, null, "Coloring role creation");
await user.GrantRoleAsync(CreatedRole, "Coloring role assignment");
}
await channel.SendMessageAsync("Color set successfully.");
Console.WriteLine("User {0}'s color was set to {1}", user.Username, color.R + ", " + color.G + ", " + color.B);
return;
}
private async Task Discord_ChannelDeleted(ChannelDeleteEventArgs e)
{
var logs = (await e.Guild.GetAuditLogsAsync(5, null, AuditLogActionType.ChannelDelete).ConfigureAwait(false)).Cast <DiscordAuditLogChannelEntry>();
foreach (var entry in logs)
{
Debug.Log("TargetId: " + entry.Target.Id, Discord);
}
//Check through the guild entries and make sure that theres no deleted recorded adresses
foreach (guildData dataEntries in data)
{
ulong guildID = dataEntries.guildId;
DiscordGuild guild = await Discord.GetGuildAsync(guildID);
DiscordChannel channel = await Discord.GetChannelAsync(dataEntries.disabledChannelID);
if (channel == null || dataEntries.disabledChannelID == 0)
{
dataEntries.disabledChannelID = 0;
}
}
}
public async Task SayAsync(CommandContext ctx,
[Description("Id of the guild where to post")] ulong guildId,
[Description("Id of the text channel where to post")] ulong channelId,
[RemainingText, Description("Message to post")] string message)
{
DiscordGuild guild = await ctx.Client.GetGuildAsync(guildId);
if (guild == null)
{
await ctx.ErrorAsync("Guild not found");
return;
}
DiscordChannel channel = guild.GetChannel(channelId);
if (channel == null)
{
await ctx.ErrorAsync("Channel not found");
return;
}
await channel.SendMessageAsync(message);
}
public static async Task CheckBacklogAsync(DiscordClient client, DiscordGuild guild)
{
try
{
var after = DateTime.UtcNow - Config.ModerationTimeThreshold;
foreach (var channel in guild.Channels.Where(ch => !ch.IsCategory))
{
var messages = await channel.GetMessagesAsync(500).ConfigureAwait(false);
var messagesToCheck = from msg in messages
where msg.CreationTimestamp > after
select msg;
foreach (var message in messagesToCheck)
{
await CheckMessageForInvitesAsync(client, message).ConfigureAwait(false);
}
}
}
catch (Exception e)
{
Config.Log.Error(e);
}
}
//TODO need a better way to store/specify permissions, and preferably one where no permissions is left out (because of my OCD)
List <DiscordOverwriteBuilder> GeneratePermissionOverwrites(DiscordGuild guild, DiscordMember creator, ChannelPublicity publicity, params DiscordMember[] permittedMembers)
{
//TODO implement the ranking method that allows moderators to specify what roles have access to naming capabilities, publicity options, and bitrate options
List <DiscordOverwriteBuilder> channelPermissionsBuilderList = new List <DiscordOverwriteBuilder>
{
new DiscordOverwriteBuilder().For(guild.EveryoneRole).Deny(Permissions.AccessChannels | Permissions.UseVoice), //Prevent everyone from viewing any channel
new DiscordOverwriteBuilder().For(registeredGuildData[guild].MemberRole).Allow(publicity == ChannelPublicity.Hidden ? Permissions.None : Permissions.AccessChannels).Deny(publicity == ChannelPublicity.Private ? Permissions.UseVoice : Permissions.None).Deny(publicity == ChannelPublicity.Hidden ? Permissions.AccessChannels : Permissions.None), //Allow members to see private channels
new DiscordOverwriteBuilder().For(registeredGuildData[guild].MutedRole).Allow(publicity == ChannelPublicity.Hidden ? Permissions.None : Permissions.AccessChannels).Deny(Permissions.UseVoice | Permissions.Speak | Permissions.UseVoiceDetection | Permissions.Stream) //Dissallow muted members from accessing or viewing
};
//TODO this might be redundant...need to test if the muted role overwrite will disallow the muted role from joining even if this allows them...though i think i know the behavior that the role system will produce
//TODO may need to accomodate other blacklist roles
foreach (var member in permittedMembers)
{
if (member.Roles.Contains(registeredGuildData[guild].MutedRole))
{
continue; //TODO we want to inform the creator this member was not whitelisted in the vc because they have the muted role
}
channelPermissionsBuilderList.Add(new DiscordOverwriteBuilder().For(member).Allow(Permissions.AccessChannels | Permissions.UseVoice | Permissions.Speak | Permissions.UseVoiceDetection | Permissions.Stream));
}
return(channelPermissionsBuilderList);
}
private async Task RequestLogin(DiscordMessage message)
{
if (!message.Channel.IsPrivate)
{
await message.RespondAsync(embed : PresetEmbeds.ErrorEmbed("This command must be run in a DM.", message).Build());
}
else
{
DiscordGuild streamGuild = messageEvent.Guild.GetChannel(StreamChannel).Guild;
if (await streamGuild.GetMemberAsync(message.Author.Id) == null)
{
await message.RespondAsync(embed : PresetEmbeds.ErrorEmbed($"We can't find you in our guild. are you part of {streamGuild.Name}?", message).Build());
return;
}
string signedId = Hmac.SignMessage(message.Author.Id.ToString(), TokenKey);
string encryptedId = StringCipher.Encrypt(signedId, TokenPassword);
await message.RespondAsync(embed : PresetEmbeds.SuccessEmbed($"[Click here to login.]({ApiUrl}BotLogin?token={encryptedId})\n\n" +
$"This link expires in 30 seconds.", message).Build());
}
}
public async Task OutputBeeMovie(CommandContext context)
{
StringBuilder contentBuilder = new();
DiscordGuild movieGuild = await context.Client.GetGuildAsync(this.options.Value.MovieEmojiGuildId);
Dictionary <string, DiscordEmoji> movieEmojis = movieGuild.Emojis.Values.ToList().ToDictionary(emoji => emoji.Name);
for (int row = 0; row < 5; row++)
{
for (int column = 0; column < 8; column++)
{
contentBuilder.Append(movieEmojis[$"beemovie{column}x{row}"].ToString());
}
contentBuilder.AppendLine();
}
using FileStream fs = new(this.options.Value.MovieFilePath, FileMode.Open);
DiscordMessageBuilder messageBuilder = new DiscordMessageBuilder().WithContent(contentBuilder.ToString());
messageBuilder.WithFile("movie", fs);
await context.RespondAsync(messageBuilder);
}
private async Task Client_Ready(ReadyEventArgs e)
{
if (!MainThreadQueue.Instance.IsMain())
{
MainThreadQueue.Instance.Queue(async() => await Client_Ready(e));
return;
}
Debug.Log($"{Log.Timestamp()} Discord-ClientReady: Client is connected.");
PushNotification.Instance.Push($"Connected as: {e.Client.CurrentUser.Username}", "Success");
if (Client.Guilds.Count > 0)
{
Debug.Log($"Guild already exists. {Client.Guilds.First()}");
return;
}
Guild = await Client.CreateGuildAsync(_guildName);
var invite = await Guild.Channels.First().CreateInviteAsync();
PushNotification.Instance.Push($"Invite: {invite}", "Success");
OnInviteCreated?.Invoke(invite.ToString());
}
public CrabgileMeeting(DiscordMember hostMember)
{
this.hostMember = hostMember;
guild = hostMember.Guild;
channels = new ConcurrentBag <DiscordChannel>();
if (!GuildMeetings.ContainsKey(guild.Id))
{
GuildMeetings.TryAdd(guild.Id, new ConcurrentDictionary <ulong, CrabgileMeeting>());
}
registrySuccess = GuildMeetings[guild.Id].TryAdd(hostMember.Id, this);
if (registrySuccess)
{
Task.Run(async() => {
meetingCategory = await guild.CreateChannelCategoryAsync($"::{hostMember.Id}::");
AddChannelToMeeting(meetingCategory);
meetingTextChannel = await guild.CreateChannelAsync("meeting-chat", DSharpPlus.ChannelType.Text, meetingCategory, "A minuted text channel for the timebox meeting.");
//AddChannelToMeeting(meetingTextChannel);
//Don't add the channel to the bag, as it shouldn't get destroyed.
});
}
}
/// <summary>
/// Using the cache, this will attempt to verify that the current bot can
/// join the selected voice channel. If the cache does not have the required details,
/// this will NOT throw an exception (the handshake timeout will handle invalid permission anyway).
/// </summary>
/// <exception cref="DiscordPermissionException"></exception>
/// <exception cref="InvalidOperationException"></exception>
void AssertUserCanJoin(Snowflake guildId, Snowflake voiceChannelId)
{
DiscordGuildMember member = cache.GetGuildMember(guildId, Shard.UserId.Value);
DiscordGuild guild = cache.GetGuild(guildId);
DiscordGuildVoiceChannel voiceChannel = cache.GetGuildVoiceChannel(voiceChannelId);
if (member != null && guild != null && voiceChannel != null)
{
// Check if the user has permission to connect.
DiscordPermissionHelper.AssertPermission(DiscordPermission.Connect, member, guild, voiceChannel);
// Check if the voice channel has room
bool channelHasRoom = false;
if (voiceChannel.UserLimit == 0)
{
channelHasRoom = true;
}
else if (DiscordPermissionHelper.HasPermission(DiscordPermission.Administrator, member, guild, voiceChannel))
{
channelHasRoom = true;
}
else
{
IReadOnlyList <Snowflake> usersInChannel = Shard.Voice.GetUsersInVoiceChannel(voiceChannelId);
if (usersInChannel.Count < voiceChannel.UserLimit)
{
channelHasRoom = true;
}
}
if (!channelHasRoom)
{
throw new InvalidOperationException("The voice channel is full, and the current bot " +
"does not have the administrator permission.");
}
}
}
private async Task <bool> CheckIfHasPermissionAsync(DiscordUser discordUser, DiscordGuild discordGuild,
Guild dbGuild)
{
var hasPermission = false;
var invoker = await _botService.GetMemberAsync(dbGuild.GuildId, discordUser.Id);
if (invoker.IsOwner)
{
hasPermission = true;
}
if (!hasPermission)
{
var managerIds = dbGuild.Managers.Select(m => m.UserId).ToList();
if (managerIds.Contains(invoker.Id.ToString()))
{
hasPermission = true;
}
}
if (!hasPermission)
{
var moderatorRoleIds = dbGuild.AutoModPlugin.ModeratorRoles
.Select(r => r.RoleId)
.ToList();
foreach (var roleId in invoker.Roles.Select(r => r.Id).ToList())
{
if (moderatorRoleIds.Contains(roleId.ToString()))
{
hasPermission = true;
break;
}
}
}
return(hasPermission);
}
private async Task SkipSong(DiscordGuild guild, DiscordChannel channel,
LavalinkGuildConnection lvc, bool fromVoteSkip = false)
{
string title = ShimakazeBot.playlists[guild].songRequests[0].track.Title;
ShimakazeBot.playlists[guild].songRequests.RemoveAt(0);
bool wasLooping = false;
if (ShimakazeBot.playlists[guild].loopCount > 0)
{
wasLooping = true;
ShimakazeBot.playlists[guild].loopCount = 0;
}
if (ShimakazeBot.playlists[guild].songRequests.Count > 0)
{
await lvc.PlayAsync(ShimakazeBot.playlists[guild].songRequests.First().track);
await CTX.SendSanitizedMessageAsync(channel,
$"Skipped *{title}*{(wasLooping ? " and stopped loop" : "")}." +
(fromVoteSkip ?
$"\nSkip requested by **{ShimakazeBot.playlists[guild].voteSkip.requester.DisplayName}**" :
""));
}
else
{
await lvc.StopAsync();
await CTX.SendSanitizedMessageAsync(channel, $"Playlist ended with skip. (Skipped *{title}*" +
$"{(wasLooping ? " and stopped loop" : "")})" +
(fromVoteSkip ?
$"\nSkip requested by **{ShimakazeBot.playlists[guild].voteSkip.requester.DisplayName}**" :
""));
}
ShimakazeBot.playlists[guild].voteSkip = null;
}
private static async Task UpdateDisplayName(DiscordGuild guild, DiscordMember guildMember)
{
try
{
if (guildMember.IsWhitelisted())
{
return;
}
if (guild.Permissions?.HasFlag(Permissions.ChangeNickname) is false)
{
return;
}
await using var db = new BotDb();
var forcedNickname = await db.ForcedNicknames.AsNoTracking().FirstOrDefaultAsync(x => x.UserId == guildMember.Id && x.GuildId == guildMember.Guild.Id).ConfigureAwait(false);
if (forcedNickname is null)
{
return;
}
if (guildMember.DisplayName == forcedNickname.Nickname)
{
return;
}
Config.Log.Debug($"Expected nickname {forcedNickname.Nickname}, but was {guildMember.Nickname}. Renaming...");
await guildMember.ModifyAsync(mem => mem.Nickname = forcedNickname.Nickname).ConfigureAwait(false);
Config.Log.Info($"Enforced nickname {forcedNickname.Nickname} for user {guildMember.Id} ({guildMember.Username}#{guildMember.Discriminator})");
}
catch (Exception e)
{
Config.Log.Error(e);
}
}
public static async Task <bool> CheckBansAsync()
{
DiscordChannel logChannel = await Program.discord.GetChannelAsync(Program.cfgjson.LogChannel);
Dictionary <string, MemberPunishment> banList = Program.db.HashGetAll("bans").ToDictionary(
x => x.Name.ToString(),
x => JsonConvert.DeserializeObject <MemberPunishment>(x.Value)
);
if (banList == null | banList.Keys.Count == 0)
{
return(false);
}
else
{
// The success value will be changed later if any of the unmutes are successful.
bool success = false;
foreach (KeyValuePair <string, MemberPunishment> entry in banList)
{
MemberPunishment banEntry = entry.Value;
DiscordGuild targetGuild = await Program.discord.GetGuildAsync(banEntry.ServerId);
if (DateTime.Now > banEntry.ExpireTime)
{
targetGuild = await Program.discord.GetGuildAsync(banEntry.ServerId);
await UnbanFromServerAsync(targetGuild, banEntry.MemberId);
success = true;
}
}
#if DEBUG
Console.WriteLine($"Checked bans at {DateTime.Now} with result: {success}");
#endif
return(success);
}
}
private async Task RunPooperAsync(DiscordGuild gld, DiscordMember mbr)
{
var gid = (long)gld.Id;
if (!await this.CheckWhitelistAsync(gid))
{
return;
}
var cmbr = gld.CurrentMember;
if (cmbr == null)
{
this.Discord.Logger.LogError(LogEvent, "Current member in '{0}' ({1}) is null - could not process pooping!", gld.Name, gld.Id);
return;
}
if (!this.CanPoop(mbr, cmbr))
{
return;
}
await DoPoopAsync(mbr);
}
private DiscordRole ResolveRole(DiscordGuild guild, string input)
{
if (input == null)
{
return(null);
}
var roles = GetTimeSortedRoles(guild);
if (ulong.TryParse(input, out ulong num))
{
if (num <= (ulong)roles.Count && num != 0)
{
return(roles[(int)(num - 1)]);
}
var tmp = roles.Find(r => r.Id == num);
if (tmp != null)
{
return(tmp);
}
}
int min = int.MaxValue;
DiscordRole result = null;
foreach (var role in roles)
{
int tmp = Utils.Levenshtein(role.Name, input);
if (tmp < min)
{
min = tmp;
result = role;
}
}
return(result);
}
public async Task MusicAsync(CommandContext ctx,
[Description("Guild for which to toggle the setting.")] DiscordGuild guild,
[Description("Whether the music module should be available.")] bool whitelist,
[RemainingText, Description("Reason why the guild has music enabled.")] string reason = null)
{
/*var gid = (long)guild.Id;
* var enable = this.Database.MusicWhitelist.SingleOrDefault(x => x.GuildId == gid);
* if (whitelist && enable == null)
* {
* enable = new DatabaseMusicWhitelistedGuild
* {
* GuildId = gid,
* Reason = reason
* };
* this.Database.MusicWhitelist.Add(enable);
* }
* else if (!whitelist && enable != null)
* {
* this.Database.MusicWhitelist.Remove(enable);
* }
*
* await this.Database.SaveChangesAsync().ConfigureAwait(false);
* await ctx.RespondAsync($"{DiscordEmoji.FromName(ctx.Client, ":msokhand:")} {Formatter.Bold(Formatter.Sanitize(guild.Name))} is {(whitelist ? "now whitelisted for music playback" : "not whitelisted for music playback anymore")}.").ConfigureAwait(false);*/
}
/// <summary>
/// Strictly gets a user from their user ID. Unlike <see cref="GetMemberFromDataAsync(DiscordGuild, string)"/>, this code will return null if a name or discriminator is passed in.
/// </summary>
/// <param name="data">The query to get a XanBotMember from. This can either be a ulong as a string or a user ping (<@ulong>)</param>
/// <returns></returns>
public static async Task <XanBotMember> GetMemberFromDataIDStrictAsync(DiscordGuild server, string data)
{
string newdata = data;
if (data.StartsWith("<@") && data.EndsWith(">"))
{
newdata = data.Substring(2, data.Length - 3);
}
if (ulong.TryParse(newdata, out ulong uuid))
{
DiscordUser user = await XanBotCoreSystem.Client.GetUserAsync(uuid);
// Catch case: Someone's username is a bunch of numbers OR they link a user ID that isn't in the server.
if (user != null)
{
XanBotMember member = XanBotMember.GetMemberFromUser(server, user);
if (member != null)
{
return(member);
}
}
}
return(null);
}
public DiscordChannel GetChannelByName(string channelName, DiscordGuild server)
{
_log.Debug("Getting channel by name {channelName} on server {serverName}.", channelName, server.Name);
DiscordChannel res;
try
{
res = server.Channels.Values.FirstOrDefault(c => c.Name == channelName);
}
catch (InvalidOperationException e)
{
throw new AmbiguousIdentifierException($"Could not uniquely identify channel with name {channelName} in server {server.Name}.", e);
}
if (res != null)
{
return(res);
}
else
{
throw new UnmatchedIdentifierException($"Could not find any channel with name {channelName} in server {server.Name}.");
}
}
public async Task ServerInfo(CommandContext ctx)
{
DiscordGuild guild = ctx.Guild;
SilkDbContext db = _dbFactory.CreateDbContext();
var staffMembers = db.Guilds.Include(g => g.Users)
.First(g => g.Id == guild.Id)
.Users
.Where(u => u.Flags.HasFlag(UserFlag.Staff));
int staffCount = staffMembers.Count();
DiscordEmbedBuilder embed = new DiscordEmbedBuilder()
.WithTitle($"Guild info for {guild.Name}:")
.WithColor(DiscordColor.Gold)
.WithFooter($"Silk! | Requested by: {ctx.User.Id}", ctx.Client.CurrentUser.AvatarUrl);
embed.WithThumbnail(guild.IconUrl);
if (guild.PremiumSubscriptionCount.Value > 0)
{
embed.AddField("Boosts:", $"{guild.PremiumSubscriptionCount.Value} boosts (level {guild.PremiumTier})");
}
if (guild.Features.Count > 0)
{
embed.AddField("Enabled guild features: ", string.Join(", ", guild.Features));
}
embed.AddField("Verification Level:", guild.VerificationLevel.ToString().ToUpper());
embed.AddField("Member Count:", guild.MemberCount.ToString());
embed.AddField("Owner:", guild.Owner.Mention);
embed.AddField("Approximate staff member count:", staffCount.ToString());
await ctx.RespondAsync(embed : embed);
}
public static async Task LogAutoActionAsync(this DiscordClient clnt, DiscordGuild gld, DatabaseContext db,
string additionalinfo = "")
{
var cfg = db.GuildConfig.SingleOrDefault(xc => (ulong)xc.GuildId == gld.Id);
var s = cfg.GetSettings();
if (s.ActionLog.Enable)
{
var w = await clnt.GetWebhookWithTokenAsync(s.ActionLog.WebhookId, s.ActionLog.WebhookToken);
var b = new DiscordEmbedBuilder();
b.WithTitle($"New Automated action executed")
.WithDescription($"Executed action: {additionalinfo}")
.WithFooter($"Guild: {gld.Name}", string.IsNullOrEmpty(gld.IconHash) ? "" : gld.IconUrl);
var e = new List <DiscordEmbed>
{
b.Build()
};
await w.ExecuteAsync(null, null, null, false, e, null);
}
}
