/*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);
}
public void ChannelTypeResolution_Invalid()
{
Assert.Throws <ArgumentException>(() => ChannelPermissions.All(new MockedInvalidChannel()));
}
public void ChannelTypeResolution_DM()
{
Assert.Equal(ChannelPermissions.DM.RawValue, ChannelPermissions.All(new MockedDMChannel()).RawValue);
}
public void ChannelTypeResolution_Group()
{
Assert.Equal(ChannelPermissions.Group.RawValue, ChannelPermissions.All(new MockedGroupChannel()).RawValue);
}
public void ChannelTypeResolution_Voice()
{
Assert.Equal(ChannelPermissions.Voice.RawValue, ChannelPermissions.All(new MockedVoiceChannel()).RawValue);
}
public void ChannelTypeResolution_Category()
{
Assert.Equal(ChannelPermissions.Category.RawValue, ChannelPermissions.All(new MockedCategoryChannel()).RawValue);
}
/*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);
}
public void ChannelTypeResolution_Text()
{
Assert.Equal(ChannelPermissions.Text.RawValue, ChannelPermissions.All(new MockedTextChannel()).RawValue);
}
/// <summary> Gets a OverwritePermissions that denies all permissions for a given channelType. </summary> public static OverwritePermissions DenyAll(IChannel channel) => new OverwritePermissions(0, ChannelPermissions.All(channel).RawValue);
public static ChannelPermissions ToChannelPerms(IGuildChannel channel, ulong guildPermissions) => new ChannelPermissions(guildPermissions & ChannelPermissions.All(channel).RawValue);
/// <summary> Gets a OverwritePermissions that grants all permissions for a given channelType. </summary> public static OverwritePermissions AllowAll(IChannel channel) => new OverwritePermissions(ChannelPermissions.All(channel).RawValue, 0);
internal bool UpdatePermissions(User user, ref ChannelPermissions permissions)
{
uint newPermissions = 0;
var server = Server;
//Load the mask of all permissions supported by this channel type
var mask = ChannelPermissions.All(this).RawValue;
if (server != null)
{
//Start with this user's server permissions
newPermissions = server.GetPermissions(user).RawValue;
if (IsPrivate || user == Server.Owner || newPermissions.HasBit((byte)PermissionBits.Administrator))
{
newPermissions = mask; //Owners and Administrators always have all permissions
}
else
{
var channelOverwrites = PermissionOverwrites;
var roles = user.Roles;
foreach (var denyRole in channelOverwrites.Where(x => x.TargetType == PermissionTarget.Role && x.Permissions.DenyValue != 0 && roles.Any(y => y.Id == x.TargetId)))
{
newPermissions &= ~denyRole.Permissions.DenyValue;
}
foreach (var allowRole in channelOverwrites.Where(x => x.TargetType == PermissionTarget.Role && x.Permissions.AllowValue != 0 && roles.Any(y => y.Id == x.TargetId)))
{
newPermissions |= allowRole.Permissions.AllowValue;
}
foreach (var denyUser in channelOverwrites.Where(x => x.TargetType == PermissionTarget.User && x.TargetId == user.Id && x.Permissions.DenyValue != 0))
{
newPermissions &= ~denyUser.Permissions.DenyValue;
}
foreach (var allowUser in channelOverwrites.Where(x => x.TargetType == PermissionTarget.User && x.TargetId == user.Id && x.Permissions.AllowValue != 0))
{
newPermissions |= allowUser.Permissions.AllowValue;
}
if (Type == ChannelType.Text && !newPermissions.HasBit((byte)PermissionBits.ReadMessages))
{
newPermissions = 0; //No read permission on a text channel removes all other permissions
}
else if (Type == ChannelType.Voice && !newPermissions.HasBit((byte)PermissionBits.Connect))
{
newPermissions = 0; //No connect permissions on a voice channel removes all other permissions
}
else
{
newPermissions &= mask; //Ensure we didnt get any permissions this channel doesnt support (from serverPerms, for example)
}
}
}
else
{
newPermissions = mask; //Private messages always have all permissions
}
if (newPermissions != permissions.RawValue)
{
permissions = new ChannelPermissions(newPermissions);
return(true);
}
return(false);
}
public bool ResolvePermissions(User user, ref ChannelPermissions permissions)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
uint newPermissions = 0;
var server = user.Server;
var mask = ChannelPermissions.All(_channel.Type).RawValue;
if (_channel.IsPrivate || user.IsOwner)
{
newPermissions = mask; //Private messages and owners always have all permissions
}
else
{
//Start with this user's server permissions
newPermissions = server.GetPermissions(user).RawValue;
var rules = _rules;
Channel.PermissionRule rule;
var roles = user.Roles.ToArray();
if (roles.Length > 0)
{
for (int i = 0; i < roles.Length; i++)
{
if (rules.TryGetValue(roles[i].Id, out rule))
{
newPermissions &= ~rule.Permissions.DenyValue;
}
}
for (int i = 0; i < roles.Length; i++)
{
if (rules.TryGetValue(roles[i].Id, out rule))
{
newPermissions |= rule.Permissions.AllowValue;
}
}
}
if (rules.TryGetValue(user.Id, out rule))
{
newPermissions = (newPermissions & ~rule.Permissions.DenyValue) | rule.Permissions.AllowValue;
}
if (newPermissions.HasBit((byte)PermissionBits.ManageRolesOrPermissions))
{
newPermissions = mask; //ManageRolesOrPermissions gives all permisions
}
else if (_channel.IsText && !newPermissions.HasBit((byte)PermissionBits.ReadMessages))
{
newPermissions = 0; //No read permission on a text channel removes all other permissions
}
else if (_channel.IsVoice && !newPermissions.HasBit((byte)PermissionBits.Connect))
{
newPermissions = 0; //No connect permissions on a voice channel removes all other permissions
}
else
{
newPermissions &= mask; //Ensure we didnt get any permissions this channel doesnt support (from serverPerms, for example)
}
}
if (newPermissions != permissions.RawValue)
{
permissions = new ChannelPermissions(newPermissions);
return(true);
}
return(false);
}
internal void UpdateChannelPermissions(Channel channel)
{
var server = Server;
if (server == null)
{
return;
}
if (channel.Server != server)
{
throw new InvalidOperationException();
}
ChannelPermissions permissions;
if (!_permissions.TryGetValue(channel.Id, out permissions))
{
return;
}
uint newPermissions = _serverPermissions.RawValue;
uint oldPermissions = permissions.RawValue;
if (server.Owner == this)
{
newPermissions = ChannelPermissions.All(channel).RawValue;
}
else
{
var channelOverwrites = channel.PermissionOverwrites;
//var roles = Roles.OrderBy(x => x.Id);
var roles = Roles;
foreach (var denyRole in channelOverwrites.Where(x => x.TargetType == PermissionTarget.Role && x.Deny.RawValue != 0 && roles.Any(y => y.Id == x.TargetId)))
{
newPermissions &= ~denyRole.Deny.RawValue;
}
foreach (var allowRole in channelOverwrites.Where(x => x.TargetType == PermissionTarget.Role && x.Allow.RawValue != 0 && roles.Any(y => y.Id == x.TargetId)))
{
newPermissions |= allowRole.Allow.RawValue;
}
foreach (var denyUser in channelOverwrites.Where(x => x.TargetType == PermissionTarget.User && x.TargetId == Id && x.Deny.RawValue != 0))
{
newPermissions &= ~denyUser.Deny.RawValue;
}
foreach (var allowUser in channelOverwrites.Where(x => x.TargetType == PermissionTarget.User && x.TargetId == Id && x.Allow.RawValue != 0))
{
newPermissions |= allowUser.Allow.RawValue;
}
}
var mask = ChannelPermissions.All(channel).RawValue;
if (BitHelper.GetBit(newPermissions, (int)PermissionsBits.ManageRolesOrPermissions))
{
newPermissions = ChannelPermissions.All(channel).RawValue;
}
else
{
newPermissions &= mask;
}
if (newPermissions != oldPermissions)
{
permissions.SetRawValueInternal(newPermissions);
channel.InvalidateMembersCache();
}
permissions.SetRawValueInternal(newPermissions);
}
internal void UpdatePermissions(User user, ChannelPermissions permissions)
{
uint newPermissions = 0;
var server = Server;
//Load the mask of all permissions supported by this channel type
var mask = ChannelPermissions.All(this).RawValue;
if (server != null)
{
//Start with this user's server permissions
newPermissions = server.GetPermissions(user).RawValue;
if (IsPrivate || user == Server.Owner)
{
newPermissions = mask; //Owners always have all permissions
}
else
{
var channelOverwrites = PermissionOverwrites;
var roles = user.Roles;
foreach (var denyRole in channelOverwrites.Where(x => x.TargetType == PermissionTarget.Role && x.Permissions.Deny.RawValue != 0 && roles.Any(y => y.Id == x.TargetId)))
{
newPermissions &= ~denyRole.Permissions.Deny.RawValue;
}
foreach (var allowRole in channelOverwrites.Where(x => x.TargetType == PermissionTarget.Role && x.Permissions.Allow.RawValue != 0 && roles.Any(y => y.Id == x.TargetId)))
{
newPermissions |= allowRole.Permissions.Allow.RawValue;
}
foreach (var denyUser in channelOverwrites.Where(x => x.TargetType == PermissionTarget.User && x.TargetId == Id && x.Permissions.Deny.RawValue != 0))
{
newPermissions &= ~denyUser.Permissions.Deny.RawValue;
}
foreach (var allowUser in channelOverwrites.Where(x => x.TargetType == PermissionTarget.User && x.TargetId == Id && x.Permissions.Allow.RawValue != 0))
{
newPermissions |= allowUser.Permissions.Allow.RawValue;
}
if (newPermissions.HasBit((byte)PermissionsBits.ManageRolesOrPermissions))
{
newPermissions = mask; //ManageRolesOrPermissions gives all permisions
}
else if (Type == ChannelType.Text && !newPermissions.HasBit((byte)PermissionsBits.ReadMessages))
{
newPermissions = 0; //No read permission on a text channel removes all other permissions
}
else
{
newPermissions &= mask; //Ensure we didnt get any permissions this channel doesnt support (from serverPerms, for example)
}
}
}
else
{
newPermissions = mask; //Private messages always have all permissions
}
if (newPermissions != permissions.RawValue)
{
permissions.SetRawValueInternal(newPermissions);
}
}
