public override string GetDocumentation()
{
var permissions = new HashSet <string>();
if (GuildPermission != null)
{
permissions.UnionWith(GuildPermission.Select(g => g.ToString().SplitCamelCase()));
}
if (ChannelPermission != null)
{
permissions.UnionWith(ChannelPermission.Select(g => g.ToString().SplitCamelCase()));
}
if (permissions.Count <= 0)
{
return(string.Empty);
}
var output = permissions.Select(s => s.Code());
if (permissions.Count == 1)
{
return($"Requires {output.First()} permission.");
}
else
{
return($"Requires {output.Join(", ")} permissions.");
}
}
/// <inheritdoc />
public async Task <GuildPermission> GetPermissionsAsync(IDiscordGuildUser user)
{
if (user.Id == OwnerId)
{
return(GuildPermission.All);
}
GuildPermission permissions = Permissions;
if (permissions.HasFlag(GuildPermission.Administrator))
{
return(GuildPermission.All);
}
IDiscordRole everyoneRole = await GetRoleAsync(Id);
permissions = everyoneRole.Permissions;
if (user.RoleIds != null)
{
var roles = await GetRolesAsync();
foreach (IDiscordRole role in roles.Where(x => user.RoleIds.Contains(x.Id)))
{
permissions |= role.Permissions;
}
}
if (permissions.HasFlag(GuildPermission.Administrator))
{
return(GuildPermission.All);
}
return(permissions);
}
public void AssertPermission(GuildPermission permission)
{
if (!HasPermission(permission))
{
throw new MissingPermissionException($"Bot does not have {nameof (permission)} '{permission}'.");
}
}
public Context CheckAuthorPermission(GuildPermission permission, string permissionName)
{
if (!GetGuildPermissions(Author).Has(permission))
{
throw new PKError($"You must have the \"{permissionName}\" permission in this server to use this command.");
}
return(this);
}
public async Task <bool> HasPermissionsAsync(GuildPermission permissions)
{
var guild = await GetGuildAsync();
GuildPermission p = await guild.GetPermissionsAsync(this);
return(p.HasFlag(permissions));
}
public async Task RemoveTag(string tag, SocketCommandContext Context)
{
try
{
List <TagStruct> tagStruct = new List <TagStruct>();
if (tagDict.ContainsKey(Context.Guild.Id))
{
tagDict.TryGetValue(Context.Guild.Id, out tagStruct);
foreach (var t in tagStruct)
{
if (t.tag.Equals(tag.Trim().ToLower()))
{
GuildPermission permiss = GuildPermission.Connect;
if (tagRestrictDict.ContainsKey(Context.Guild.Id))
{
tagRestrictDict.TryGetValue(Context.Guild.Id, out permiss);
}
if (Context.User.Id == t.creatorID ||
((permiss == GuildPermission.Connect)
? ((SocketGuildUser)Context.User).GuildPermissions.Has(
GuildPermission.ManageChannels)
: ((SocketGuildUser)Context.User).GuildPermissions.Has(permiss)))
{
tagStruct.Remove(t);
if (tagDict.TryUpdate(Context.Guild.Id, tagStruct))
{
SaveDatabase();
await Context.Channel.SendMessageAsync(
$":white_check_mark: Successfully removed the Tag `{t.tag}`");
}
else
{
await Context.Channel.SendMessageAsync("Something went wrong :(");
}
}
else
{
await Context.Channel.SendMessageAsync(
":no_entry_sign: You are neither the Creator of the tag nor have the permissions to delete it!");
}
return;
}
}
await Context.Channel.SendMessageAsync($":no_entry_sign: Tag `{tag}` was not found!");
}
else
{
await Context.Channel.SendMessageAsync(":no_entry_sign: There are no tags in this guild!");
}
}
catch (Exception e)
{
Console.WriteLine(e);
await SentryService.SendError(e, Context);
}
}
public Task <InteractiveButtonData> NextButtonAsync(SocketCommandContext context, IUserMessage currentMessage,
GuildPermission perm,
TimeSpan?timeout = null,
CancellationToken token = default(CancellationToken))
{
var criterion = new Criteria <SocketMessage>();
criterion.AddCriterion(new EnsureGuildPermissionCriterion(perm));
return(NextButtonAsync(context, currentMessage, criterion, timeout, token));
}
/// <summary>
/// Casts the <see cref="GuildPermissions"/> struct to the <see cref="GuildPermission"/> enum.
/// </summary>
/// <param name="perms">The <see cref="GuildPermissions"/> struct.</param>
/// <returns>The <see cref="GuildPermission"/> enum</returns>
public static GuildPermission ToEnum(this GuildPermissions perms)
{
GuildPermission outPerms = 0;
foreach (GuildPermission perm in perms.ToList())
{
outPerms |= perm;
}
return(outPerms);
}
public async Task <RuntimeResult> ModeratorPermsSetAsync([Remainder] GuildPermission guildPermission)
{
var record = await CoreRepository.GetOrCreateGuildSettingsAsync(Context.Guild).ConfigureAwait(false);
record.ModeratorPermission = guildPermission;
await CoreRepository.SaveRepositoryAsync().ConfigureAwait(false);
return(CommandRuntimeResult.FromSuccess(
$"Successfully changed the required moderator permission to {Format.Bold(guildPermission.Humanize(LetterCasing.Title))}."));
}
/// <summary>
/// Returns true if the bot has the permission in the server and the channel.
/// </summary>
/// <param name="channel">The channel.</param>
/// <param name="permission">The permission.</param>
public static bool HasPermission(IChannel channel, GuildPermission permission, bool inChannel = true)
{
var guild = (channel as SocketGuildChannel).Guild;
var me = guild.GetUser(Client.CurrentUser.Id);
var channelPermissions = me.GetPermissions(channel as IGuildChannel);
var guildPermissions = me.GuildPermissions;
bool a = inChannel ? channelPermissions.Has((ChannelPermission)permission) : true;
bool b = guildPermissions.Has(permission);
return(a && b);
}
public bool HasPermission([NotNull] SocketCommandContext context, GuildPermission guildPermission)
{
var amby = context.Guild.GetUser(context.Client.CurrentUser.Id) as IGuildUser;
if (amby is null)
{
return(false);
}
return(amby.GuildPermissions.Has(guildPermission));
}
public async Task <bool> HasPermissionAsync(IGuild guild, GuildPermission guildPermission)
{
var amby = await guild.GetUserAsync(_client.CurrentUser.Id);
if (amby is null)
{
return(false);
}
return(amby.GuildPermissions.Has(guildPermission));
}
/// <summary>
/// Set permission by enum
/// </summary>
/// <param name="perm">permission</param>
/// <param name="value">status</param>
private void SetPerm(GuildPermission perm, bool value)
{
if (value)
{
AddAllows(perm);
}
else
{
AddDenies(perm);
}
}
public static bool HasPermission(SocketGuildUser user, GuildPermission permission)
{
var userPerms = user.GuildPermissions.ToList();
if (userPerms.Contains(permission))
{
return(true);
}
return(false);
}
/// <summary>
/// Check if a certain permission is missing, and call <see cref="DisablePlugin(string)"/> if so. Call <see cref="NotifyGuild(string)"/> if <paramref name="permission"/> is true.
/// </summary>
/// <param name="permission">Permission to check</param>
/// <param name="notifyGuild">Notify guild of disable</param>
protected void DisablePluginIfPermissionMissing(GuildPermission permission, bool notifyGuild)
{
if (!HasPermission(permission))
{
if (notifyGuild)
{
NotifyGuild($"Plugin '{Plugin.GetName(GetType())}' requires permission '{permission}' to function, which has been revoked. The plugin has automatically been disabled.");
}
DisablePlugin($"Disabled plugin due to revoked permission '{permission}'.");
}
}
public static GuildPermission GetOverwritePermissions(
IDiscordGuildUser user, IDiscordGuildChannel channel, GuildPermission basePermissions)
{
var permissions = basePermissions;
if (permissions.HasFlag(GuildPermission.Administrator))
{
return(GuildPermission.All);
}
if (channel.PermissionOverwrites != null)
{
PermissionOverwrite overwriteEveryone = channel.PermissionOverwrites
.FirstOrDefault(x => x.Id == channel.GuildId);
if (overwriteEveryone != null)
{
permissions &= ~overwriteEveryone.DeniedPermissions;
permissions |= overwriteEveryone.AllowedPermissions;
}
PermissionOverwrite overwrites = new PermissionOverwrite();
if (user.RoleIds != null)
{
foreach (ulong roleId in user.RoleIds)
{
PermissionOverwrite roleOverwrites = channel.PermissionOverwrites
.FirstOrDefault(x => x.Id == roleId);
if (roleOverwrites != null)
{
overwrites.AllowedPermissions |= roleOverwrites.AllowedPermissions;
overwrites.DeniedPermissions &= roleOverwrites.DeniedPermissions;
}
}
}
permissions &= ~overwrites.DeniedPermissions;
permissions |= overwrites.AllowedPermissions;
PermissionOverwrite userOverwrite = channel.PermissionOverwrites
.FirstOrDefault(x => x.Id == user.Id);
if (userOverwrite != null)
{
permissions &= ~userOverwrite.DeniedPermissions;
permissions |= userOverwrite.AllowedPermissions;
}
}
return(permissions);
}
public async Task <GuildPermission> GetPermissionsAsync(IDiscordGuildUser user = null)
{
IDiscordGuild guild = await GetGuildAsync();
if (user == null)
{
user = await guild.GetSelfAsync();
}
GuildPermission permissions = await guild.GetPermissionsAsync(user);
return(DiscordChannelHelper.GetOverwritePermissions(user, this, permissions));
}
public async ValueTask <GuildPermission> GetPermissionsAsync(IDiscordGuildUser user)
{
IDiscordGuild guild = await GetGuildAsync();
GuildPermission permissions = await guild.GetPermissionsAsync(user);
if (permissions.HasFlag(GuildPermission.Administrator))
{
return(GuildPermission.All);
}
if (_packet.PermissionOverwrites != null)
{
PermissionOverwrite overwriteEveryone = _packet.PermissionOverwrites
.FirstOrDefault(x => x.Id == GuildId) ?? null;
if (overwriteEveryone != null)
{
permissions &= ~overwriteEveryone.DeniedPermissions;
permissions |= overwriteEveryone.AllowedPermissions;
}
PermissionOverwrite overwrites = new PermissionOverwrite();
if (user.RoleIds != null)
{
foreach (ulong roleId in user.RoleIds)
{
PermissionOverwrite roleOverwrites = _packet.PermissionOverwrites.FirstOrDefault(x => x.Id == roleId);
if (roleOverwrites != null)
{
overwrites.AllowedPermissions |= roleOverwrites.AllowedPermissions;
overwrites.DeniedPermissions &= roleOverwrites.DeniedPermissions;
}
}
}
permissions &= ~overwrites.DeniedPermissions;
permissions |= overwrites.AllowedPermissions;
PermissionOverwrite userOverwrite = _packet.PermissionOverwrites.FirstOrDefault(x => x.Id == user.Id);
if (userOverwrite != null)
{
permissions &= ~userOverwrite.DeniedPermissions;
permissions |= userOverwrite.AllowedPermissions;
}
}
return(permissions);
}
public bool HasPermissions(IDiscordChannel channel, params DiscordGuildPermission[] permissions)
{
foreach (DiscordGuildPermission p in permissions)
{
GuildPermission newP = (GuildPermission)Enum.Parse(typeof(DiscordGuildPermission), p.ToString());
if (!(user as IGuildUser).GuildPermissions.Has(newP))
{
return(false);
}
}
return(true);
}
/// <summary>
/// <see cref="RequireUserPermissionAttribute"/>, but it isn't an attribute
/// </summary>
/// <param name="context">Context</param>
/// <param name="permission">The permission the user needs</param>
/// <returns>True if the user has permissions, else false. Also returns false if the command wasn't executed in a guild.</returns>
public static bool CheckForPermissions(ICommandContext context, GuildPermission permission)
{
if (context.User is not IGuildUser guildUser)
{
return(false);
}
if (guildUser.GuildPermissions.Has(permission))
{
return(true);
}
else
{
return(false);
}
}
public static bool HasPermission(this GuildPermissions p, string s, out GuildPermission perm)
{
perm = GuildPermission.CreateInstantInvite;
foreach (GuildPermission gp in p.ToList())
{
if (gp.ToString().ToLower() == s.ToLower())
{
perm = gp;
return(true);
}
}
return(false);
}
protected async Task <bool> UserHasGuildPermission(GuildPermission guildPerm, string errorMessage = null)
{
var user = Context.User as IGuildUser;
if (user == null)
{
return(false);
}
if (!user.GuildPermissions.Has(guildPerm))
{
await ReplyFailureEmbed(errorMessage ??
$"You require the Guild Permission `{guildPerm.ToString()}` for this command!");
return(false);
}
return(true);
}
internal static Role fromJSON(dynamic data, Guild guild)
{
Role role = new Role();
role.guild = guild;
role.position = data.position;
role.permissionsInt = data.permissions;
role.permissions = GuildPermission.getPermissions(role.permissionsInt);
role.name = data.name;
role.mentionable = data.mentionable;
role.managed = data.managed;
role.ID = data.id;
role.hoist = data.hoist;
role.color = data.color;
Cache.cachedRoles.Add(role, role.guild.ID);
return(role);
}
public static bool HasPermission(this GuildPermissions p, ulong raw, out GuildPermission perm)
{
perm = GuildPermission.CreateInstantInvite;
if (!Enum.TryParse($"{raw}", out GuildPermission permission))
{
return(false);
}
foreach (GuildPermission gp in p.ToList())
{
if (gp == permission)
{
perm = gp;
return(true);
}
}
return(false);
}
public async Task <bool> HasRolePermissionInGuild(ulong guildId, GuildPermission permission)
{
IGuild guild = _discordAPI.FetchGuildInfo(guildId, CacheBehavior.Default);
if (currentUser == null || guild == null)
{
return(false);
}
IGuildUser member = await _discordAPI.FetchMemberInfo(guildId, currentUser.Id, CacheBehavior.Default);
if (member == null)
{
return(false);
}
if (member.Guild.OwnerId == member.Id)
{
return(true);
}
return(member.GuildPermissions.Has(permission));
}
public static void SetValue(ref ulong allow, ref ulong deny, PermValue?value, GuildPermission bit) => SetValue(ref allow, ref deny, value, (byte)bit);
public static void SetValue(ref ulong rawValue, bool?value, GuildPermission bit) => SetValue(ref rawValue, value, (byte)bit);
public static bool GetValue(ulong value, GuildPermission bit) => GetValue(value, (byte)bit);
public static PermValue GetValue(ulong allow, ulong deny, GuildPermission bit) => GetValue(allow, deny, (byte)bit);
public static void SetValue(ref ulong allow, ref ulong deny, PermValue?value, GuildPermission flag) => SetValue(ref allow, ref deny, value, (ulong)flag);
