Example #1
0
        public ServerPermissions(ServerPermissions basePerms, bool? createInstantInvite = null, bool? administrator = null,
            bool? banMembers = null, bool? kickMembers = null, bool? manageChannel = null, bool? manageServer = 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? changeNickname = null, bool? manageNicknames = null, bool? manageRoles = null)
        {
            uint value = basePerms.RawValue;

            PermissionsHelper.SetValue(ref value, createInstantInvite, PermissionBits.CreateInstantInvite);
            PermissionsHelper.SetValue(ref value, administrator, PermissionBits.Administrator);
            PermissionsHelper.SetValue(ref value, banMembers, PermissionBits.BanMembers);
            PermissionsHelper.SetValue(ref value, kickMembers, PermissionBits.KickMembers);
            PermissionsHelper.SetValue(ref value, manageChannel, PermissionBits.ManageChannel);
            PermissionsHelper.SetValue(ref value, manageServer, PermissionBits.ManageServer);
            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, changeNickname, PermissionBits.ChangeNickname);
            PermissionsHelper.SetValue(ref value, manageNicknames, PermissionBits.ManageNicknames);
            PermissionsHelper.SetValue(ref value, manageRoles, PermissionBits.ManageRolesOrPermissions);

            RawValue = value;
        }
Example #2
0
		internal Role(ulong id, Server server)
		{
            Id = id;
            Server = server;

			Permissions = new ServerPermissions(0);
			Color = new Color(0);
		}
Example #3
0
		//TODO: Add local members cache

		internal Role(DiscordClient client, string id, string serverId)
			: base(client, id)
		{
			_server = new Reference<Server>(serverId, x => _client.Servers[x], x => x.AddRole(this), x => x.RemoveRole(this));
			Permissions = new ServerPermissions(0);
			Permissions.Lock();
			Color = new Color(0);
			Color.Lock();
		}
Example #4
0
        public static async Task<bool> SafeEdit(this Role role,
            string name = null, ServerPermissions? perm = null, Color color = null, bool? isHoisted = false,
            int? position = null)
        {
            if (color != null && role.IsEveryone)
                return false;

            await role.Edit(name, perm, color, isHoisted, position);

            return true;
        }
Example #5
0
        public async Task Edit(string name = null, ServerPermissions? permissions = null, Color color = null, bool? isHoisted = null, int? position = null, bool? isMentionable = null)
        {
            var updateRequest = new UpdateRoleRequest(Server.Id, Id)
            {
                Name = name ?? Name,
                Permissions = (permissions ?? Permissions).RawValue,
                Color = (color ?? Color).RawValue,
                IsHoisted = isHoisted ?? IsHoisted,
                IsMentionable = isMentionable ?? IsMentionable
            };

            var updateResponse = await Client.ClientAPI.Send(updateRequest).ConfigureAwait(false);

            if (position != null)
            {
                int oldPos = Position;
                int newPos = position.Value;
                int minPos;
                Role[] roles = Server.Roles.OrderBy(x => x.Position).ToArray();

                if (oldPos < newPos) //Moving Down
                {
                    minPos = oldPos;
                    for (int i = oldPos; i < newPos; i++)
                        roles[i] = roles[i + 1];
                    roles[newPos] = this;
                }
                else //(oldPos > newPos) Moving Up
                {
                    minPos = newPos;
                    for (int i = oldPos; i > newPos; i--)
                        roles[i] = roles[i - 1];
                    roles[newPos] = this;
                }

                var reorderRequest = new ReorderRolesRequest(Server.Id)
                {
                    RoleIds = roles.Skip(minPos).Select(x => x.Id).ToArray(),
                    StartPos = minPos
                };
                await Client.ClientAPI.Send(reorderRequest).ConfigureAwait(false);
            }
        }
Example #6
0
		internal void Update(APIRole model, bool updatePermissions)
		{
            if (model.Name != null)
				Name = model.Name;
			if (model.Hoist != null)
				IsHoisted = model.Hoist.Value;
			if (model.Managed != null)
				IsManaged = model.Managed.Value;
			if (model.Mentionable != null)
				IsMentionable = model.Mentionable.Value;
			if (model.Position != null && !IsEveryone)
				Position = model.Position.Value;
			if (model.Color != null)
				Color = new Color(model.Color.Value);
            if (model.Permissions != null)
            {
                Permissions = new ServerPermissions(model.Permissions.Value);
                if (updatePermissions) //Dont update these during READY
                {                    
                    foreach (var member in Members)
                        Server.UpdatePermissions(member);
                }
            }
		}
Example #7
0
        private bool UpdatePermissions(User user, ref ServerPermissions permissions)
		{
			uint newPermissions = 0;

			if (user.Id == _ownerId)
				newPermissions = ServerPermissions.All.RawValue;
			else
			{
				foreach (var serverRole in user.Roles)
					newPermissions |= serverRole.Permissions.RawValue;
			}

			if (newPermissions.HasBit((byte)PermissionBits.ManageRolesOrPermissions))
				newPermissions = ServerPermissions.All.RawValue;

			if (newPermissions != permissions.RawValue)
			{
				permissions = new ServerPermissions(newPermissions);
                return true;
			}
            return false;
		}
Example #8
0
 public Member(User user, ServerPermissions permissions)
 {
     User = user;
     Permissions = permissions;
 }
Example #9
0
        /// <summary> Creates a new role. </summary>
        public async Task<Role> CreateRole(string name, ServerPermissions? permissions = null, Color color = null, bool isHoisted = false)
        {
            if (name == null) throw new ArgumentNullException(nameof(name));

            var createRequest = new CreateRoleRequest(Id);
            var createResponse = await Client.ClientAPI.Send(createRequest).ConfigureAwait(false);
            var role = AddRole(createResponse.Id);
            role.Update(createResponse);

            var editRequest = new UpdateRoleRequest(role.Server.Id, role.Id)
            {
                Name = name,
                Permissions = (permissions ?? role.Permissions).RawValue,
                Color = (color ?? Color.Default).RawValue,
                IsHoisted = isHoisted
            };
            var editResponse = await Client.ClientAPI.Send(editRequest).ConfigureAwait(false);
            role.Update(editResponse);

            return role;
        }
Example #10
0
        private void UpdatePermissions(User user, ServerPermissions permissions)
		{
			uint newPermissions = 0;

			if (user.Id == _ownerId)
				newPermissions = ServerPermissions.All.RawValue;
			else
			{
				foreach (var serverRole in user.Roles)
					newPermissions |= serverRole.Permissions.RawValue;
			}

			if (newPermissions.HasBit((byte)PermissionsBits.ManageRolesOrPermissions))
				newPermissions = ServerPermissions.All.RawValue;

			if (newPermissions != permissions.RawValue)
			{
				permissions.SetRawValueInternal(newPermissions);
				foreach (var channel in _channels)
					channel.Value.UpdatePermissions(user);
			}
		}
Example #11
0
 public Member(User user)
 {
     User = user;
     Permissions = new ServerPermissions();
     Permissions.Lock();
 }
Example #12
0
        async Task<Role> CreateMutedRole(Server server)
        {
            try
            {
                var role = await _client.CreateRole(server, "Muted");
                var serverPermissions = new ServerPermissions
                {
                    ReadMessages = true,
                    SendMessages = false,
                    SendTTSMessages = false
                };

                await _client.EditRole(role, "Muted", serverPermissions);

                return role;
            } 
            catch (Exception ex)
            {
                _botServices.Logging.LogError(string.Format("Failed to create muted role on the {0} server.", server.Name), ex);
                throw;
            }
        } 
Example #13
0
		internal User(DiscordClient client, string id, string serverId)
			: base(client, id)
		{
			_globalUser = new Reference<GlobalUser>(id, 
				x => _client.GlobalUsers.GetOrAdd(x), 
				x => x.AddUser(this), 
				x => x.RemoveUser(this));
			_server = new Reference<Server>(serverId, 
				x => _client.Servers[x], 
				x =>
				{
					x.AddMember(this);
					if (Id == _client.CurrentUserId)
						x.CurrentUser = this;
                }, 
				x =>
				{
					x.RemoveMember(this);
					if (Id == _client.CurrentUserId)
						x.CurrentUser = null;
				});
			_voiceChannel = new Reference<Channel>(x => _client.Channels[x]);
			_roles = new Dictionary<string, Role>();

			Status = UserStatus.Offline;
			_channels = new ConcurrentDictionary<string, Channel>();
			if (serverId != null)
			{
				_permissions = new ConcurrentDictionary<string, ChannelPermissions>();
				_serverPermissions = new ServerPermissions();
			}

			if (serverId == null)
				UpdateRoles(null);
		}