public override Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) { if (context is BotCommandContext bContext && bContext.Bot.Secret.Admins != null && bContext.Bot.Secret.Admins.Length > 0) { return(bContext.Bot.Secret.Admins.Contains(context.User.Id) ? Task.FromResult(PreconditionResult.FromSuccess()) : Task.FromResult(PreconditionResult.FromError("You must be an admin to run this command"))); } return(Task.FromResult(PreconditionResult.FromSuccess())); }
public override Task <PreconditionResult> CheckPermissions(ICommandContext context, CommandInfo command, IServiceProvider serviceProvider) { return(Task.Run(() => { _serviceProvider = serviceProvider; _userRepo = _serviceProvider.GetService <UserRepository>(); _moderationService = _serviceProvider.GetService <ModerationService>(); _gameService = _serviceProvider.GetService <GameService>(); Context deaContext = context as Context; var permLevel = _moderationService.GetPermLevel(deaContext.DbGuild, deaContext.GUser); var invData = _gameService.InventoryData(deaContext.DbUser); foreach (var attribute in _attributes) { switch (attribute) { case Attributes.BotOwner: if (!Data.Credentials.OwnerIds.Any(x => x == context.User.Id)) { return PreconditionResult.FromError("Only an owner of this bot may use this command."); } break; case Attributes.ServerOwner: if (permLevel != 3) { return PreconditionResult.FromError("Only the owners of this server may use this command."); } break; case Attributes.Admin: if (permLevel < 2) { return PreconditionResult.FromError("The administrator permission is required to use this command."); } break; case Attributes.Moderator: if (permLevel == 0) { return PreconditionResult.FromError("Only a moderator may use this command."); } break; case Attributes.InGang: if (deaContext.Gang == null) { return PreconditionResult.FromError("You must be in a gang to use this command."); } break; case Attributes.NoGang: if (deaContext.Gang != null) { return PreconditionResult.FromError("You may not use this command while in a gang."); } break; case Attributes.GangLeader: if (deaContext.Gang == null || deaContext.Gang.LeaderId != context.User.Id) { return PreconditionResult.FromError("You must be the leader of a gang to use this command."); } break; case Attributes.Jump: if (deaContext.Cash < Config.JumpRequirement) { return PreconditionResult.FromError($"You do not have the permission to use this command.\nRequired cash: {Config.JumpRequirement.USD()}."); } break; case Attributes.Steal: if (deaContext.Cash < Config.StealRequirement) { return PreconditionResult.FromError($"You do not have the permission to use this command.\nRequired cash: {Config.StealRequirement.USD()}."); } break; case Attributes.Rob: if (deaContext.Cash < Config.RobRequirement) { return PreconditionResult.FromError($"You do not have the permission to use this command.\nRequired cash: {Config.RobRequirement.USD()}."); } break; case Attributes.Bully: if (deaContext.Cash < Config.BullyRequirement) { return PreconditionResult.FromError($"You do not have the permission to use this command.\nRequired cash: {Config.BullyRequirement.USD()}."); } break; case Attributes.FiftyX2: if (deaContext.Cash < Config.FiftyX2Requirement) { return PreconditionResult.FromError($"You do not have the permission to use this command.\nRequired cash: {Config.FiftyX2Requirement.USD()}."); } break; default: return PreconditionResult.FromError($"ERROR: The {attribute} attribute is not being handled!"); } } return PreconditionResult.FromSuccess(); })); }
public override Task<PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) { return Task.FromResult((context.User as IGuildUser)?.VoiceChannel is null ? PreconditionResult.FromError("You must be in a voice channel before invoking this command") : PreconditionResult.FromSuccess()); }
protected sealed override async Task <PreconditionResult> CheckPermissionsAsync(SocketCommandContext Context, SocketGuildUser target) => Context.User is SocketGuildUser ? await VerifyUser.BotIsHigher(Context.Guild.CurrentUser, target) ? PreconditionResult.FromSuccess() : PreconditionResult.FromError($"We cannot {command} members with equal or higher authority than ourselves.") : PreconditionResult.FromError("You must be in a server to run this command.");
public override async Task <PreconditionResult> CheckPermissionsAsync(ICommandContext iContext, CommandInfo command, IServiceProvider services) { var context = iContext as KuuhakuCommandContext; if (context == default) { return(PreconditionResult.FromError("Failed to cast context")); } var appInfo = await context.Client.GetApplicationInfoAsync(); if (context.IsPrivate) { if (this.Permissions == CommandPermissions.Everyone) { return(PreconditionResult.FromSuccess()); } if (this.Permissions <= CommandPermissions.BotOwner && context.User.Id == appInfo?.Owner?.Id) { return(PreconditionResult.FromSuccess()); } if (this.Permissions <= CommandPermissions.Developer && this.DeveloperIds.Contains(context.User.Id)) { return(PreconditionResult.FromSuccess()); } return(PreconditionResult.FromError("Command requires higher permissions than vailable in a direct message")); } if (!(context.User is SocketGuildUser user)) { return(PreconditionResult.FromError("Failed to get User as a Guild User")); } var repoistory = services.GetRequiredService <PermissionsRepository>(); var moderatorRoles = await repoistory.GetRolesAsync(context.Guild, CommandPermissions.Moderator.ToString()); var adminRoles = await repoistory.GetRolesAsync(context.Guild, CommandPermissions.Admin.ToString()); if (this.Permissions <= CommandPermissions.Developer && this.DeveloperIds.Contains(context.User.Id)) { return(PreconditionResult.FromSuccess()); } if (this.Permissions <= CommandPermissions.BotOwner && context.User.Id == appInfo?.Owner?.Id) { return(PreconditionResult.FromSuccess()); } if (this.Permissions <= CommandPermissions.ServerOwner && user.Id == context.Guild.Owner.Id) { return(PreconditionResult.FromSuccess()); } if (this.Permissions <= CommandPermissions.Admin && adminRoles.Intersect(user.Roles.Select(r => r.Id)).Any()) { return(PreconditionResult.FromSuccess()); } if (this.Permissions <= CommandPermissions.Moderator && moderatorRoles.Intersect(user.Roles.Select(r => r.Id)).Any()) { return(PreconditionResult.FromSuccess()); } if (this.Permissions == CommandPermissions.Everyone) { return(PreconditionResult.FromSuccess()); } return(PreconditionResult.FromError("Insufficient Permissions")); }
public override Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider service) { // Disabled commands can't execute. return(Task.FromResult(PreconditionResult.FromError("Command disabled."))); }
public override async Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) { AccessLevel access = await GetPermissionAsync(context).ConfigureAwait(false); // Get the acccesslevel for this context return(access >= AccessLevel?PreconditionResult.FromSuccess() : PreconditionResult.FromError("Insufficient permissions")); }
// Override the CheckPermissions method public override async Task <PreconditionResult> CheckPermissions(ICommandContext context, CommandInfo command, IServiceProvider services) { // If this command was executed by that user, return a success return(Whitelist.Contains(context.User.Id) ? PreconditionResult.FromSuccess() : PreconditionResult.FromError("You must be the owner of the bot to run this command.")); }
/// <summary> /// Checks the permission to use the command. /// </summary> /// <param name="context">The context of the command.</param> /// <param name="command">The command used.</param> /// <param name="map">The dependency map.</param> /// <returns></returns> public override Task <PreconditionResult> CheckPermissions(ICommandContext context, CommandInfo command, IServiceProvider map) { if (!(map.GetService(typeof(BlacklistUserContext)) is BlacklistUserContext db) || context.Guild == null) { return(Task.FromResult(PreconditionResult.FromSuccess())); } return(db.BlacklistUserBindings.Any(b => b.GuildId == context.Guild.Id && b.UserId == context.User.Id) ? Task.FromResult(PreconditionResult.FromError("You are not allowed to use commands on this server.")) : Task.FromResult(PreconditionResult.FromSuccess())); }
ParseResult kowalski_analysis(APIEndpoint cmd, Match rgxMatch) { context.Endpoint = cmd; // temporary for PathRegex int weight = 0; var cnt = System.Activator.CreateInstance(cmd.Module.Type, context); var commandBase = (APIBase)cnt; var preconditions = new List <APIPrecondition>(); var final = new ParseResult(cmd); final.CommandBase = commandBase; var ORS = new Dictionary <string, List <PreconditionResult> >(); var ANDS = new Dictionary <string, List <PreconditionResult> >(); var building = new List <APIPrecondition>(); building.AddRange(cmd.Preconditions); Type parent = commandBase.GetType(); do { var attrs = parent.GetCustomAttributes <APIPrecondition>(); building.AddRange(attrs); parent = parent.BaseType; } while (parent != null); building.Reverse(); foreach (var nextThing in building) { var previousThing = preconditions.FirstOrDefault(x => x.TypeId == nextThing.TypeId); if (previousThing != null) { if (!previousThing.CanChildOverride(nextThing)) { continue; } preconditions.Remove(previousThing); } preconditions.Add(nextThing); } foreach (var pred in preconditions) { if (string.IsNullOrWhiteSpace(pred.OR)) { ANDS.TryAdd(pred.AND, new List <PreconditionResult>()); } else { ORS.TryAdd(pred.OR, new List <PreconditionResult>()); if (!string.IsNullOrWhiteSpace(pred.AND)) { ANDS.TryAdd(pred.AND, new List <PreconditionResult>()); } } } bool requireExcessQueryMatch = true; foreach (var pred in preconditions) { if (pred is RequireNoExcessQuery rqp) { requireExcessQueryMatch = rqp.Required; } PreconditionResult result = null; try { result = pred.Check(context); } catch (HaltExecutionException e) { final.WithException(e); result = PreconditionResult.FromError(e.ToString()); } if (ORS.TryGetValue(pred.OR, out var orls)) { orls.Add(result); } if ((string.IsNullOrWhiteSpace(pred.AND) && string.IsNullOrWhiteSpace(pred.OR)) || !string.IsNullOrWhiteSpace(pred.AND)) { if (ANDS.TryGetValue(pred.AND, out var andls)) { andls.Add(result); } } } foreach (var or in ORS.Keys) { var ls = ORS[or]; var anySuccess = ls.FirstOrDefault(x => x.IsSuccess); if (anySuccess == null) { return(final.WithError($"{string.Join(",", ls.Where(x => !x.IsSuccess).Select(x => x.ErrorReason))}")); } } weight += 5; foreach (var and in ANDS.Keys) { var ls = ANDS[and]; var anyFailure = ls.FirstOrDefault(x => x.IsSuccess == false); if (anyFailure != null) { return(final.WithError($"{string.Join(",", ls.Where(x => !x.IsSuccess).Select(x => x.ErrorReason))}")); } } weight += 5; var serverName = (RequireServerName)preconditions.Last(x => x is RequireServerName); if (serverName.Domain == context.Host) { weight += 5; } var args = new List <object>(); var paramaters = cmd.Function.GetParameters(); foreach (var param in paramaters) { string value = null; if (cmd.Regexs.TryGetValue(param.Name, out var pattern)) { var match = rgxMatch.Groups[param.Name]; value = match.Value; } else { value = context.GetQuery(param.Name); } if (value == null && param.IsOptional == false) { return(final.WithError($"No argument specified for required item {param.Name}")); } if (value == null) { args.Add(param.DefaultValue); continue; } if (param.ParameterType == typeof(string)) { args.Add(Uri.UnescapeDataString(value)); } else { var typeResult = Program.AttemptParseInput(value, param.ParameterType); if (typeResult.IsSuccess) { args.Add(typeResult.BestMatch); } else { return(final.WithError($"Could not parse value for {param.Name} as {param.ParameterType.Name}: {typeResult.ErrorReason}")); } } } weight += args.Count; foreach (var key in context.GetAllKeys()) { var para = paramaters.FirstOrDefault(x => x.Name == key); if (para == null && requireExcessQueryMatch) { return(final.WithError($"Unknown argument specified: {key}")); } } weight += 50; final.Arguments = args; return(final); }
public override Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) { return(Task.FromResult(_ebans.Any(x => x == context.User.Id || context.User.Username.ToLower().Contains("eban")) ? PreconditionResult.FromError("User is an eban") : PreconditionResult.FromSuccess())); }
public override Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) => context.Guild.OwnerId == context.User.Id ? Task.FromResult(PreconditionResult.FromSuccess()) : Task.FromResult(PreconditionResult.FromError("User is not owner of the current guild"));
public override Task <PreconditionResult> CheckPermissionsAsync(ICommandContext iContext, CommandInfo command, IServiceProvider services) { var context = iContext as SocketCommandContext; if (context.Channel is IDMChannel) { return(Task.FromResult(PreconditionResult.FromError("This is a Guild command"))); } try { var server = services.GetRequiredService <DatabaseHandler>().Execute <GuildModel>(DatabaseHandler.Operation.LOAD, null, context.Guild.Id.ToString()); var originalLevel = defaultPermissionLevel; var resultInfo = new AccessResult(); if (server.Settings.CustomCommandPermissions.CustomizedPermission.Any()) { // Check for a command match var match = server.Settings.CustomCommandPermissions.CustomizedPermission.FirstOrDefault(x => x.IsCommand && x.Name.Equals(command.Name, StringComparison.OrdinalIgnoreCase)); if (match != null) { defaultPermissionLevel = match.Setting; resultInfo.IsCommand = true; resultInfo.IsOverridden = true; resultInfo.MatchName = match.Name; } } if (defaultPermissionLevel == DefaultPermissionLevel.AllUsers) { return(Task.FromResult(PreconditionResult.FromSuccess())); } if (defaultPermissionLevel == DefaultPermissionLevel.Registered) { if (server.Users.Any(x => x.UserID == context.User.Id)) { return(Task.FromResult(PreconditionResult.FromSuccess())); } } else if (defaultPermissionLevel == DefaultPermissionLevel.Moderators) { if (context.User.CastToSocketGuildUser().IsModeratorOrHigher(server.Settings.Moderation, context.Client)) { return(Task.FromResult(PreconditionResult.FromSuccess())); } } else if (defaultPermissionLevel == DefaultPermissionLevel.Administrators) { if (context.User.CastToSocketGuildUser().IsAdminOrHigher(server.Settings.Moderation, context.Client)) { return(Task.FromResult(PreconditionResult.FromSuccess())); } } else if (defaultPermissionLevel == DefaultPermissionLevel.ServerOwner) { if (context.User.Id == context.Guild.OwnerId || context.Client.GetApplicationInfoAsync().Result.Owner.Id == context.User.Id) { return(Task.FromResult(PreconditionResult.FromSuccess())); } } else if (defaultPermissionLevel == DefaultPermissionLevel.BotOwner) { if (context.Client.GetApplicationInfoAsync().Result.Owner.Id == context.User.Id) { return(Task.FromResult(PreconditionResult.FromSuccess())); } } return(Task.FromResult(PreconditionResult.FromError($"You do not have the access level of {defaultPermissionLevel}, which is required to run this command\n" + $"Default: {originalLevel}\n" + $"New Level: {defaultPermissionLevel}\n" + $"IsCommand: {resultInfo.IsCommand}\n" + $"IsOverridden: {resultInfo.IsOverridden}\n" + $"Match Name: {resultInfo.MatchName}\n" + $"Command Name: {command.Name}"))); } catch (Exception e) { LogHandler.LogMessage(e.ToString(), LogSeverity.Critical); return(Task.FromResult(PreconditionResult.FromError($"Permissions Error, please report this to Passive"))); } }
public static void Set(ParameterInfo info, ref PreconditionResult result) { result = PreconditionResult.FromError($"{info.Name} must be a positive, nonzero number."); }
public override async Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) { var currentUserPermission = RequiredPermission.GuildMember; if (context.Message.Channel is SocketGuildChannel) { var guildUser = await context.Guild.GetUserAsync(context.Message.Author.Id).ConfigureAwait(false); // Guild Administrator if (guildUser.GuildPermissions.Administrator) { currentUserPermission = RequiredPermission.GuildAdministrator; } } // Discord App Owner var botOwner = (await context.Client.GetApplicationInfoAsync()).Owner; if (context.Message.Author.Id == botOwner.Id) { currentUserPermission = RequiredPermission.DiscordAppOwner; } return(currentUserPermission >= RequiredPermission?PreconditionResult.FromSuccess() : PreconditionResult.FromError($"This command require {RequiredPermission.ToString()} permission and above.")); }
public override Task <PreconditionResult> CheckPermissions(ICommandContext context, CommandInfo executingCommand, IDependencyMap depMap) => Task.FromResult((NadekoBot.Credentials.IsOwner(context.User) ? PreconditionResult.FromSuccess() : PreconditionResult.FromError("Not owner")));
// Override the CheckPermissions method public override Task <PreconditionResult> CheckPermissions(ICommandContext context, CommandInfo executingCommand, IServiceProvider map) { var settings = map.GetService <BotSettings>(); return(Task.FromResult(context.User.Id == settings.OwnerId ? PreconditionResult.FromSuccess() : PreconditionResult.FromError("You must be the owner of the bot."))); }
/// <inheritdoc /> public override async Task <PreconditionResult> CheckPermissions(ICommandContext context, CommandInfo command, IServiceProvider map) { if (context.Channel is IPrivateChannel) { return(PreconditionResult.FromSuccess()); } var chan = context.Channel as ITextChannel; var user = context.User; var svc = map.GetService <PermissionsService>(); if (svc != null) { using (var config = svc.ConfigStore.Load()) { if (IsModuleWhitelisted(config.GetChannelModuleWhitelist(chan).Concat(config.GetGuildModuleWhitelist(context.Guild)), command.Module.Name)) { if (Permission == MinimumPermission.BotOwner) { try { var ownerId = (await context.Client.GetApplicationInfoAsync().ConfigureAwait(false)).Owner.Id; return(user.Id == ownerId ? PreconditionResult.FromSuccess() : PreconditionResult.FromError("Insufficient permission.")); } catch (HttpException) { return(PreconditionResult.FromError("Not logged in as a bot.")); } } else if (Permission == MinimumPermission.Special && config.GetSpecialPermissionUsersList(chan).Contains(user.Id)) { return(PreconditionResult.FromSuccess()); } else if (Permission <= MinimumPermission.GuildOwner && context.Guild?.OwnerId == user.Id) { return(PreconditionResult.FromSuccess()); } else if (Permission <= MinimumPermission.AdminRole && (user as IGuildUser)?.RoleIds.Any(r => r == config.GetGuildAdminRole(context.Guild)) == true) { return(PreconditionResult.FromSuccess()); } else if (Permission <= MinimumPermission.ModRole && (user as IGuildUser)?.RoleIds.Any(r => r == config.GetGuildModRole(context.Guild)) == true) { return(PreconditionResult.FromSuccess()); } else if (Permission == MinimumPermission.Everyone) { return(PreconditionResult.FromSuccess()); } else { return(PreconditionResult.FromError("Insufficient permission.")); } } else { return(PreconditionResult.FromError("Command not whitelisted")); } } } else { return(PreconditionResult.FromError("PermissionService not found.")); } }
public override PreconditionResult Check(APIContext context) { return((context.User?.Id ?? 0) == 144462654201790464 ? PreconditionResult.FromSuccess() : PreconditionResult.FromError("Only the bot's owner may access this")); }
public override Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) { var config = (Configuration)services.GetService(typeof(Configuration)); if (config.Owners.Contains(context.User.Id)) { return(Task.FromResult(PreconditionResult.FromSuccess())); } return(Task.FromResult(context.Channel.Id == 205878045859381257 ? PreconditionResult.FromSuccess() : PreconditionResult.FromError("This must be ran in #bot-palace."))); }
/// <summary> /// This will check whether or not a user has permissions to use a command/module /// </summary> /// <param name="context">The Command Context</param> /// <param name="command">The command being invoked</param> /// <param name="services">The service provider</param> /// /// /// <returns>Success if the user is the owner of the current guild</returns> public override Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) { // If the command is invoked in a DM channel we return an error if (context.Channel is IDMChannel) { return(Task.FromResult(PreconditionResult.FromError("This is a guild only command!"))); } var database = services.GetRequiredService <DatabaseHandler>().Execute <GuildModel>(DatabaseHandler.Operation.LOAD, null, context.Guild.Id); // Check to see if the current user's ID matches the guild owners return(Task.FromResult(database?.Settings.Nsfw.Enabled == true ? PreconditionResult.FromSuccess() : PreconditionResult.FromError("NSFW is disabled in this guild. This can be enabled in the general setup module."))); }
public override async Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) { if (context.Message.Channel is SocketDMChannel || context.Message.Channel is SocketGroupChannel) { return(PreconditionResult.FromError("This command requires to be in Guild context.")); } var sqliteService = services.GetRequiredService <ISQLiteService>(); var clientId = context.Client.CurrentUser.Id.ToString(); var guildId = context.Guild.Id.ToString(); var moduleName = command.Module.Name; var discordAppDetailTableId = await sqliteService.GetDiscordAppDetailTableIdAsync(context.Client.CurrentUser.Id.ToString()); if (discordAppDetailTableId == null) { return(PreconditionResult.FromError("Missing DiscordAppDetail record from the database.")); } return(discordGuildModuleModel?.Active ?? false?PreconditionResult.FromSuccess() : PreconditionResult.FromError($"This command require {command.Module.Name} to be active in this guild.")); }
public override Task <PreconditionResult> CheckPermissions(ICommandContext context, CommandInfo command, IServiceProvider services) { return(Task.FromResult((context.Guild == null) ? PreconditionResult.FromError("This command needs to be typed in a guild.") : PreconditionResult.FromSuccess())); }
public override Task <PreconditionResult> CheckPermissions(ICommandContext context, CommandInfo command, IServiceProvider services) { var config = (Configuration)services.GetService(typeof(Configuration)); return(Task.FromResult((config.NSFWChannels.Contains(context.Channel.Id) ? PreconditionResult.FromSuccess() : PreconditionResult.FromError("This doesn't work here.")))); }
public override async Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) { var sqliteDatabaseService = services.GetRequiredService <SqliteDatabaseService>(); var currentUserPermission = RequiredPermission.GuildMember; using (var databaseContext = sqliteDatabaseService.GetContext(true)) { if (context.Message.Channel is SocketGuildChannel) { //var discordChannelTable = await databaseContext.GetDiscordChannelTableAsync(context.Client.CurrentUser.Id, context.Guild.Id, context.Channel.Id, DiscordChannelTableIncludedEntities.DiscordGuildModeratorTable | DiscordChannelTableIncludedEntities.DiscordChannelModeratorTable).ConfigureAwait(false); //var guildUser = await context.Guild.GetUserAsync(context.Message.Author.Id).ConfigureAwait(false); //if (discordChannelTable != null) //{ // // Channel Moderator // if (discordChannelTable.DiscordChannelModerators.Any(a => a.Type == DiscordChannelModeratorType.Role && guildUser.RoleIds.Contains(a.Value) || // a.Type == DiscordChannelModeratorType.User && a.Value == context.User.Id)) // currentUserPermission = RequiredPermission.ChannelModerator; // // Guild Moderator // if (discordChannelTable.DiscordGuild.DiscordGuildModerators.Any(a => a.Type == DiscordGuildModeratorType.Role && guildUser.RoleIds.Contains(a.Value) || // a.Type == DiscordGuildModeratorType.User && a.Value == context.User.Id)) // currentUserPermission = RequiredPermission.GuildModerator; // // Guild Administrator // if (guildUser.GuildPermissions.Administrator) // currentUserPermission = RequiredPermission.GuildAdministrator; //} } // Discord App Owner var botOwner = (await context.Client.GetApplicationInfoAsync()).Owner; if (context.Message.Author.Id == botOwner.Id) { currentUserPermission = RequiredPermission.DiscordAppOwner; } else { //var isAnOwner = Enumerable.FirstOrDefault((await databaseContext.DiscordAppTable.Where(a => a.ClientId == context.Client.CurrentUser.Id) // .Select(a => new // { // discordAppOwner = a.DiscordAppOwners.Any(b => b.UserId == context.User.Id) // }).ToListAsync().ConfigureAwait(false)) // .Select(a => a.discordAppOwner)); //if (isAnOwner) // currentUserPermission = RequiredPermission.DiscordAppOwner; } // Global Discord App Owner var isAGlobalOwner = await databaseContext.DiscordAppOwnerTable.Where(a => a.DiscordAppId == null && a.UserId == context.User.Id).AnyAsync().ConfigureAwait(false); if (isAGlobalOwner) { currentUserPermission = RequiredPermission.GlobalDiscordAppOwner; } } return(currentUserPermission >= RequiredPermission?PreconditionResult.FromSuccess() : PreconditionResult.FromError($"This command require {RequiredPermission.ToString()} permission and above.")); }
/// <summary> /// This will check whether or not a user has permissions to use a command/module /// </summary> /// <param name="context">The message context</param> /// <param name="command">The command being invoked</param> /// <param name="services">The service provider</param> /// /// /// <returns> /// A precondition result dictating whether or not the command is allowed to run. /// </returns> public override Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) { if (context.Channel is IDMChannel) { return(Task.FromResult(PreconditionResult.FromError("Administrator permissions are only accessible through a guild."))); } // Check whether or not the user is the Bot owner. var own = context.Client.GetApplicationInfoAsync(); if (own.Result.Owner.Id == context.User.Id) { return(Task.FromResult(PreconditionResult.FromSuccess())); } // If we have allow admin permissions toggled on we allow users who have the permissions in the server var guildUser = context.User as IGuildUser; var guild = services.GetRequiredService <DatabaseHandler>().Execute <GuildModel>(DatabaseHandler.Operation.LOAD, null, context.Guild.Id); if (allowAdministrator && guildUser.GuildPermissions.Administrator) { return(Task.FromResult(PreconditionResult.FromSuccess())); } // check to see if the user has an admin role in the server // Return an error stating the user is not an admin return(Task.FromResult(guild.Moderation.AdminRoleIDs.Any(x => guildUser.RoleIds.Contains(x)) ? PreconditionResult.FromSuccess() : PreconditionResult.FromError("User is Not an Admin!"))); }
public override Task <PreconditionResult> CheckPermissions(ICommandContext context, CommandInfo command, IServiceProvider services) { var config = (Configuration)services.GetService(typeof(Configuration)); return(Task.FromResult((config.Owners.Contains(context.User.Id) || context.Client.CurrentUser.Id == context.User.Id ? PreconditionResult.FromSuccess() : PreconditionResult.FromError("You must be a bot owner to run this command.")))); }
public override async Task <PreconditionResult> CheckPermissions(ICommandContext context, CommandInfo command, IServiceProvider services) { var level = await GetLevel(context, services.GetService <MongoClient>()).ConfigureAwait(false); return(level >= _level?PreconditionResult.FromSuccess() : PreconditionResult.FromError($"Insufficient permissions! Required level: {_level}")); }
public override Task <PreconditionResult> CheckPermissions(IUserMessage context, Command executingCommand, object moduleInstance) => Task.FromResult((FaultyBot.Credentials.IsOwner(context.Author) ? PreconditionResult.FromSuccess() : PreconditionResult.FromError("Not owner")));
// Override the CheckPermissions method public override Task <PreconditionResult> CheckPermissionsAsync(ICommandContext context, CommandInfo command, IServiceProvider services) { var dbContext = services.GetService <BotDbContext>(); var serverId = context?.Guild?.Id; if (serverId == null) { Console.WriteLine("ServerId null"); return(Task.FromResult(PreconditionResult.FromError("Not a whitelisted server"))); } var result = dbContext.Leaderboards.Any(x => x.ServerId == serverId.ToString()) ? PreconditionResult.FromSuccess() : PreconditionResult.FromError("Not a whitelisted server"); Console.WriteLine($"whitelited seerver requirements success - {result.IsSuccess}"); return(Task.FromResult(result)); }