public void Modify()
{
// asserts that a channel permission flag value can be checked
// and that modify can set and unset each flag
// and that ToList performs as expected
void AssertUtil(ChannelPermission permission,
Func <ChannelPermissions, bool> has,
Func <ChannelPermissions, bool, ChannelPermissions> modify)
{
var perm = new ChannelPermissions();
// ensure permission initially false
// use both the function and Has to ensure that the GetPermission
// function is working
Assert.False(has(perm));
Assert.False(perm.Has(permission));
// enable it, and ensure that it gets set
perm = modify(perm, true);
Assert.True(has(perm));
Assert.True(perm.Has(permission));
// check ToList behavior
var list = perm.ToList();
Assert.Contains(permission, list);
Assert.Single(list);
// set it false again
perm = modify(perm, false);
Assert.False(has(perm));
Assert.False(perm.Has(permission));
// ensure that no perms are set now
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
}
AssertUtil(ChannelPermission.CreateInstantInvite, x => x.CreateInstantInvite, (p, enable) => p.Modify(createInstantInvite: enable));
AssertUtil(ChannelPermission.ManageChannels, x => x.ManageChannel, (p, enable) => p.Modify(manageChannel: enable));
AssertUtil(ChannelPermission.AddReactions, x => x.AddReactions, (p, enable) => p.Modify(addReactions: enable));
AssertUtil(ChannelPermission.ViewChannel, x => x.ViewChannel, (p, enable) => p.Modify(viewChannel: enable));
AssertUtil(ChannelPermission.SendMessages, x => x.SendMessages, (p, enable) => p.Modify(sendMessages: enable));
AssertUtil(ChannelPermission.SendTTSMessages, x => x.SendTTSMessages, (p, enable) => p.Modify(sendTTSMessages: enable));
AssertUtil(ChannelPermission.ManageMessages, x => x.ManageMessages, (p, enable) => p.Modify(manageMessages: enable));
AssertUtil(ChannelPermission.EmbedLinks, x => x.EmbedLinks, (p, enable) => p.Modify(embedLinks: enable));
AssertUtil(ChannelPermission.AttachFiles, x => x.AttachFiles, (p, enable) => p.Modify(attachFiles: enable));
AssertUtil(ChannelPermission.ReadMessageHistory, x => x.ReadMessageHistory, (p, enable) => p.Modify(readMessageHistory: enable));
AssertUtil(ChannelPermission.MentionEveryone, x => x.MentionEveryone, (p, enable) => p.Modify(mentionEveryone: enable));
AssertUtil(ChannelPermission.UseExternalEmojis, x => x.UseExternalEmojis, (p, enable) => p.Modify(useExternalEmojis: enable));
AssertUtil(ChannelPermission.Connect, x => x.Connect, (p, enable) => p.Modify(connect: enable));
AssertUtil(ChannelPermission.Speak, x => x.Speak, (p, enable) => p.Modify(speak: enable));
AssertUtil(ChannelPermission.MuteMembers, x => x.MuteMembers, (p, enable) => p.Modify(muteMembers: enable));
AssertUtil(ChannelPermission.DeafenMembers, x => x.DeafenMembers, (p, enable) => p.Modify(deafenMembers: enable));
AssertUtil(ChannelPermission.MoveMembers, x => x.MoveMembers, (p, enable) => p.Modify(moveMembers: enable));
AssertUtil(ChannelPermission.UseVAD, x => x.UseVAD, (p, enable) => p.Modify(useVoiceActivation: enable));
AssertUtil(ChannelPermission.ManageRoles, x => x.ManageRoles, (p, enable) => p.Modify(manageRoles: enable));
AssertUtil(ChannelPermission.ManageWebhooks, x => x.ManageWebhooks, (p, enable) => p.Modify(manageWebhooks: enable));
AssertUtil(ChannelPermission.PrioritySpeaker, x => x.PrioritySpeaker, (p, enable) => p.Modify(prioritySpeaker: enable));
AssertUtil(ChannelPermission.Stream, x => x.Stream, (p, enable) => p.Modify(stream: enable));
}
public void RawValueConstructor()
{
// returns all of the values that will be tested
// a Theory cannot be used here, because these values are not all constants
IEnumerable <ulong> GetTestValues()
{
yield return(0);
yield return(ChannelPermissions.Category.RawValue);
yield return(ChannelPermissions.DM.RawValue);
yield return(ChannelPermissions.Group.RawValue);
yield return(ChannelPermissions.None.RawValue);
yield return(ChannelPermissions.Text.RawValue);
yield return(ChannelPermissions.Voice.RawValue);
};
foreach (var rawValue in GetTestValues())
{
var p = new ChannelPermissions(rawValue);
Assert.Equal(rawValue, p.RawValue);
}
}
public ChannelPermissions(ChannelPermissions basePerms, bool?createInstantInvite = null, bool?managePermissions = null,
bool?manageChannel = null, bool?readMessages = null, bool?sendMessages = null, bool?sendTTSMessages = null,
bool?manageMessages = null, bool?embedLinks = null, bool?attachFiles = null, bool?readMessageHistory = null,
bool?mentionEveryone = null, bool?connect = null, bool?speak = null, bool?muteMembers = null, bool?deafenMembers = null,
bool?moveMembers = null, bool?useVoiceActivation = null)
{
uint value = basePerms.RawValue;
PermissionsHelper.SetValue(ref value, createInstantInvite, PermissionBits.CreateInstantInvite);
PermissionsHelper.SetValue(ref value, managePermissions, PermissionBits.ManageRolesOrPermissions);
PermissionsHelper.SetValue(ref value, manageChannel, PermissionBits.ManageChannel);
PermissionsHelper.SetValue(ref value, readMessages, PermissionBits.ReadMessages);
PermissionsHelper.SetValue(ref value, sendMessages, PermissionBits.SendMessages);
PermissionsHelper.SetValue(ref value, sendTTSMessages, PermissionBits.SendTTSMessages);
PermissionsHelper.SetValue(ref value, manageMessages, PermissionBits.ManageMessages);
PermissionsHelper.SetValue(ref value, embedLinks, PermissionBits.EmbedLinks);
PermissionsHelper.SetValue(ref value, attachFiles, PermissionBits.AttachFiles);
PermissionsHelper.SetValue(ref value, readMessageHistory, PermissionBits.ReadMessageHistory);
PermissionsHelper.SetValue(ref value, mentionEveryone, PermissionBits.MentionEveryone);
PermissionsHelper.SetValue(ref value, connect, PermissionBits.Connect);
PermissionsHelper.SetValue(ref value, speak, PermissionBits.Speak);
PermissionsHelper.SetValue(ref value, muteMembers, PermissionBits.MuteMembers);
PermissionsHelper.SetValue(ref value, deafenMembers, PermissionBits.DeafenMembers);
PermissionsHelper.SetValue(ref value, moveMembers, PermissionBits.MoveMembers);
PermissionsHelper.SetValue(ref value, useVoiceActivation, PermissionBits.UseVoiceActivation);
RawValue = value;
}
public void TestChannelTypeResolution()
{
ITextChannel someChannel = null;
// null channels will throw exception
Assert.Throws <ArgumentException>(() => ChannelPermissions.All(someChannel));
}
public void DefaultConstructor()
{
var permission = new ChannelPermissions();
Assert.Equal((ulong)0, permission.RawValue);
Assert.Equal(ChannelPermissions.None.RawValue, permission.RawValue);
}
public ChannelPermissions GetPermissions(User user)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (_users != null)
{
Member member;
if (_users.TryGetValue(user.Id, out member))
{
return(member.Permissions);
}
else
{
return(ChannelPermissions.None);
}
}
else
{
ChannelPermissions perms = new ChannelPermissions();
ResolvePermissions(user, ref perms);
return(perms);
}
}
public void ChannelTypeResolution_Null()
{
Assert.Throws <ArgumentException>(() =>
{
ChannelPermissions.All(null);
});
}
public Task TestChannelTypeResolution()
{
ITextChannel someChannel = null;
// null channels will throw exception
Assert.Throws <ArgumentException>(() => ChannelPermissions.All(someChannel));
return(Task.CompletedTask);
}
public Task SetChannelPermissions(Channel channel, Role role, ChannelPermissions allow = null, ChannelPermissions deny = null)
{
if (channel == null) throw new ArgumentNullException(nameof(channel));
if (role == null) throw new ArgumentNullException(nameof(role));
CheckReady();
return SetChannelPermissions(channel, role?.Id, PermissionTarget.Role, allow, deny);
}
public Task SetChannelPermissions(Channel channel, User user, ChannelPermissions allow = null, ChannelPermissions deny = null)
{
if (channel == null) throw new ArgumentNullException(nameof(channel));
if (user == null) throw new ArgumentNullException(nameof(user));
CheckReady();
return SetChannelPermissions(channel, user?.Id, PermissionTarget.User, allow, deny);
}
public Task AddPermissionsRule(Role role, ChannelPermissions allow, ChannelPermissions deny)
{
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
return(AddPermissionsRule(role.Id, PermissionTarget.Role, allow.RawValue, deny.RawValue));
}
internal PermissionOverwrite(PermissionTarget targetType, string targetId, uint allow, uint deny)
{
TargetType = targetType;
TargetId = targetId;
Allow = new ChannelPermissions(allow);
Allow.Lock();
Deny = new ChannelPermissions(deny);
Deny.Lock();
}
internal PermissionOverwrite(PermissionTarget targetType, string targetId, uint allow, uint deny)
{
TargetType = targetType;
TargetId = targetId;
Allow = new ChannelPermissions(allow);
Allow.Lock();
Deny = new ChannelPermissions(deny);
Deny.Lock();
}
public Task AddPermissionsRule(User user, ChannelPermissions allow, ChannelPermissions deny)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
return(AddPermissionsRule(user.Id, PermissionTarget.User, allow.RawValue, deny.RawValue));
}
internal void AddChannel(Channel channel)
{
if (_server.Id != null)
{
var perms = new ChannelPermissions();
perms.Lock();
_channels.TryAdd(channel.Id, channel);
_permissions.TryAdd(channel.Id, perms);
UpdateChannelPermissions(channel);
}
}
public Task TestChannelPermissionModify()
{
// test that channel permissions could be modified correctly
var perm = new ChannelPermissions();
void Check(ChannelPermission permission,
Func <ChannelPermissions, bool> has,
Func <ChannelPermissions, bool, ChannelPermissions> modify)
{
// ensure permission initially false
// use both the function and Has to ensure that the GetPermission
// function is working
Assert.False(has(perm));
Assert.False(perm.Has(permission));
// enable it, and ensure that it gets set
perm = modify(perm, true);
Assert.True(has(perm));
Assert.True(perm.Has(permission));
// set it false again
perm = modify(perm, false);
Assert.False(has(perm));
Assert.False(perm.Has(permission));
// ensure that no perms are set now
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
}
Check(ChannelPermission.CreateInstantInvite, x => x.CreateInstantInvite, (p, enable) => p.Modify(createInstantInvite: enable));
Check(ChannelPermission.ManageChannels, x => x.ManageChannel, (p, enable) => p.Modify(manageChannel: enable));
Check(ChannelPermission.AddReactions, x => x.AddReactions, (p, enable) => p.Modify(addReactions: enable));
Check(ChannelPermission.ViewChannel, x => x.ViewChannel, (p, enable) => p.Modify(viewChannel: enable));
Check(ChannelPermission.SendMessages, x => x.SendMessages, (p, enable) => p.Modify(sendMessages: enable));
Check(ChannelPermission.SendTTSMessages, x => x.SendTTSMessages, (p, enable) => p.Modify(sendTTSMessages: enable));
Check(ChannelPermission.ManageMessages, x => x.ManageMessages, (p, enable) => p.Modify(manageMessages: enable));
Check(ChannelPermission.EmbedLinks, x => x.EmbedLinks, (p, enable) => p.Modify(embedLinks: enable));
Check(ChannelPermission.AttachFiles, x => x.AttachFiles, (p, enable) => p.Modify(attachFiles: enable));
Check(ChannelPermission.ReadMessageHistory, x => x.ReadMessageHistory, (p, enable) => p.Modify(readMessageHistory: enable));
Check(ChannelPermission.MentionEveryone, x => x.MentionEveryone, (p, enable) => p.Modify(mentionEveryone: enable));
Check(ChannelPermission.UseExternalEmojis, x => x.UseExternalEmojis, (p, enable) => p.Modify(useExternalEmojis: enable));
Check(ChannelPermission.Connect, x => x.Connect, (p, enable) => p.Modify(connect: enable));
Check(ChannelPermission.Speak, x => x.Speak, (p, enable) => p.Modify(speak: enable));
Check(ChannelPermission.MuteMembers, x => x.MuteMembers, (p, enable) => p.Modify(muteMembers: enable));
Check(ChannelPermission.DeafenMembers, x => x.DeafenMembers, (p, enable) => p.Modify(deafenMembers: enable));
Check(ChannelPermission.MoveMembers, x => x.MoveMembers, (p, enable) => p.Modify(moveMembers: enable));
Check(ChannelPermission.UseVAD, x => x.UseVAD, (p, enable) => p.Modify(useVoiceActivation: enable));
Check(ChannelPermission.ManageRoles, x => x.ManageRoles, (p, enable) => p.Modify(manageRoles: enable));
Check(ChannelPermission.ManageWebhooks, x => x.ManageWebhooks, (p, enable) => p.Modify(manageWebhooks: enable));
Check(ChannelPermission.PrioritySpeaker, x => x.PrioritySpeaker, (p, enable) => p.Modify(prioritySpeaker: enable));
return(Task.CompletedTask);
}
private Task AddPermissionsRule(ulong targetId, PermissionTarget targetType, ChannelPermissions allow = null, ChannelPermissions deny = null)
{
var request = new AddChannelPermissionsRequest(Id)
{
TargetId = targetId,
TargetType = targetType.Value,
Allow = allow?.RawValue ?? 0,
Deny = deny?.RawValue ?? 0
};
return(Client.ClientAPI.Send(request));
}
/*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 Task SetChannelPermissions(Channel channel, Role role, ChannelPermissions allow = null, ChannelPermissions deny = null)
{
if (channel == null)
{
throw new ArgumentNullException(nameof(channel));
}
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
CheckReady();
return(SetChannelPermissions(channel, role?.Id, PermissionTarget.Role, allow, deny));
}
internal void AddUser(User user)
{
if (!Client.Config.UsePermissionsCache)
{
return;
}
var perms = new ChannelPermissions();
UpdatePermissions(user, ref perms);
var member = new Member(user, ChannelPermissions.None);
_users[user.Id] = new Member(user, ChannelPermissions.None);
}
public Task SetChannelPermissions(Channel channel, User user, ChannelPermissions allow = null, ChannelPermissions deny = null)
{
if (channel == null)
{
throw new ArgumentNullException(nameof(channel));
}
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
CheckReady();
return(SetChannelPermissions(channel, user?.Id, PermissionTarget.User, allow, deny));
}
public void AddUser(User user)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (_users != null)
{
var perms = new ChannelPermissions();
ResolvePermissions(user, ref perms);
var member = new Member(user, ChannelPermissions.None);
_users[user.Id] = new Member(user, ChannelPermissions.None);
}
}
internal ChannelPermissions GetPermissions(User user)
{
if (Client.Config.UsePermissionsCache)
{
Member member;
if (_users.TryGetValue(user.Id, out member))
{
return(member.Permissions);
}
else
{
return(ChannelPermissions.None);
}
}
else
{
ChannelPermissions perms = new ChannelPermissions();
UpdatePermissions(user, ref perms);
return(perms);
}
}
public User GetUser(ulong id)
{
if (IsPrivate)
{
if (id == Recipient.Id)
{
return(Recipient);
}
else if (id == Client.PrivateUser.Id)
{
return(Client.PrivateUser);
}
}
else if (!Client.Config.UsePermissionsCache)
{
var user = Server.GetUser(id);
if (user != null)
{
ChannelPermissions perms = new ChannelPermissions();
UpdatePermissions(user, ref perms);
if (perms.ReadMessages)
{
return(user);
}
}
}
else
{
Member result;
if (_users.TryGetValue(id, out result))
{
return(result.User);
}
}
return(null);
}
public void ChannelTypeResolution_Voice()
{
Assert.Equal(ChannelPermissions.Voice.RawValue, ChannelPermissions.All(new MockedVoiceChannel()).RawValue);
}
public Member(User user, ChannelPermissions permissions)
{
User = user;
Permissions = permissions;
}
public void ChannelTypeResolution_Text()
{
Assert.Equal(ChannelPermissions.Text.RawValue, ChannelPermissions.All(new MockedTextChannel()).RawValue);
}
private Task SetChannelPermissions(Channel channel, string targetId, PermissionTarget targetType, ChannelPermissions allow = null, ChannelPermissions deny = null) => _api.SetChannelPermissions(channel.Id, targetId, targetType.Value, allow?.RawValue ?? 0, deny?.RawValue ?? 0);
internal void AddUser(User user)
{
if (!Client.Config.UsePermissionsCache) return;
var perms = new ChannelPermissions();
UpdatePermissions(user, ref perms);
var member = new Member(user, ChannelPermissions.None);
_users[user.Id] = new Member(user, ChannelPermissions.None);
}
public static ChannelPermissions ToChannelPerms(IGuildChannel channel, ulong guildPermissions) => new ChannelPermissions(guildPermissions & ChannelPermissions.All(channel).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 Task TestChannelPermissionModify()
{
// test channel permission modify
var perm = new ChannelPermissions();
// ensure that the permission is initially false
Assert.False(perm.CreateInstantInvite);
// ensure that when modified it works
perm = perm.Modify(createInstantInvite: true);
Assert.True(perm.CreateInstantInvite);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.CreateInstantInvite);
// set false again, move on to next permission
perm = perm.Modify(createInstantInvite: false);
Assert.False(perm.CreateInstantInvite);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.ManageChannel);
perm = perm.Modify(manageChannel: true);
Assert.True(perm.ManageChannel);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.ManageChannels);
perm = perm.Modify(manageChannel: false);
Assert.False(perm.ManageChannel);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.AddReactions);
perm = perm.Modify(addReactions: true);
Assert.True(perm.AddReactions);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.AddReactions);
perm = perm.Modify(addReactions: false);
Assert.False(perm.AddReactions);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.ViewChannel);
perm = perm.Modify(viewChannel: true);
Assert.True(perm.ViewChannel);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.ViewChannel);
perm = perm.Modify(viewChannel: false);
Assert.False(perm.ViewChannel);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.SendMessages);
perm = perm.Modify(sendMessages: true);
Assert.True(perm.SendMessages);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.SendMessages);
perm = perm.Modify(sendMessages: false);
Assert.False(perm.SendMessages);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.SendTTSMessages);
perm = perm.Modify(sendTTSMessages: true);
Assert.True(perm.SendTTSMessages);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.SendTTSMessages);
perm = perm.Modify(sendTTSMessages: false);
Assert.False(perm.SendTTSMessages);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.ManageMessages);
perm = perm.Modify(manageMessages: true);
Assert.True(perm.ManageMessages);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.ManageMessages);
perm = perm.Modify(manageMessages: false);
Assert.False(perm.ManageMessages);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.EmbedLinks);
perm = perm.Modify(embedLinks: true);
Assert.True(perm.EmbedLinks);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.EmbedLinks);
perm = perm.Modify(embedLinks: false);
Assert.False(perm.EmbedLinks);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.AttachFiles);
perm = perm.Modify(attachFiles: true);
Assert.True(perm.AttachFiles);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.AttachFiles);
perm = perm.Modify(attachFiles: false);
Assert.False(perm.AttachFiles);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.ReadMessageHistory);
perm = perm.Modify(readMessageHistory: true);
Assert.True(perm.ReadMessageHistory);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.ReadMessageHistory);
perm = perm.Modify(readMessageHistory: false);
Assert.False(perm.ReadMessageHistory);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.MentionEveryone);
perm = perm.Modify(mentionEveryone: true);
Assert.True(perm.MentionEveryone);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.MentionEveryone);
perm = perm.Modify(mentionEveryone: false);
Assert.False(perm.MentionEveryone);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.UseExternalEmojis);
perm = perm.Modify(useExternalEmojis: true);
Assert.True(perm.UseExternalEmojis);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.UseExternalEmojis);
perm = perm.Modify(useExternalEmojis: false);
Assert.False(perm.UseExternalEmojis);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.Connect);
perm = perm.Modify(connect: true);
Assert.True(perm.Connect);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.Connect);
perm = perm.Modify(connect: false);
Assert.False(perm.Connect);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.Speak);
perm = perm.Modify(speak: true);
Assert.True(perm.Speak);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.Speak);
perm = perm.Modify(speak: false);
Assert.False(perm.Speak);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.MuteMembers);
perm = perm.Modify(muteMembers: true);
Assert.True(perm.MuteMembers);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.MuteMembers);
perm = perm.Modify(muteMembers: false);
Assert.False(perm.MuteMembers);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.DeafenMembers);
perm = perm.Modify(deafenMembers: true);
Assert.True(perm.DeafenMembers);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.DeafenMembers);
perm = perm.Modify(deafenMembers: false);
Assert.False(perm.DeafenMembers);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.MoveMembers);
perm = perm.Modify(moveMembers: true);
Assert.True(perm.MoveMembers);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.MoveMembers);
perm = perm.Modify(moveMembers: false);
Assert.False(perm.MoveMembers);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.UseVAD);
perm = perm.Modify(useVoiceActivation: true);
Assert.True(perm.UseVAD);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.UseVAD);
perm = perm.Modify(useVoiceActivation: false);
Assert.False(perm.UseVAD);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.ManageRoles);
perm = perm.Modify(manageRoles: true);
Assert.True(perm.ManageRoles);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.ManageRoles);
perm = perm.Modify(manageRoles: false);
Assert.False(perm.ManageRoles);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
// individual permission test
Assert.False(perm.ManageWebhooks);
perm = perm.Modify(manageWebhooks: true);
Assert.True(perm.ManageWebhooks);
Assert.Equal(perm.RawValue, (ulong)ChannelPermission.ManageWebhooks);
perm = perm.Modify(manageWebhooks: false);
Assert.False(perm.ManageWebhooks);
Assert.Equal(ChannelPermissions.None.RawValue, perm.RawValue);
return(Task.CompletedTask);
}
public DualChannelPermissions(uint allow = 0, uint deny = 0)
{
Allow = new ChannelPermissions(allow);
Deny = new ChannelPermissions(deny);
}
public void ChannelTypeResolution_Group()
{
Assert.Equal(ChannelPermissions.Group.RawValue, ChannelPermissions.All(new MockedGroupChannel()).RawValue);
}
public void ChannelTypeResolution_Category()
{
Assert.Equal(ChannelPermissions.Category.RawValue, ChannelPermissions.All(new MockedCategoryChannel()).RawValue);
}
public ChannelPermissions(ChannelPermissions basePerms, bool? createInstantInvite = null,
bool? manageChannel = null, bool? readMessages = null, bool? sendMessages = null, bool? sendTTSMessages = null,
bool? manageMessages = null, bool? embedLinks = null, bool? attachFiles = null, bool? readMessageHistory = null,
bool? mentionEveryone = null, bool? connect = null, bool? speak = null, bool? muteMembers = null, bool? deafenMembers = null,
bool? moveMembers = null, bool? useVoiceActivation = null, bool? managePermissions = null)
{
uint value = basePerms.RawValue;
PermissionsHelper.SetValue(ref value, createInstantInvite, PermissionBits.CreateInstantInvite);
PermissionsHelper.SetValue(ref value, manageChannel, PermissionBits.ManageChannel);
PermissionsHelper.SetValue(ref value, readMessages, PermissionBits.ReadMessages);
PermissionsHelper.SetValue(ref value, sendMessages, PermissionBits.SendMessages);
PermissionsHelper.SetValue(ref value, sendTTSMessages, PermissionBits.SendTTSMessages);
PermissionsHelper.SetValue(ref value, manageMessages, PermissionBits.ManageMessages);
PermissionsHelper.SetValue(ref value, embedLinks, PermissionBits.EmbedLinks);
PermissionsHelper.SetValue(ref value, attachFiles, PermissionBits.AttachFiles);
PermissionsHelper.SetValue(ref value, readMessageHistory, PermissionBits.ReadMessageHistory);
PermissionsHelper.SetValue(ref value, mentionEveryone, PermissionBits.MentionEveryone);
PermissionsHelper.SetValue(ref value, connect, PermissionBits.Connect);
PermissionsHelper.SetValue(ref value, speak, PermissionBits.Speak);
PermissionsHelper.SetValue(ref value, muteMembers, PermissionBits.MuteMembers);
PermissionsHelper.SetValue(ref value, deafenMembers, PermissionBits.DeafenMembers);
PermissionsHelper.SetValue(ref value, moveMembers, PermissionBits.MoveMembers);
PermissionsHelper.SetValue(ref value, useVoiceActivation, PermissionBits.UseVoiceActivation);
PermissionsHelper.SetValue(ref value, managePermissions, PermissionBits.ManageRolesOrPermissions);
RawValue = value;
}
public User GetUser(ulong id)
{
if (!Client.Config.UsePermissionsCache)
{
if (Server != null)
{
var user = Server.GetUser(id);
if (user != null)
{
ChannelPermissions perms = new ChannelPermissions();
UpdatePermissions(user, perms);
if (perms.ReadMessages)
return user;
}
}
else
{
if (id == Recipient.Id)
return Recipient;
else if (id == Client.PrivateUser.Id)
return Client.PrivateUser;
}
return null;
}
Member result;
_users.TryGetValue(id, out result);
return result.User;
}
private Task AddPermissionsRule(ulong targetId, PermissionTarget targetType, ChannelPermissions allow = null, ChannelPermissions deny = null)
{
var request = new AddChannelPermissionsRequest(Id)
{
TargetId = targetId,
TargetType = targetType.Value,
Allow = allow?.RawValue ?? 0,
Deny = deny?.RawValue ?? 0
};
return Client.ClientAPI.Send(request);
}
public Task AddPermissionsRule(Role role, ChannelPermissions allow = null, ChannelPermissions deny = null)
{
if (role == null) throw new ArgumentNullException(nameof(role));
return AddPermissionsRule(role.Id, PermissionTarget.Role, allow, deny);
}
public Task AddPermissionsRule(User user, ChannelPermissions allow = null, ChannelPermissions deny = null)
{
if (user == null) throw new ArgumentNullException(nameof(user));
return AddPermissionsRule(user.Id, PermissionTarget.User, allow, deny);
}
public void ChannelTypeResolution_DM()
{
Assert.Equal(ChannelPermissions.DM.RawValue, ChannelPermissions.All(new MockedDMChannel()).RawValue);
}
public Member(User user)
{
User = user;
Permissions = new ChannelPermissions();
Permissions.Lock();
}
public void ChannelTypeResolution_Invalid()
{
Assert.Throws <ArgumentException>(() => ChannelPermissions.All(new MockedInvalidChannel()));
}
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 == user.Id && x.Permissions.Deny.RawValue != 0))
newPermissions &= ~denyUser.Permissions.Deny.RawValue;
foreach (var allowUser in channelOverwrites.Where(x => x.TargetType == PermissionTarget.User && x.TargetId == user.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 if (Type == ChannelType.Voice && !newPermissions.HasBit((byte)PermissionsBits.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.SetRawValueInternal(newPermissions);
}
internal ChannelPermissions GetPermissions(User user)
{
if (Client.Config.UsePermissionsCache)
{
Member member;
if (_users.TryGetValue(user.Id, out member))
return member.Permissions;
else
return null;
}
else
{
ChannelPermissions perms = new ChannelPermissions();
UpdatePermissions(user, perms);
return perms;
}
}
internal void AddChannel(Channel channel)
{
if (_server.Id != null)
{
var perms = new ChannelPermissions();
perms.Lock();
_channels.TryAdd(channel.Id, channel);
_permissions.TryAdd(channel.Id, perms);
UpdateChannelPermissions(channel);
}
}
