private async Task <ModifyEntityResult> ConfigureDefaultUserRolePermissions ( IGuild guild, IGuildChannel dedicatedChannel ) { var getServer = await _servers.GetOrRegisterServerAsync(guild); if (!getServer.IsSuccess) { return(ModifyEntityResult.FromError(getServer)); } var server = getServer.Entity; var getSettings = await _serverSettings.GetOrCreateServerRoleplaySettingsAsync(server); if (!getSettings.IsSuccess) { return(ModifyEntityResult.FromError(getSettings)); } var settings = getSettings.Entity; var denyView = OverwritePermissions.InheritAll.Modify ( viewChannel: PermValue.Deny, sendMessages: PermValue.Deny, addReactions: PermValue.Deny ); // Configure visibility for everyone // viewChannel starts off as deny, since starting or stopping the RP will set the correct permissions. IRole defaultUserRole; if (settings.DefaultUserRole.HasValue) { var defaultRole = guild.GetRole((ulong)settings.DefaultUserRole.Value); defaultUserRole = defaultRole ?? guild.EveryoneRole; } else { defaultUserRole = guild.EveryoneRole; } await dedicatedChannel.AddPermissionOverwriteAsync(defaultUserRole, denyView); if (defaultUserRole != guild.EveryoneRole) { // Also override @everyone so it can't see anything await dedicatedChannel.AddPermissionOverwriteAsync(guild.EveryoneRole, denyView); } return(ModifyEntityResult.FromSuccess()); }
public async Task <ModifyEntityResult> SetDedicatedChannelWritabilityForUserAsync ( [NotNull] IGuildChannel dedicatedChannel, [NotNull] IUser participant, bool isVisible ) { var permissions = OverwritePermissions.InheritAll; var existingOverwrite = dedicatedChannel.GetPermissionOverwrite(participant); if (!(existingOverwrite is null)) { permissions = existingOverwrite.Value; } permissions = permissions.Modify ( sendMessages: isVisible ? PermValue.Allow : PermValue.Deny, addReactions: isVisible ? PermValue.Allow : PermValue.Deny, embedLinks: isVisible ? PermValue.Allow : PermValue.Deny, attachFiles: isVisible ? PermValue.Allow : PermValue.Deny, useExternalEmojis: isVisible ? PermValue.Allow : PermValue.Deny ); await dedicatedChannel.AddPermissionOverwriteAsync(participant, permissions); // Ugly hack - there seems to be some kind of race condition on Discord's end. await Task.Delay(20); return(ModifyEntityResult.FromSuccess()); }
private async Task AddPermission(IGuildChannel channel, IRole role) { this.Logger.Debug("Adding role {0} to channel {1}", role.Id, channel.Id); await channel.AddPermissionOverwriteAsync(role, TeamPermissions, RequestOptionsSettings.Default); this.Logger.Debug("Added role {0} to channel {1}", role.Id, channel.Id); }
private static async Task ConfigureChannelMuteRolePermissionsAsync(IGuildChannel channel, IRole muteRole) { try { var permissionOverwrite = channel.GetPermissionOverwrite(muteRole); if (permissionOverwrite != null) { var deniedPermissions = permissionOverwrite.GetValueOrDefault().ToDenyList(); if (!_mutePermissions.ToDenyList().Except(deniedPermissions).Any()) { Log.Debug("Skipping setting mute permissions for channel #{Channel} as they're already set.", channel.Name); return; } Log.Debug("Removing permission overwrite for channel #{Channel}.", channel.Name); await channel.RemovePermissionOverwriteAsync(muteRole); } await channel.AddPermissionOverwriteAsync(muteRole, _mutePermissions); Log.Debug("Set mute permissions for role {Role} in channel #{Channel}.", muteRole.Name, channel.Name); } catch (Exception e) { Log.Error(e, "Failed setting channel mute role on #{Channel}", channel.Name); throw; } }
public async Task LockAllChannels() { IRole defaultRole = Context.Guild.EveryoneRole; IReadOnlyCollection <IGuildChannel> guildChannels = await Context.Guild.GetChannelsAsync(); for (int idLoc = 0; idLoc < GlobalConfiguration.LockableChannelIds.Length; idLoc++) { ulong channelId = ulong.Parse(GlobalConfiguration.LockableChannelIds[idLoc]); IGuildChannel channel = guildChannels.FirstOrDefault(c => c.Id == channelId); if (channel != null) { OverwritePermissions permissions = channel.GetPermissionOverwrite(defaultRole) ?? new OverwritePermissions(); permissions = permissions.Modify(sendMessages: PermValue.Inherit, addReactions: PermValue.Inherit); await channel.AddPermissionOverwriteAsync(defaultRole, permissions); } else { _logger.LogWarning(string.Format("Channel '{0}' was not found for locking.", channelId)); } } await ReplyAsync("all the chawnnels hawv bween unlocked~!! uwu p-please reward me.. ///"); _logger.LogInformation(Context.User.ToString() + " unlocked all channels [ " + string.Join(", ", GlobalConfiguration.LockableChannelIds) + " ]."); }
public async Task ShowChannelAsync(IGuildChannel channel) { await channel.AddPermissionOverwriteAsync(Context.User, new OverwritePermissions(readMessages : PermValue.Allow, sendMessages : PermValue.Allow)); await ReplyAsync("Channel hidden."); }
public async Task <ModifyEntityResult> SetDedicatedChannelVisibilityForRoleAsync ( [NotNull] IGuildChannel dedicatedChannel, [NotNull] IRole role, bool isVisible ) { var permissions = OverwritePermissions.InheritAll; var existingOverwrite = dedicatedChannel.GetPermissionOverwrite(role); if (!(existingOverwrite is null)) { permissions = existingOverwrite.Value; } permissions = permissions.Modify ( readMessageHistory: isVisible ? PermValue.Allow : PermValue.Deny, viewChannel: isVisible ? PermValue.Allow : PermValue.Deny ); await dedicatedChannel.AddPermissionOverwriteAsync(role, permissions); // Ugly hack - there seems to be some kind of race condition on Discord's end. await Task.Delay(20); return(ModifyEntityResult.FromSuccess()); }
/// <summary> /// Clears all channel permission overwrites from the given channel. /// </summary> /// <param name="channel">The channel.</param> /// <returns>A modification result which may or may not have succeeded.</returns> private async Task <ModifyEntityResult> ClearChannelPermissionOverwrites(IGuildChannel channel) { var guild = channel.Guild; foreach (var overwrite in channel.PermissionOverwrites) { switch (overwrite.TargetType) { case PermissionTarget.Role: { var role = guild.GetRole(overwrite.TargetId); if (role is null) { continue; } if (role.Id == guild.EveryoneRole.Id) { await channel.AddPermissionOverwriteAsync(role, OverwritePermissions.InheritAll); } else { await channel.RemovePermissionOverwriteAsync(role); } break; } case PermissionTarget.User: { var user = await guild.GetUserAsync(overwrite.TargetId); if (user is null) { continue; } if (user.IsMe(_client)) { continue; } await channel.RemovePermissionOverwriteAsync(user); break; } default: { throw new ArgumentOutOfRangeException(); } } } return(ModifyEntityResult.FromSuccess()); }
public async Task Unlock(IGuildChannel channel, IGuildUser agent) { try { IRole role = channel.Guild.EveryoneRole; var permission = channel.GetPermissionOverwrite(role); if (permission.HasValue && permission.Value.ViewChannel == PermValue.Deny) { await channel.AddPermissionOverwriteAsync(role, new OverwritePermissions(viewChannel : PermValue.Allow)); { var eb = new EmbedBuilder() { Author = new EmbedAuthorBuilder() { IconUrl = $"{agent.GetAvatarUrl()}", Name = $"Channel unlocked" }, Description = $"{agent.Username}#{agent.Discriminator} ({agent.Mention}) unlocked a channel!", Fields = { new EmbedFieldBuilder() { Name = "Perpetrator", Value = $"• **Agent:** {agent.Username}#{agent.Discriminator}\n• **Agent ID:** {agent.Id}", IsInline = false }, new EmbedFieldBuilder() { Name = "Source", Value = $"• **Server:** {agent.Guild.Name}\n• **Channel:** <#{channel.Id}>", IsInline = false } }, Footer = new EmbedFooterBuilder() { Text = $"{DateTime.Now}", }, }; eb.WithColor(Color.Blue); DiscordReply("", eb); await Utils.LogChannel.SendMessageAsync("", false, eb.Build()); } } else { DiscordReply("This channel is already unlocked."); } } catch { Console.WriteLine($"Error while trying to set or remove lockdown on channel."); DiscordReply("Unable to lock this channel down"); } }
public async Task ArchiveChannel([Remainder] IGuildChannel channel) { //First we need to move channel var cat = await Context.Guild.GetCategoriesAsync(); ICategoryChannel category = cat.Where(x => x.Id == 548238743476240405).FirstOrDefault(); if (category == null) { return; } //Move it now await channel.ModifyAsync(x => x.CategoryId = category.Id); //Get role overwrites var everyoneOverwrite = category.GetPermissionOverwrite(Context.Guild.EveryoneRole); var adminOverwrite = category.GetPermissionOverwrite(Context.Guild.GetRole(217696310168518657)); //First remove all perms var curPerms = channel.PermissionOverwrites; foreach (Overwrite ow in curPerms) { if (ow.TargetType == PermissionTarget.Role) { await channel.RemovePermissionOverwriteAsync(Context.Guild.GetRole(ow.TargetId)); } else { await channel.RemovePermissionOverwriteAsync(await Context.Guild.GetUserAsync(ow.TargetId)); } } //Okay now we set perms await channel.AddPermissionOverwriteAsync(Context.Guild.EveryoneRole, everyoneOverwrite.Value); await channel.AddPermissionOverwriteAsync(Context.Guild.GetRole(217696310168518657), adminOverwrite.Value); //Will add an output await Context.Channel.SendSuccessAsync($"The channel {channel.Name} has been archived."); }
public async Task LockModule() { IGuildChannel channel = (IGuildChannel)Context.Channel; PermValue permission = channel.GetPermissionOverwrite(Context.Guild.EveryoneRole)?.SendMessages ?? PermValue.Allow; PermValue flippedPermission = permission == PermValue.Allow ? PermValue.Deny : PermValue.Allow; await ReplyAsync(flippedPermission == PermValue.Allow? "> Channel Has Been Unlocked" : "> Channel Has Been Locked"); await channel.AddPermissionOverwriteAsync(Context.Guild.EveryoneRole, new OverwritePermissions(sendMessages : flippedPermission)); }
public async Task LockCurrentChannel() { IGuildChannel channel = (IGuildChannel)Context.Channel; IRole defaultRole = channel.Guild.EveryoneRole; OverwritePermissions permissions = channel.GetPermissionOverwrite(defaultRole) ?? new OverwritePermissions(); permissions = permissions.Modify(sendMessages: PermValue.Inherit, addReactions: PermValue.Inherit); await channel.AddPermissionOverwriteAsync(defaultRole, permissions); await ReplyAsync("uwu!! #" + channel.Name + " is nyow unlowcked!1! uguuuu yes im so c-c-ccreative"); _logger.LogInformation(Context.User.ToString() + " unlocked channel #" + channel.Name + " [" + channel.Id + "]."); }
public async Task LockCurrentChannel() { IGuildChannel channel = (IGuildChannel)Context.Channel; IRole defaultRole = channel.Guild.EveryoneRole; OverwritePermissions permissions = channel.GetPermissionOverwrite(defaultRole) ?? new OverwritePermissions(); permissions = permissions.Modify(sendMessages: PermValue.Deny, addReactions: PermValue.Deny); await channel.AddPermissionOverwriteAsync(defaultRole, permissions); await ReplyAsync("i-i nylocked #" + channel.Name + " f-for you s-s-s-senpai :0 a-are you p-proud??! >//////<"); _logger.LogInformation(Context.User.ToString() + " locked channel #" + channel.Name + " [" + channel.Id + "]."); }
//updates channel permissions when a user joins a voice channel public Task HandleConnect(SocketUser socketUser, ISocketMessageChannel targetChannel) { OverwritePermissions overwrite = new OverwritePermissions(readMessages: PermValue.Allow); IGuildChannel textChannel = (IGuildChannel)targetChannel; textChannel.AddPermissionOverwriteAsync(socketUser, overwrite); EmbedBuilder builder = new EmbedBuilder() { Description = ":speaker: " + socketUser.Mention + " has joined the voice channel", Color = Color.Green, ThumbnailUrl = socketUser.GetAvatarUrl(ImageFormat.Auto, 128) }; targetChannel.SendMessageAsync("", false, builder.Build()); return(Task.CompletedTask); }
//updates channel permissions when a user leaves a voice channel public Task HandleDisconnect(SocketUser socketUser, ISocketMessageChannel targetChannel) { // Don't hide the channel for users that can manage messages if (!((SocketGuildUser)socketUser).GuildPermissions.ManageMessages) { OverwritePermissions overwrite = new OverwritePermissions(readMessages: PermValue.Deny); IGuildChannel textChannel = (IGuildChannel)targetChannel; textChannel.AddPermissionOverwriteAsync(socketUser, overwrite); } EmbedBuilder builder = new EmbedBuilder() { Description = ":mute: " + socketUser.Mention + " has left the voice channel ", Color = Color.Orange, ThumbnailUrl = socketUser.GetAvatarUrl(ImageFormat.Auto, 128) }; targetChannel.SendMessageAsync("", false, builder.Build()); return(Task.CompletedTask); }
private async Task ConfigureChannelMuteRolePermissionsAsync(IGuildChannel channel, IRole muteRole) { var permissionOverwrite = channel.GetPermissionOverwrite(muteRole); if (permissionOverwrite != null) { if ((permissionOverwrite.Value.AllowValue == _mutePermissions.AllowValue) && (permissionOverwrite.Value.DenyValue == _mutePermissions.DenyValue)) { Log.Debug("Skipping setting mute permissions for channel #{Channel} as they're already set.", channel.Name); return; } Log.Debug("Removing permission overwrite for channel #{Channel}.", channel.Name); await channel.RemovePermissionOverwriteAsync(muteRole); } await channel.AddPermissionOverwriteAsync(muteRole, _mutePermissions); Log.Debug("Set mute permissions for role {Role} in channel #{Channel}.", muteRole.Name, channel.Name); }
public async Task MuteUserAsync(IGuildUser user, IGuildChannel channel) { if (user == null) { throw new ArgumentNullException(nameof(user)); } if (channel == null) { throw new ArgumentNullException(nameof(channel)); } // Fetches the previous overwrite and bail if one is found var previousOverwrite = channel.GetPermissionOverwrite(user); if (previousOverwrite.HasValue && previousOverwrite.Value.SendMessages == PermValue.Deny) { throw new InvalidOperationException($"User {user.Username} had already been muted in this channel."); } // Creates a new OverwritePermissions with send message set to deny and pass it into the method await channel.AddPermissionOverwriteAsync(user, new OverwritePermissions(sendMessages : PermValue.Deny)); }