/*public static ulong ResolveChannel(IGuildUser user, IGuildChannel channel)
* {
* return ResolveChannel(user, channel, ResolveGuild(user));
* }*/
public static ulong ResolveChannel(IGuildUser user, IGuildChannel channel, ulong guildPermissions)
{
ulong resolvedPermissions = 0;
ulong mask = ChannelPermissions.All(channel).RawValue;
if (/*user.Id == user.Guild.OwnerId || */ GetValue(guildPermissions, GuildPermission.Administrator))
{
resolvedPermissions = mask; //Owners and administrators always have all permissions
}
else
{
//Start with this user's guild permissions
resolvedPermissions = guildPermissions;
OverwritePermissions?perms;
var roles = user.Roles;
if (roles.Count > 0)
{
ulong deniedPermissions = 0UL, allowedPermissions = 0UL;
foreach (var role in roles)
{
perms = channel.GetPermissionOverwrite(role);
if (perms != null)
{
deniedPermissions |= perms.Value.DenyValue;
allowedPermissions |= perms.Value.AllowValue;
}
}
resolvedPermissions = (resolvedPermissions & ~deniedPermissions) | allowedPermissions;
}
perms = channel.GetPermissionOverwrite(user);
if (perms != null)
{
resolvedPermissions = (resolvedPermissions & ~perms.Value.DenyValue) | perms.Value.AllowValue;
}
//TODO: C#7 Typeswitch candidate
var textChannel = channel as ITextChannel;
var voiceChannel = channel as IVoiceChannel;
if (textChannel != null && !GetValue(resolvedPermissions, ChannelPermission.ReadMessages))
{
resolvedPermissions = 0; //No read permission on a text channel removes all other permissions
}
else if (voiceChannel != null && !GetValue(resolvedPermissions, ChannelPermission.Connect))
{
resolvedPermissions = 0; //No connect permission on a voice channel removes all other permissions
}
resolvedPermissions &= mask; //Ensure we didnt get any permissions this channel doesnt support (from guildPerms, for example)
}
return(resolvedPermissions);
}
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 <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());
}
bool IsPublic(IGuildChannel channel)
{
var permissions = channel.GetPermissionOverwrite(_client.GetGuild(LimitedToGuild).EveryoneRole);
return(!permissions.HasValue ||
(permissions.Value.ViewChannel != PermValue.Deny && permissions.Value.SendMessages != PermValue.Deny));
}
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());
}
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 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 static bool IsPublic(this IGuildChannel channel)
{
if (channel?.Guild is IGuild guild)
{
var permissions = channel.GetPermissionOverwrite(guild.EveryoneRole);
return(!permissions.HasValue || permissions.Value.ViewChannel != PermValue.Deny);
}
return(false);
}
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 + "].");
}
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 Unmute(IGuildUser user, IGuildChannel channel = null)
{
//If there's no specified channel, use the channel the command was sent in
if (channel == null)
{
channel = (ITextChannel)Context.Channel;
}
//Ensure this is a text channel
if (channel == null)
{
await Context.Channel.SendErrorAsync($"{channel.Name} is not a text channel.");
return;
}
//Try and get the perms for teh user
var userPerms = channel.GetPermissionOverwrite(user);
//If there *are* user perms, it's safe to check to unmute them otherwise they aren't muted
if (userPerms == null)
{
await Context.Channel.SendErrorAsync($"{user.NicknameUsername()} is not muted.");
return;
}
//Check to see if they're muted
if (userPerms.Value.SendMessages != PermValue.Deny)
{
await Context.Channel.SendErrorAsync($"{user.NicknameUsername()} is not muted.");
return;
}
//Delete their perms, they're gucci
await channel.RemovePermissionOverwriteAsync(user);
await Context.Channel.SendSuccessAsync($"{user.NicknameUsername()} has been unmuted.");
}
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));
}
/*public static ulong ResolveChannel(IGuildUser user, IGuildChannel channel)
* {
* return ResolveChannel(user, channel, ResolveGuild(user));
* }*/
public static ulong ResolveChannel(IGuild guild, IGuildUser user, IGuildChannel channel, ulong guildPermissions)
{
ulong mask = ChannelPermissions.All(channel).RawValue;
ulong resolvedPermissions;
if (GetValue(guildPermissions, GuildPermission.Administrator)) //Includes owner
{
resolvedPermissions = mask; //Owners and administrators always have all permissions
}
else
{
//Start with this user's guild permissions
resolvedPermissions = guildPermissions;
//Give/Take Everyone permissions
var perms = channel.GetPermissionOverwrite(guild.EveryoneRole);
if (perms != null)
{
resolvedPermissions = (resolvedPermissions & ~perms.Value.DenyValue) | perms.Value.AllowValue;
}
//Give/Take Role permissions
ulong deniedPermissions = 0UL, allowedPermissions = 0UL;
foreach (var roleId in user.RoleIds)
{
IRole role;
if (roleId != guild.EveryoneRole.Id && (role = guild.GetRole(roleId)) != null)
{
perms = channel.GetPermissionOverwrite(role);
if (perms != null)
{
allowedPermissions |= perms.Value.AllowValue;
deniedPermissions |= perms.Value.DenyValue;
}
}
}
resolvedPermissions = (resolvedPermissions & ~deniedPermissions) | allowedPermissions;
//Give/Take User permissions
perms = channel.GetPermissionOverwrite(user);
if (perms != null)
{
resolvedPermissions = (resolvedPermissions & ~perms.Value.DenyValue) | perms.Value.AllowValue;
}
if (channel is ITextChannel)
{
if (!GetValue(resolvedPermissions, ChannelPermission.ViewChannel))
{
//No read permission on a text channel removes all other permissions
resolvedPermissions = 0;
}
else if (!GetValue(resolvedPermissions, ChannelPermission.SendMessages))
{
//No send permissions on a text channel removes all send-related permissions
resolvedPermissions &= ~(ulong)ChannelPermission.SendTTSMessages;
resolvedPermissions &= ~(ulong)ChannelPermission.MentionEveryone;
resolvedPermissions &= ~(ulong)ChannelPermission.EmbedLinks;
resolvedPermissions &= ~(ulong)ChannelPermission.AttachFiles;
}
}
resolvedPermissions &= mask; //Ensure we didn't get any permissions this channel doesn't support (from guildPerms, for example)
}
return(resolvedPermissions);
}
/// <summary> /// Determines wether the supplied user has the manage messages permission. /// </summary> public static bool CanManageMessages(IGuildUser guildUser, IGuildChannel channel) => guildUser?.GuildPermissions.ManageMessages == true && channel?.GetPermissionOverwrite(guildUser)?.ManageMessages != PermValue.Deny;
public static bool TestPermission(this IGuildChannel Channel, ChannelPermission Permission, IRole Role) => Channel.GetPermissionOverwrite(Role)?.ToAllowList().Contains(Permission) ?? false;
