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);