public override ValueTask <CheckResult> CheckAsync(CommandContext _) { var baseResult = base.CheckAsync(_).Result; if (!baseResult.IsSuccessful) { return(baseResult); } var context = _ as DiscordCommandContext; var permissions = context.Guild.CurrentMember.GetPermissionsFor(context.Channel as IGuildChannel); return(permissions.Has(Permissions) ? CheckResult.Successful : CheckResult.Unsuccessful($"The bot lacks the necessary channel permissions ({Permissions - permissions}) to execute this.")); }
public override ValueTask <CheckResult> CheckAsync(CommandContext _) { var baseResult = base.CheckAsync(_).Result; if (!baseResult.IsSuccessful) { return(baseResult); } var context = _ as DiscordCommandContext; var permissions = context.Member.Permissions; return(permissions.Has(Permissions) ? CheckResult.Successful : CheckResult.Unsuccessful($"You lack the necessary guild permissions ({Permissions - permissions}) to execute this.")); }
public override ValueTask <CheckResult> CheckAsync(object argument, CommandContext context) { if (!(context is AbfCommandContext ctx)) { return(CheckResult.Unsuccessful("Invalid command context.")); } if (!(argument is CachedMember mbr)) { return(CheckResult.Unsuccessful("The argument was not a CachedMember")); } return(ctx.Member.Hierarchy > mbr.Hierarchy && ctx.Guild.CurrentMember.Hierarchy > mbr.Hierarchy ? CheckResult.Successful : CheckResult.Unsuccessful($"Sorry. {mbr.ToString()} is protected.")); }
public override async ValueTask <CheckResult> CheckAsync(object argument, CommandContext ctx) { var baseCheck = await base.CheckAsync(argument, ctx); if (!baseCheck.IsSuccessful) { return(baseCheck); } var context = (AdminCommandContext)ctx; var emoji = (LocalCustomEmoji)argument; return(!context.Guild.Emojis.ContainsKey(emoji.Id) ? CheckResult.Unsuccessful(context.Localize("require_guild_emoji")) : CheckResult.Successful); }
public override async ValueTask <CheckResult> CheckAsync(CommandContext ctx) { var context = (AdminCommandContext)ctx; var permissions = context.IsPrivate ? await context.Database.Permissions.Where(x => !x.GuildId.HasValue) .OrderByDescending(x => x.Id) .ToListAsync() : await context.Database.Permissions.Where(x => !x.GuildId.HasValue || x.GuildId == context.Guild.Id) .OrderByDescending(x => x.Id) .ToListAsync(); if (context.Guild?.OwnerId == context.User.Id) { return(CheckResult.Successful); } var userId = context.User.Id; var roleIds = (context.User as CachedMember)?.Roles.Keys.ToList() ?? new List <Snowflake>(); var channelId = context.Channel.Id; var guildId = context.Guild?.Id; var commandName = context.Command.FullAliases[0]; foreach (var permission in permissions) { if (!string.IsNullOrWhiteSpace(permission.Name) && !context.Command.Module.Name.Equals(permission.Name) && !commandName.Equals(permission.Name)) { continue; } switch (permission.Filter) { case PermissionFilter.Global: case PermissionFilter.Guild when guildId == permission.TargetId: case PermissionFilter.Role when roleIds.Contains(permission.TargetId.GetValueOrDefault()): case PermissionFilter.Channel when channelId == permission.TargetId: case PermissionFilter.User when userId == permission.TargetId: return(permission.IsEnabled ? CheckResult.Successful : CheckResult.Unsuccessful(context.Localize("permissions_denied", permission.Id))); } } return(CheckResult.Successful); }
public async ValueTask <CheckResult> RunChecksAsync(ICommandContext context, IServiceProvider provider) { if (Checks is null) { return(CheckResult.Successful); } var results = await Task.WhenAll(Checks.Select(c => c.CheckAsync(context, provider).AsTask())); var failedChecks = results .Where(r => !r.IsSuccessful) .Select(r => r.Reason !) .ToList(); return(failedChecks.Any() ? CheckResult.Unsuccessful(string.Join("\n", failedChecks)) : CheckResult.Successful); }
public override ValueTask <CheckResult> CheckAsync(MummyContext context) { CachedMember user = null; switch (_target) { case PermissionTarget.User: user = context.User; break; case PermissionTarget.Bot: user = context.Guild.CurrentMember; break; } var failedGuildPerms = _guildPerms.Where(guildPerm => !user.Permissions.Has(guildPerm)).ToArray(); var channelPerms = context.User.GetPermissionsFor(context.Channel); var failedChannelPerms = _channelPerms.Where(channelPerm => !channelPerms.Has(channelPerm)).ToArray(); if (failedGuildPerms.Length == 0 && failedChannelPerms.Length == 0) { return(CheckResult.Successful); } var sb = new StringBuilder(); foreach (var guildPerm in failedGuildPerms) { sb.AppendLine(guildPerm.ToString()); } foreach (var channelPerm in failedChannelPerms) { sb.AppendLine(channelPerm.ToString()); } var u = context.User; var target = _target == PermissionTarget.User ? "You" : "I"; return(CheckResult.Unsuccessful($"{target} lack permissions for {sb}")); }
public override ValueTask <CheckResult> CheckAsync(object argument, MummyContext context) { var lenght = argument.ToString().Length; if (lenght == 6) { return(CheckResult.Successful); } else { if (lenght < 6) { return(CheckResult.Unsuccessful($"the code provide was to SHORT and it required to be 6 chars long exactly. (code provided was {lenght} char long)")); } else { return(CheckResult.Unsuccessful($"the code provide was to LONG and it required to be 6 chars long exactly. (code provided was {lenght} char long)")); } } }
public override ValueTask <CheckResult> CheckAsync(CommandContext _) { var baseResult = base.CheckAsync(_).Result; if (!baseResult.IsSuccessful) { return(baseResult); } var context = _ as DiscordCommandContext; if (context.Guild.OwnerId == context.Member.Id) { return(CheckResult.Successful); } else { return(CheckResult.Unsuccessful("This command can only be executed by the server owner.")); } }
public override async ValueTask <CheckResult> CheckAsync(CommandContext ctx) { var baseCheck = await base.CheckAsync(ctx); if (!baseCheck.IsSuccessful) { return(baseCheck); } var context = (AdminCommandContext)ctx; if (!(await context.Database.GetLoggingChannelAsync(context.Guild.Id, RequiredLogType) is { } channel)) { return(CheckResult.Unsuccessful(context.Localize("requireloggingchannel_notfound", RequiredLogType))); } return(channel.Id != context.Channel.Id ? CheckResult.Unsuccessful(context.Localize("requireloggingchannel", RequiredLogType)) : CheckResult.Successful); }
public override async ValueTask <CheckResult> CheckAsync(CommandContext _) { var context = _ as DiscordCommandContext; switch (context.Bot.TokenType) { case TokenType.Bot: { if (application == null) { application = await context.Bot.GetCurrentApplicationAsync().ConfigureAwait(false); } if (application.Team != null && application.Team.Members != null) { if (application.Team.Members.ContainsKey(context.User.Id)) { return(CheckResult.Successful); } } return(application.Owner.Id == context.User.Id ? CheckResult.Successful : CheckResult.Unsuccessful("This can only be executed by the bot's owner or team members.")); } case TokenType.Bearer: case TokenType.User: { return(context.Bot.CurrentUser.Id == context.User.Id ? CheckResult.Successful : CheckResult.Unsuccessful("This can only be executed by the currently logged in user.")); } default: throw new InvalidOperationException("Invalid token type."); } }
public override Task <CheckResult> CheckAsync(object argument, ICommandContext ctx, IServiceProvider provider) { var context = (AdminCommandContext)ctx; var target = (SocketGuildUser)argument; var user = (SocketGuildUser)context.User; if (context.IsPrivate) { return(Task.FromResult( CheckResult.Unsuccessful(context.Localize("requirecontext", Format.Bold("guild"))))); } if (context.Guild.CurrentUser.Hierarchy <= target.Hierarchy) { return(Task.FromResult(CheckResult.Unsuccessful(context.Localize("requirehierarchy_self")))); } if (user.Hierarchy <= target.Hierarchy) { return(Task.FromResult(CheckResult.Unsuccessful(context.Localize("requirehierarchy_user")))); } return(Task.FromResult(CheckResult.Successful)); }
public override Task <CheckResult> CheckAsync(object argument, ICommandContext context, IServiceProvider provider) { if (!(context is FoxCommandContext ctx)) { return(Task.FromResult(CheckResult.Unsuccessful("Invalid command context."))); } if (!(argument is DiscordMember mbr)) { return(Task.FromResult(CheckResult.Unsuccessful("The argument was not a DiscordMember"))); } return(ctx.Member.Hierarchy > mbr.Hierarchy && ctx.Guild.CurrentMember.Hierarchy > mbr.Hierarchy ? Task.FromResult(CheckResult.Successful) : Task.FromResult(CheckResult.Unsuccessful($"Sorry. {mbr.FormatUser()} is protected."))); }
public override ValueTask <CheckResult> CheckAsync(object argument, CommandContext ctx) { var context = (AdminCommandContext)ctx; var user = (CachedMember)context.User; if (context.IsPrivate) { return(CheckResult.Unsuccessful(context.Localize("requirecontext_guild"))); } var result = string.Empty; switch (argument) { case CachedRole targetRole: result = GetRoleResult(targetRole); break; case CachedRole[] targetRoles: foreach (var targetRole in targetRoles) { result = GetRoleResult(targetRole); if (!string.IsNullOrWhiteSpace(result)) { break; } } break; case CachedMember[] targetUsers: foreach (var targetUser in targetUsers) { result = GetUserResult(targetUser); if (!string.IsNullOrWhiteSpace(result)) { break; } } break; case CachedMember targetUser: result = GetUserResult(targetUser); break; } return(string.IsNullOrWhiteSpace(result) ? CheckResult.Successful : CheckResult.Unsuccessful(result)); string GetRoleResult(CachedRole target) { if (context.Guild.CurrentMember.GetHighestRole().Position <= target.Position) { return(context.Localize("role_unassignable_self", Markdown.Bold(target.Name))); } if (user.GetHighestRole().Position <= target.Position) { return(context.Localize("role_unassignable_user", Markdown.Bold(target.Name))); } return(string.Empty); } string GetUserResult(CachedMember target) { if (context.Guild.CurrentMember.Hierarchy <= target.Hierarchy) { return(context.Localize("requirehierarchy_self")); } if (user.Hierarchy <= target.Hierarchy) { return(context.Localize("requirehierarchy_user")); } return(string.Empty); } }
public override ValueTask <CheckResult> CheckAsync(CommandContext context) => context.Command.IsExecuting((AdminCommandContext)context) ? CheckResult.Unsuccessful(string.Empty) : CheckResult.Successful;
public override ValueTask <CheckResult> CheckAsync(ScrapContext context) => UserIds.Contains(context.User.Id) ? CheckResult.Successful : CheckResult.Unsuccessful("You do not have access to this command!");