public static bool CheckChannelPermission(this IMessageChannel channel, ChannelPermission permission, IGuildUser guildUser) { var guildchannel = channel as IGuildChannel; ChannelPermissions perms; perms = guildchannel != null?guildUser.GetPermissions(guildchannel) : ChannelPermissions.All(null); return(perms.Has(permission)); }
PreconditionResult CheckUser(IUser user, IChannel channel) { var guildUser = user as IGuildUser; // If user is server owner or has the administrator role // they get a free pass. if (guildUser != null && (guildUser.IsServerOwner() || guildUser.GuildPermissions .Has(Discord.GuildPermission.Administrator))) { return(PreconditionResult.FromSuccess()); } if (GuildPermission != null) { if (guildUser == null) { return(PreconditionResult.FromError("Command must be used in a guild channel")); } foreach (GuildPermission guildPermission in GuildPermission) { if (!guildUser.GuildPermissions.Has(guildPermission)) { return(PreconditionResult.FromError($"Command requires guild permission {guildPermission.ToString().SplitCamelCase().Code()}")); } } } if (ChannelPermission != null) { var guildChannel = channel as IGuildChannel; ChannelPermissions perms; if (guildChannel != null) { perms = guildUser.GetPermissions(guildChannel); } else { perms = ChannelPermissions.All(guildChannel); } foreach (ChannelPermission channelPermission in ChannelPermission) { if (!perms.Has(channelPermission)) { return(PreconditionResult.FromError($"Command requires channel permission {channelPermission.ToString().SplitCamelCase().Code()}")); } } } return(PreconditionResult.FromSuccess()); }
public override async Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) { if ( services.GetService <Configuration>().OwnerIds.Contains(context.User.Id)) { return(PreconditionResult.FromSuccess()); } IGuildUser guildUser = null; if (context.Guild != null) { guildUser = await context.Guild.GetCurrentUserAsync().ConfigureAwait(false); } if (GuildPermission.HasValue) { if (guildUser == null) { return(PreconditionResult.FromError( $"This command can only be used in a {"server".InlineCode()} channel")); } if (!guildUser.GuildPermissions.Has(GuildPermission.Value)) { return(PreconditionResult.FromError( $"I need the permission {GuildPermission.Value.Humanize(LetterCasing.Title).ToLower().InlineCode()} to do this")); } } if (!ChannelPermission.HasValue) { return(PreconditionResult.FromSuccess()); } ChannelPermissions perms; if (context.Channel is IGuildChannel guildChannel) { perms = guildUser.GetPermissions(guildChannel); } else { perms = ChannelPermissions.All(context.Channel); } return(!perms.Has(ChannelPermission.Value) ? PreconditionResult.FromError( $"I need the channel permission {ChannelPermission.Value.Humanize(LetterCasing.Title).ToLower().InlineCode()} to do this") : PreconditionResult.FromSuccess()); }
public override Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) { if (services.GetService <Configuration>().OwnerIds.Contains(context.User.Id)) { return(Task.FromResult(PreconditionResult.FromSuccess())); } var guildUser = context.User as IGuildUser; if (GuildPermission.HasValue) { if (guildUser == null) { return(Task.FromResult( PreconditionResult.FromError( $"This command is only available in {"server".InlineCode()} channels"))); } if (!guildUser.GuildPermissions.Has(GuildPermission.Value)) { return(Task.FromResult( PreconditionResult.FromError( $"You need the permission {GuildPermission.Value.Humanize(LetterCasing.Title).ToLower().InlineCode()} to do this"))); } } if (!ChannelPermission.HasValue) { return(Task.FromResult(PreconditionResult.FromSuccess())); } ChannelPermissions perms; if (context.Channel is IGuildChannel guildChannel) { perms = guildUser.GetPermissions(guildChannel); } else { perms = ChannelPermissions.All(context.Channel); } if (!perms.Has(ChannelPermission.Value)) { return(Task.FromResult(PreconditionResult.FromError( $"You need the channel permission {ChannelPermission.Value.Humanize(LetterCasing.Title).ToLower().InlineCode()} to do this"))); } return(Task.FromResult(PreconditionResult.FromSuccess())); }
public override async Task <PreconditionResult> CheckPermissionsAsync(ICommandContext ctx, CommandInfo command, IServiceProvider services) { var context = (ShadeContext)ctx; // Includes owner and trusted users. var isTrusted = await new RequireTrustedUserAttribute().CheckPermissionsAsync(ctx, command, services); if (isTrusted.IsSuccess) { return(PreconditionResult.FromSuccess()); } var guildUser = context.PermissionUser; if (GuildPermission.HasValue) { if (guildUser == null) { return(PreconditionResult.FromError(NotAGuildErrorMessage ?? "Command must be used in a guild channel.")); } if (!guildUser.GuildPermissions.Has(GuildPermission.Value)) { return(PreconditionResult.FromError(ErrorMessage ?? $"User requires guild permission {GuildPermission.Value}.")); } } if (ChannelPermission.HasValue) { ChannelPermissions perms; if (context.Channel is IGuildChannel guildChannel) { perms = guildUser.GetPermissions(guildChannel); } else { perms = ChannelPermissions.All(context.Channel); } if (!perms.Has(ChannelPermission.Value)) { return(PreconditionResult.FromError(ErrorMessage ?? $"User requires channel permission {ChannelPermission.Value}.")); } } return(PreconditionResult.FromSuccess()); }
public override async Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) { IGuildUser guildUser = null; if (context.Guild != null) { guildUser = await context.Guild.GetCurrentUserAsync().ConfigureAwait(false); } if (GuildPermission.HasValue) { if (guildUser == null) { return(PreconditionResult.FromError("Command must be used in a guild channel")); } if (!guildUser.GuildPermissions.Has(GuildPermission.Value)) { return(PreconditionResult.FromError($"Bot requires guild permission {GuildPermission.Value}")); } } if (ChannelPermission.HasValue) { var guildChannel = context.Channel as IGuildChannel; ChannelPermissions perms; if (guildChannel != null) { perms = guildUser.GetPermissions(guildChannel); } else { perms = ChannelPermissions.All(guildChannel); } if (!perms.Has(ChannelPermission.Value)) { return(PreconditionResult.FromError($"Bot requires channel permission {ChannelPermission.Value}")); } } return(PreconditionResult.FromSuccess()); }
/// <inheritdoc /> public override async Task <PreconditionResult> CheckRequirementsAsync(IInteractionContext context, ICommandInfo command, IServiceProvider services) { IGuildUser guildUser = null; if (context.Guild != null) { guildUser = await context.Guild.GetCurrentUserAsync().ConfigureAwait(false); } if (GuildPermission.HasValue) { if (guildUser == null) { return(PreconditionResult.FromError(NotAGuildErrorMessage ?? "Command must be used in a guild channel.")); } if (!guildUser.GuildPermissions.Has(GuildPermission.Value)) { return(PreconditionResult.FromError(ErrorMessage ?? $"Bot requires guild permission {GuildPermission.Value}.")); } } if (ChannelPermission.HasValue) { ChannelPermissions perms; if (context.Channel is IGuildChannel guildChannel) { perms = guildUser.GetPermissions(guildChannel); } else { perms = ChannelPermissions.All(context.Channel); } if (!perms.Has(ChannelPermission.Value)) { return(PreconditionResult.FromError(ErrorMessage ?? $"Bot requires channel permission {ChannelPermission.Value}.")); } } return(PreconditionResult.FromSuccess()); }
public async Task Usage() { ChannelPermissions perms; var user = Context.User as IGuildUser; await ReplyAsync($"Command is {Current ?? "_not set_"}"); if (Context.Channel is IGuildChannel guildChannel) { perms = user.GetPermissions(guildChannel); } else { perms = ChannelPermissions.All(Context.Channel); } if (perms.Has(ChannelPermission.ManageChannels)) { await ReplyAsync($"!enable {string.Join("|", Config.Command)}"); } }
public override Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) { var guildUser = context.User as IGuildUser; if (GuildPermission.HasValue) { if (guildUser == null) { return(Task.FromResult(PreconditionResult.FromError("Command must be used in a guild channel"))); } if (!guildUser.GuildPermissions.Has(GuildPermission.Value)) { return(Task.FromResult(PreconditionResult.FromError($"User requires guild permission {GuildPermission.Value}"))); } } if (ChannelPermission.HasValue) { var guildChannel = context.Channel as IGuildChannel; ChannelPermissions perms; if (guildChannel != null) { perms = guildUser.GetPermissions(guildChannel); } else { perms = ChannelPermissions.All(guildChannel); } if (!perms.Has(ChannelPermission.Value)) { return(Task.FromResult(PreconditionResult.FromError($"User requires channel permission {ChannelPermission.Value}"))); } } return(Task.FromResult(PreconditionResult.FromSuccess())); }
public override Task <PreconditionResult> CheckPermissions(IUserMessage context, Command executingCommand, object moduleInstance) { var guildUser = context.Author as IGuildUser; if (GuildPermission.HasValue) { if (guildUser == null) { return(Task.FromResult(PreconditionResult.FromError("Command must be used in a guild channel"))); } if (!guildUser.GuildPermissions.Has(GuildPermission.Value)) { return(Task.FromResult(PreconditionResult.FromError($"Command requires guild permission {GuildPermission.Value}"))); } } if (ChannelPermission.HasValue) { var guildChannel = context.Channel as IGuildChannel; ChannelPermissions perms; if (guildChannel != null) { perms = guildUser.GetPermissions(guildChannel); } else { perms = ChannelPermissions.All(guildChannel); } if (!perms.Has(ChannelPermission.Value)) { return(Task.FromResult(PreconditionResult.FromError($"Command requires channel permission {ChannelPermission.Value}"))); } } return(Task.FromResult(PreconditionResult.FromSuccess())); }
public override async Task <PreconditionResult> CheckPermissions(ICommandContext context, CommandInfo command, IDependencyMap map) { var guildUser = await context.Guild.GetCurrentUserAsync(); if (GuildPermission.HasValue) { if (guildUser == null) { return(PreconditionResult.FromError("Command must be used in a guild channel")); } if (!guildUser.GuildPermissions.Has(GuildPermission.Value)) { return(PreconditionResult.FromError($"Command requires guild permission {GuildPermission.Value}")); } } if (ChannelPermission.HasValue) { var guildChannel = context.Channel as IGuildChannel; ChannelPermissions perms; if (guildChannel != null) { perms = guildUser.GetPermissions(guildChannel); } else { perms = ChannelPermissions.All(guildChannel); } if (!perms.Has(ChannelPermission.Value)) { return(PreconditionResult.FromError($"Command requires channel permission {ChannelPermission.Value}")); } } return(PreconditionResult.FromSuccess()); }
/// <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, ChannelPermission permission) { var guildUser = context.User as IGuildUser; ChannelPermissions perms; if (context.Channel is IGuildChannel guildChannel) { perms = guildUser.GetPermissions(guildChannel); } else { perms = ChannelPermissions.All(context.Channel); } if (perms.Has(permission)) { return(true); } else { return(false); } }
public override Task <CheckResult> CheckAsync(ICommandContext ctx, IServiceProvider provider) { var context = (QuiccbanContext)ctx; var responseService = provider.GetService <ResponseService>(); var guildUser = context.Guild.CurrentUser; if (GuildPermission.HasValue) { if (!guildUser.GuildPermissions.Has(GuildPermission.Value)) { return(Task.FromResult(new CheckResult(string.Format(responseService.Get("bot_require_guild_permission"), GuildPermission.Value)))); } } if (ChannelPermission.HasValue) { ChannelPermissions perms; if (context.Channel is IGuildChannel guildChannel) { perms = guildUser.GetPermissions(guildChannel); } else { perms = ChannelPermissions.All(context.Channel); } if (!perms.Has(ChannelPermission.Value)) { return(Task.FromResult(new CheckResult(string.Format(responseService.Get("bot_require_channel_permission"), ChannelPermission.Value)))); } } return(Task.FromResult(CheckResult.Successful)); }
/// <inheritdoc /> public override Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) { var guildUser = context.User as IGuildUser; if (GuildPermission.HasValue) { if (guildUser == null) { return(Task.FromResult(PreconditionAttributeResult.FromError("Command must be used in a guild channel.", this))); } if (guildUser.GuildPermissions.Has(GuildPermission.Value)) { return(Task.FromResult(PreconditionPermissionResult.FromError($"User requires guild permission {GuildPermission.Value}.", GuildPermission.Value & ~((GuildPermission)guildUser.GuildPermissions.RawValue), 0, this))); } } if (ChannelPermission.HasValue) { ChannelPermissions perms; if (context.Channel is IGuildChannel guildChannel) { perms = guildUser.GetPermissions(guildChannel); } else { perms = ChannelPermissions.All(context.Channel); } if (perms.Has(ChannelPermission.Value)) { return(Task.FromResult(PreconditionPermissionResult.FromError($"User requires channel permission {ChannelPermission.Value}.", 0, ChannelPermission.Value & ~((ChannelPermission)perms.RawValue), this))); } } return(Task.FromResult(PreconditionResult.FromSuccess())); }
/// <inheritdoc /> public override Task <PreconditionResult> CheckRequirementsAsync(IInteractionContext context, ICommandInfo commandInfo, IServiceProvider services) { var guildUser = context.User as IGuildUser; if (GuildPermission.HasValue) { if (guildUser == null) { return(Task.FromResult(PreconditionResult.FromError(NotAGuildErrorMessage ?? "Command must be used in a guild channel."))); } if (!guildUser.GuildPermissions.Has(GuildPermission.Value)) { return(Task.FromResult(PreconditionResult.FromError(ErrorMessage ?? $"User requires guild permission {GuildPermission.Value}."))); } } if (ChannelPermission.HasValue) { ChannelPermissions perms; if (context.Channel is IGuildChannel guildChannel) { perms = guildUser.GetPermissions(guildChannel); } else { perms = ChannelPermissions.All(context.Channel); } if (!perms.Has(ChannelPermission.Value)) { return(Task.FromResult(PreconditionResult.FromError(ErrorMessage ?? $"User requires channel permission {ChannelPermission.Value}."))); } } return(Task.FromResult(PreconditionResult.FromSuccess())); }
public override async Task<PreconditionResult> CheckPermissions(ICommandContext context, CommandInfo command, IServiceProvider map) { var guildUser = context.User as IGuildUser; //If the user is the owner of the bot, skip checking for permissions if ((await context.Client.GetApplicationInfoAsync().ConfigureAwait(false)).Owner.Id == context.User.Id) return PreconditionResult.FromSuccess(); if (GuildPermission.HasValue) { if (guildUser == null) return PreconditionResult.FromError("Command must be used in a guild channel"); if (!guildUser.GuildPermissions.Has(GuildPermission.Value)) return PreconditionResult.FromError($"Command requires guild permission {GuildPermission.Value}"); } if (ChannelPermission.HasValue) { var guildChannel = context.Channel as IGuildChannel; ChannelPermissions perms; perms = guildChannel != null ? guildUser.GetPermissions(guildChannel) : ChannelPermissions.All(guildChannel); if (!perms.Has(ChannelPermission.Value)) return PreconditionResult.FromError($"Command requires channel permission {ChannelPermission.Value}"); } return PreconditionResult.FromSuccess(); }
public override Task <PreconditionResult> CheckPermissionsAsync( ICommandContext context, CommandInfo command, IServiceProvider services) { IGuildUser user = context.User as IGuildUser; if (context.User.IsWebhook) { return(Task.FromResult(_webhookNames.Contains(context.User.Username) ? PreconditionResult.FromSuccess() : PreconditionResult.FromError("Command must be used by an authorized webhook."))); } if (this.GuildPermission.HasValue) { if (user == null) { return(Task.FromResult(PreconditionResult.FromError(this.NotAGuildErrorMessage ?? "Command must be used in a guild channel."))); } if (!user.GuildPermissions.Has(this.GuildPermission.Value)) { return(Task.FromResult(PreconditionResult.FromError(this.ErrorMessage ?? string.Format("User requires guild permission {0}.", (object)this.GuildPermission.Value)))); } } Discord.ChannelPermission?channelPermission = this.ChannelPermission; if (channelPermission.HasValue) { ChannelPermissions channelPermissions = !(context.Channel is IGuildChannel channel) ? ChannelPermissions.All((IChannel)context.Channel) : user.GetPermissions(channel); ref ChannelPermissions local = ref channelPermissions; channelPermission = this.ChannelPermission; long num = (long)channelPermission.Value; if (!local.Has((Discord.ChannelPermission)num)) { string reason = this.ErrorMessage; if (reason == null) { channelPermission = this.ChannelPermission; reason = string.Format("User requires channel permission {0}.", (object)channelPermission.Value); } return(Task.FromResult(PreconditionResult.FromError(reason))); } }
private async Task OnCommandExecutedAsync(Optional <CommandInfo> optionalCommand, ICommandContext context, IResult result) { // We have access to the information of the command executed, // the context of the command, and the result returned from the // execution in this event. // command is unspecified when there was a search failure (command not found) if (!optionalCommand.IsSpecified) { await _logService.LogAsync(new LogMessage(LogSeverity.Info, "Command", $"Unknown command: \"{context.Message.Content}\", sent by {context.User} in {context.Display()}")); return; } var command = optionalCommand.Value; if (command.Module.Name != Constants.DevelopmentModuleName) { // Update the command stats lock (_cmdStatsLock) { var stats = DatabaseConfig.CommandStats; if (stats.ContainsKey(command.Name)) { stats[command.Name]++; } else { stats.Add(command.Name, 1); } DatabaseConfig.Update(x => x.CommandStats = stats); } } // the command was successful, we don't care about this result, unless we want to log that a command succeeded. if (result.IsSuccess) { return; } double ignoreTime = Constants.DefaultIgnoreTime; switch (result.Error) { //case CommandError.UnknownCommand: // await SendEmbedAsync(context.Message, string.Format(LocalizationService.Locate("CommandNotFound", context.Message), GetPrefix(context.Channel))); // break; case CommandError.BadArgCount: case CommandError.ParseFailed: string language = GuildUtils.GetLanguage(context.Channel); string prefix = GuildUtils.GetPrefix(context.Channel); await SendEmbedAsync(context.Message, command.ToHelpEmbed(language, prefix), _services); break; case CommandError.UnmetPrecondition when command.Module.Name != Constants.DevelopmentModuleName: ChannelPermissions permissions; if (context.Guild == null) { permissions = ChannelPermissions.All(context.Channel); } else { var guildUser = await context.Guild.GetCurrentUserAsync().ConfigureAwait(false); permissions = guildUser.GetPermissions((IGuildChannel)context.Channel); } if (!permissions.Has(Constants.MinimumRequiredPermissions)) { var builder = new EmbedBuilder() .WithDescription($"\u26a0 {result.ErrorReason}") .WithColor(FergunClient.Config.EmbedColor); try { await context.User.SendMessageAsync(embed : builder.Build()); } catch (HttpException e) when(e.DiscordCode == 50007) { await _logService.LogAsync(new LogMessage(LogSeverity.Warning, "Command", "Unable to send a DM about the minimum required permissions to the user.")); } } else { if (result.ErrorReason.StartsWith("(Cooldown)", StringComparison.OrdinalIgnoreCase)) { ignoreTime = Constants.CooldownIgnoreTime; } await SendEmbedAsync(context.Message, $"\u26a0 {GuildUtils.Locate(result.ErrorReason, context.Channel)}", _services); } break; case CommandError.ObjectNotFound: // reason: The error reason (User not found., Role not found., etc) string reason = result.ErrorReason; // Delete the last char (.) reason = reason.Substring(0, result.ErrorReason.Length - 1); // Convert to title case (User Not Found) reason = CultureInfo.InvariantCulture.TextInfo.ToTitleCase(reason); // Remove spaces (UserNotFound) reason = reason.Replace(" ", string.Empty, StringComparison.OrdinalIgnoreCase); // Locate the string to the current language of the guild reason = GuildUtils.Locate(reason, context.Channel); await SendEmbedAsync(context.Message, $"\u26a0 {reason}", _services); break; case CommandError.MultipleMatches: await SendEmbedAsync(context.Message, $"\u26a0 {GuildUtils.Locate("MultipleMatches", context.Channel)}", _services); break; case CommandError.Unsuccessful: await SendEmbedAsync(context.Message, $"\u26a0 {result.ErrorReason}".Truncate(EmbedBuilder.MaxDescriptionLength), _services); break; case CommandError.Exception when result is ExecuteResult execResult: var exception = execResult.Exception; if (exception is HttpException httpException && httpException.HttpCode >= HttpStatusCode.InternalServerError) { await Task.Delay(2000); var builder = new EmbedBuilder() .WithTitle(GuildUtils.Locate("DiscordServerError", context.Channel)) .WithDescription($"\u26a0 {GuildUtils.Locate("DiscordServerErrorInfo", context.Channel)}") .AddField(GuildUtils.Locate("ErrorDetails", context.Channel), Format.Code($"Code: {(int)httpException.HttpCode}, Reason: {httpException.Reason}", "md")) .WithColor(FergunClient.Config.EmbedColor); try { await SendEmbedAsync(context.Message, builder.Build(), _services); } catch (HttpException) { } break; } var builder2 = new EmbedBuilder() .WithTitle($"\u274c {GuildUtils.Locate("FailedExecution", context.Channel)} {Format.Code(command.Name)}") .AddField(GuildUtils.Locate("ErrorType", context.Channel), Format.Code(exception.GetType().Name, "cs")) .AddField(GuildUtils.Locate("ErrorMessage", context.Channel), Format.Code(exception.Message, "cs")) .WithColor(FergunClient.Config.EmbedColor); var owner = (await context.Client.GetApplicationInfoAsync()).Owner; if (context.User.Id != owner.Id) { builder2.WithFooter(GuildUtils.Locate("ErrorSentToOwner", context.Channel)); } await SendEmbedAsync(context.Message, builder2.Build(), _services); if (context.User.Id == owner.Id) { break; } // if the user that executed the command isn't the bot owner, send the full stack trace to the errors channel var channel = await context.Client.GetChannelAsync(FergunClient.Config.LogChannel); if (!(channel is IMessageChannel messageChannel)) { await _logService.LogAsync(new LogMessage(LogSeverity.Warning, "Command", $"Invalid log channel Id ({FergunClient.Config.LogChannel}). Not possible to send the embed with the error info.")); break; } var builder3 = new EmbedBuilder() .WithTitle($"\u274c Failed to execute {Format.Code(command.Name)} in {context.Display()}".Truncate(EmbedBuilder.MaxTitleLength)) .AddField(GuildUtils.Locate("ErrorType", messageChannel), Format.Code(exception.GetType().Name, "cs")) .AddField(GuildUtils.Locate("ErrorMessage", messageChannel), Format.Code(exception.ToString().Truncate(EmbedFieldBuilder.MaxFieldValueLength - 10), "cs")) .AddField("Jump url", context.Message.GetJumpUrl()) .AddField("Command", context.Message.Content.Truncate(EmbedFieldBuilder.MaxFieldValueLength)) .WithColor(FergunClient.Config.EmbedColor); try { await messageChannel.SendMessageAsync(embed : builder3.Build()); } catch (HttpException e) { await _logService.LogAsync(new LogMessage(LogSeverity.Warning, "Command", "Error while sending the embed in the log channel", e)); } break; } _ = IgnoreUserAsync(context.User.Id, TimeSpan.FromSeconds(ignoreTime)); await _logService.LogAsync(new LogMessage(LogSeverity.Info, "Command", $"Failed to execute \"{command.Name}\" for {context.User} in {context.Display()}, with error type: {result.Error} and reason: {result.ErrorReason}")); }