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