github/Discord.Net
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Exposed RequestOptions

Browse Source
This commit is contained in:
RogueException
2016-10-06 02:44:41 -03:00
parent aa7d9ad414
commit f41df1f966
54 changed files with 793 additions and 766 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/Discord.Net.Core/Entities/Channels/IChannel.cs
View File

@@ -6,9 +6,9 @@ namespace Discord
public interface IChannel : ISnowflakeEntity public interface IChannel : ISnowflakeEntity
{ {
/// <summary> Gets a collection of all users in this channel. </summary> /// <summary> Gets a collection of all users in this channel. </summary>
IAsyncEnumerable<IReadOnlyCollection<IUser>> GetUsersAsync(CacheMode mode = CacheMode.AllowDownload); IAsyncEnumerable<IReadOnlyCollection<IUser>> GetUsersAsync(CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
/// <summary> Gets a user in this channel with the provided id. </summary> /// <summary> Gets a user in this channel with the provided id. </summary>
Task<IUser> GetUserAsync(ulong id, CacheMode mode = CacheMode.AllowDownload); Task<IUser> GetUserAsync(ulong id, CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
} }
} }

2
src/Discord.Net.Core/Entities/Channels/IDMChannel.cs
View File

@@ -8,6 +8,6 @@ namespace Discord
IUser Recipient { get; } IUser Recipient { get; }
/// <summary> Closes this private channel, removing it from your channel list. </summary> /// <summary> Closes this private channel, removing it from your channel list. </summary>
Task CloseAsync(); Task CloseAsync(RequestOptions options = null);
} }
} }

2
src/Discord.Net.Core/Entities/Channels/IGroupChannel.cs
View File

@@ -5,6 +5,6 @@ namespace Discord
public interface IGroupChannel : IMessageChannel, IPrivateChannel, IAudioChannel public interface IGroupChannel : IMessageChannel, IPrivateChannel, IAudioChannel
{ {
/// <summary> Leaves this group. </summary> /// <summary> Leaves this group. </summary>
Task LeaveAsync(); Task LeaveAsync(RequestOptions options = null);
} }
} }

18
src/Discord.Net.Core/Entities/Channels/IGuildChannel.cs
View File

@@ -21,29 +21,29 @@ namespace Discord
/// <param name="maxAge"> The time (in seconds) until the invite expires. Set to null to never expire. </param> /// <param name="maxAge"> The time (in seconds) until the invite expires. Set to null to never expire. </param>
/// <param name="maxUses"> The max amount of times this invite may be used. Set to null to have unlimited uses. </param> /// <param name="maxUses"> The max amount of times this invite may be used. Set to null to have unlimited uses. </param>
/// <param name="isTemporary"> If true, a user accepting this invite will be kicked from the guild after closing their client. </param> /// <param name="isTemporary"> If true, a user accepting this invite will be kicked from the guild after closing their client. </param>
Task<IInviteMetadata> CreateInviteAsync(int? maxAge = 1800, int? maxUses = default(int?), bool isTemporary = false); Task<IInviteMetadata> CreateInviteAsync(int? maxAge = 1800, int? maxUses = default(int?), bool isTemporary = false, RequestOptions options = null);
/// <summary> Returns a collection of all invites to this channel. </summary> /// <summary> Returns a collection of all invites to this channel. </summary>
Task<IReadOnlyCollection<IInviteMetadata>> GetInvitesAsync(); Task<IReadOnlyCollection<IInviteMetadata>> GetInvitesAsync(RequestOptions options = null);
/// <summary> Modifies this guild channel. </summary> /// <summary> Modifies this guild channel. </summary>
Task ModifyAsync(Action<ModifyGuildChannelParams> func); Task ModifyAsync(Action<ModifyGuildChannelParams> func, RequestOptions options = null);
/// <summary> Gets the permission overwrite for a specific role, or null if one does not exist. </summary> /// <summary> Gets the permission overwrite for a specific role, or null if one does not exist. </summary>
OverwritePermissions? GetPermissionOverwrite(IRole role); OverwritePermissions? GetPermissionOverwrite(IRole role);
/// <summary> Gets the permission overwrite for a specific user, or null if one does not exist. </summary> /// <summary> Gets the permission overwrite for a specific user, or null if one does not exist. </summary>
OverwritePermissions? GetPermissionOverwrite(IUser user); OverwritePermissions? GetPermissionOverwrite(IUser user);
/// <summary> Removes the permission overwrite for the given role, if one exists. </summary> /// <summary> Removes the permission overwrite for the given role, if one exists. </summary>
Task RemovePermissionOverwriteAsync(IRole role); Task RemovePermissionOverwriteAsync(IRole role, RequestOptions options = null);
/// <summary> Removes the permission overwrite for the given user, if one exists. </summary> /// <summary> Removes the permission overwrite for the given user, if one exists. </summary>
Task RemovePermissionOverwriteAsync(IUser user); Task RemovePermissionOverwriteAsync(IUser user, RequestOptions options = null);
/// <summary> Adds or updates the permission overwrite for the given role. </summary> /// <summary> Adds or updates the permission overwrite for the given role. </summary>
Task AddPermissionOverwriteAsync(IRole role, OverwritePermissions permissions); Task AddPermissionOverwriteAsync(IRole role, OverwritePermissions permissions, RequestOptions options = null);
/// <summary> Adds or updates the permission overwrite for the given user. </summary> /// <summary> Adds or updates the permission overwrite for the given user. </summary>
Task AddPermissionOverwriteAsync(IUser user, OverwritePermissions permissions); Task AddPermissionOverwriteAsync(IUser user, OverwritePermissions permissions, RequestOptions options = null);
/// <summary> Gets a collection of all users in this channel. </summary> /// <summary> Gets a collection of all users in this channel. </summary>
new IAsyncEnumerable<IReadOnlyCollection<IGuildUser>> GetUsersAsync(CacheMode mode = CacheMode.AllowDownload); new IAsyncEnumerable<IReadOnlyCollection<IGuildUser>> GetUsersAsync(CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
/// <summary> Gets a user in this channel with the provided id.</summary> /// <summary> Gets a user in this channel with the provided id.</summary>
new Task<IGuildUser> GetUserAsync(ulong id, CacheMode mode = CacheMode.AllowDownload); new Task<IGuildUser> GetUserAsync(ulong id, CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
} }
} }

23
src/Discord.Net.Core/Entities/Channels/IMessageChannel.cs
View File

@@ -8,26 +8,29 @@ namespace Discord
public interface IMessageChannel : IChannel public interface IMessageChannel : IChannel
{ {
/// <summary> Sends a message to this message channel. </summary> /// <summary> Sends a message to this message channel. </summary>
Task<IUserMessage> SendMessageAsync(string text, bool isTTS = false); Task<IUserMessage> SendMessageAsync(string text, bool isTTS = false, RequestOptions options = null);
/// <summary> Sends a file to this text channel, with an optional caption. </summary> /// <summary> Sends a file to this text channel, with an optional caption. </summary>
Task<IUserMessage> SendFileAsync(string filePath, string text = null, bool isTTS = false); Task<IUserMessage> SendFileAsync(string filePath, string text = null, bool isTTS = false, RequestOptions options = null);
/// <summary> Sends a file to this text channel, with an optional caption. </summary> /// <summary> Sends a file to this text channel, with an optional caption. </summary>
Task<IUserMessage> SendFileAsync(Stream stream, string filename, string text = null, bool isTTS = false); Task<IUserMessage> SendFileAsync(Stream stream, string filename, string text = null, bool isTTS = false, RequestOptions options = null);
/// <summary> Gets a message from this message channel with the given id, or null if not found. </summary> /// <summary> Gets a message from this message channel with the given id, or null if not found. </summary>
Task<IMessage> GetMessageAsync(ulong id, CacheMode mode = CacheMode.AllowDownload); Task<IMessage> GetMessageAsync(ulong id, CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
/// <summary> Gets the last N messages from this message channel. </summary> /// <summary> Gets the last N messages from this message channel. </summary>
IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch, CacheMode mode = CacheMode.AllowDownload); IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch,
CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
/// <summary> Gets a collection of messages in this channel. </summary> /// <summary> Gets a collection of messages in this channel. </summary>
IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, CacheMode mode = CacheMode.AllowDownload); IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch,
CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
/// <summary> Gets a collection of messages in this channel. </summary> /// <summary> Gets a collection of messages in this channel. </summary>
IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, CacheMode mode = CacheMode.AllowDownload); IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch,
CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
/// <summary> Gets a collection of pinned messages in this channel. </summary> /// <summary> Gets a collection of pinned messages in this channel. </summary>
Task<IReadOnlyCollection<IMessage>> GetPinnedMessagesAsync(); Task<IReadOnlyCollection<IMessage>> GetPinnedMessagesAsync(RequestOptions options = null);
/// <summary> Bulk deletes multiple messages. </summary> /// <summary> Bulk deletes multiple messages. </summary>
Task DeleteMessagesAsync(IEnumerable<IMessage> messages); Task DeleteMessagesAsync(IEnumerable<IMessage> messages, RequestOptions options = null);
/// <summary> Broadcasts the "user is typing" message to all users in this channel, lasting 10 seconds.</summary> /// <summary> Broadcasts the "user is typing" message to all users in this channel, lasting 10 seconds.</summary>
IDisposable EnterTypingState(); IDisposable EnterTypingState(RequestOptions options = null);
} }
} }

2
src/Discord.Net.Core/Entities/Channels/ITextChannel.cs
View File

@@ -10,6 +10,6 @@ namespace Discord
string Topic { get; } string Topic { get; }
/// <summary> Modifies this text channel. </summary> /// <summary> Modifies this text channel. </summary>
Task ModifyAsync(Action<ModifyTextChannelParams> func); Task ModifyAsync(Action<ModifyTextChannelParams> func, RequestOptions options = null);
} }
} }

2
src/Discord.Net.Core/Entities/Channels/IVoiceChannel.cs
View File

@@ -13,7 +13,7 @@ namespace Discord
int UserLimit { get; } int UserLimit { get; }
/// <summary> Modifies this voice channel. </summary> /// <summary> Modifies this voice channel. </summary>
Task ModifyAsync(Action<ModifyVoiceChannelParams> func); Task ModifyAsync(Action<ModifyVoiceChannelParams> func, RequestOptions options = null);
/// <summary> Connects to this voice channel. </summary> /// <summary> Connects to this voice channel. </summary>
Task<IAudioClient> ConnectAsync(); Task<IAudioClient> ConnectAsync();
} }

44
src/Discord.Net.Core/Entities/Guilds/IGuild.cs
View File

@@ -53,56 +53,56 @@ namespace Discord
IReadOnlyCollection<IRole> Roles { get; } IReadOnlyCollection<IRole> Roles { get; }
/// <summary> Modifies this guild. </summary> /// <summary> Modifies this guild. </summary>
Task ModifyAsync(Action<ModifyGuildParams> func); Task ModifyAsync(Action<ModifyGuildParams> func, RequestOptions options = null);
/// <summary> Modifies this guild's embed. </summary> /// <summary> Modifies this guild's embed. </summary>
Task ModifyEmbedAsync(Action<ModifyGuildEmbedParams> func); Task ModifyEmbedAsync(Action<ModifyGuildEmbedParams> func, RequestOptions options = null);
/// <summary> Bulk modifies the channels of this guild. </summary> /// <summary> Bulk modifies the channels of this guild. </summary>
Task ModifyChannelsAsync(IEnumerable<ModifyGuildChannelsParams> args); Task ModifyChannelsAsync(IEnumerable<ModifyGuildChannelsParams> args, RequestOptions options = null);
/// <summary> Bulk modifies the roles of this guild. </summary> /// <summary> Bulk modifies the roles of this guild. </summary>
Task ModifyRolesAsync(IEnumerable<ModifyGuildRolesParams> args); Task ModifyRolesAsync(IEnumerable<ModifyGuildRolesParams> args, RequestOptions options = null);
/// <summary> Leaves this guild. If you are the owner, use Delete instead. </summary> /// <summary> Leaves this guild. If you are the owner, use Delete instead. </summary>
Task LeaveAsync(); Task LeaveAsync(RequestOptions options = null);
/// <summary> Gets a collection of all users banned on this guild. </summary> /// <summary> Gets a collection of all users banned on this guild. </summary>
Task<IReadOnlyCollection<IBan>> GetBansAsync(); Task<IReadOnlyCollection<IBan>> GetBansAsync(RequestOptions options = null);
/// <summary> Bans the provided user from this guild and optionally prunes their recent messages. </summary> /// <summary> Bans the provided user from this guild and optionally prunes their recent messages. </summary>
Task AddBanAsync(IUser user, int pruneDays = 0); Task AddBanAsync(IUser user, int pruneDays = 0, RequestOptions options = null);
/// <summary> Bans the provided user id from this guild and optionally prunes their recent messages. </summary> /// <summary> Bans the provided user id from this guild and optionally prunes their recent messages. </summary>
Task AddBanAsync(ulong userId, int pruneDays = 0); Task AddBanAsync(ulong userId, int pruneDays = 0, RequestOptions options = null);
/// <summary> Unbans the provided user if it is currently banned. </summary> /// <summary> Unbans the provided user if it is currently banned. </summary>
Task RemoveBanAsync(IUser user); Task RemoveBanAsync(IUser user, RequestOptions options = null);
/// <summary> Unbans the provided user id if it is currently banned. </summary> /// <summary> Unbans the provided user id if it is currently banned. </summary>
Task RemoveBanAsync(ulong userId); Task RemoveBanAsync(ulong userId, RequestOptions options = null);
/// <summary> Gets a collection of all channels in this guild. </summary> /// <summary> Gets a collection of all channels in this guild. </summary>
Task<IReadOnlyCollection<IGuildChannel>> GetChannelsAsync(CacheMode mode = CacheMode.AllowDownload); Task<IReadOnlyCollection<IGuildChannel>> GetChannelsAsync(CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
/// <summary> Gets the channel in this guild with the provided id, or null if not found. </summary> /// <summary> Gets the channel in this guild with the provided id, or null if not found. </summary>
Task<IGuildChannel> GetChannelAsync(ulong id, CacheMode mode = CacheMode.AllowDownload); Task<IGuildChannel> GetChannelAsync(ulong id, CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
/// <summary> Creates a new text channel. </summary> /// <summary> Creates a new text channel. </summary>
Task<ITextChannel> CreateTextChannelAsync(string name); Task<ITextChannel> CreateTextChannelAsync(string name, RequestOptions options = null);
/// <summary> Creates a new voice channel. </summary> /// <summary> Creates a new voice channel. </summary>
Task<IVoiceChannel> CreateVoiceChannelAsync(string name); Task<IVoiceChannel> CreateVoiceChannelAsync(string name, RequestOptions options = null);
Task<IReadOnlyCollection<IGuildIntegration>> GetIntegrationsAsync(); Task<IReadOnlyCollection<IGuildIntegration>> GetIntegrationsAsync(RequestOptions options = null);
Task<IGuildIntegration> CreateIntegrationAsync(ulong id, string type); Task<IGuildIntegration> CreateIntegrationAsync(ulong id, string type, RequestOptions options = null);
/// <summary> Gets a collection of all invites to this guild. </summary> /// <summary> Gets a collection of all invites to this guild. </summary>
Task<IReadOnlyCollection<IInviteMetadata>> GetInvitesAsync(); Task<IReadOnlyCollection<IInviteMetadata>> GetInvitesAsync(RequestOptions options = null);
/// <summary> Gets the role in this guild with the provided id, or null if not found. </summary> /// <summary> Gets the role in this guild with the provided id, or null if not found. </summary>
IRole GetRole(ulong id); IRole GetRole(ulong id);
/// <summary> Creates a new role. </summary> /// <summary> Creates a new role. </summary>
Task<IRole> CreateRoleAsync(string name, GuildPermissions? permissions = null, Color? color = null, bool isHoisted = false); Task<IRole> CreateRoleAsync(string name, GuildPermissions? permissions = null, Color? color = null, bool isHoisted = false, RequestOptions options = null);
/// <summary> Gets a collection of all users in this guild. </summary> /// <summary> Gets a collection of all users in this guild. </summary>
Task<IReadOnlyCollection<IGuildUser>> GetUsersAsync(CacheMode mode = CacheMode.AllowDownload); //TODO: shouldnt this be paged? Task<IReadOnlyCollection<IGuildUser>> GetUsersAsync(CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null); //TODO: shouldnt this be paged?
/// <summary> Gets the user in this guild with the provided id, or null if not found. </summary> /// <summary> Gets the user in this guild with the provided id, or null if not found. </summary>
Task<IGuildUser> GetUserAsync(ulong id, CacheMode mode = CacheMode.AllowDownload); Task<IGuildUser> GetUserAsync(ulong id, CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
/// <summary> Gets the current user for this guild. </summary> /// <summary> Gets the current user for this guild. </summary>
Task<IGuildUser> GetCurrentUserAsync(CacheMode mode = CacheMode.AllowDownload); Task<IGuildUser> GetCurrentUserAsync(CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
/// <summary> Downloads all users for this guild if the current list is incomplete. </summary> /// <summary> Downloads all users for this guild if the current list is incomplete. </summary>
Task DownloadUsersAsync(); Task DownloadUsersAsync();
/// <summary> Removes all users from this guild if they have not logged on in a provided number of days or, if simulate is true, returns the number of users that would be removed. </summary> /// <summary> Removes all users from this guild if they have not logged on in a provided number of days or, if simulate is true, returns the number of users that would be removed. </summary>
Task<int> PruneUsersAsync(int days = 30, bool simulate = false); Task<int> PruneUsersAsync(int days = 30, bool simulate = false, RequestOptions options = null);
} }
} }

2
src/Discord.Net.Core/Entities/IDeletable.cs
View File

@@ -5,6 +5,6 @@ namespace Discord
public interface IDeletable public interface IDeletable
{ {
/// <summary> Deletes this object and all its children. </summary> /// <summary> Deletes this object and all its children. </summary>
Task DeleteAsync(); Task DeleteAsync(RequestOptions options = null);
} }
} }

2
src/Discord.Net.Core/Entities/IUpdateable.cs
View File

@@ -5,6 +5,6 @@ namespace Discord
public interface IUpdateable public interface IUpdateable
{ {
/// <summary> Updates this object's properties with its current state. </summary> /// <summary> Updates this object's properties with its current state. </summary>
Task UpdateAsync(); Task UpdateAsync(RequestOptions options = null);
} }
} }

2
src/Discord.Net.Core/Entities/Invites/IInvite.cs
View File

@@ -15,6 +15,6 @@ namespace Discord
ulong GuildId { get; } ulong GuildId { get; }
/// <summary> Accepts this invite and joins the target guild. This will fail on bot accounts. </summary> /// <summary> Accepts this invite and joins the target guild. This will fail on bot accounts. </summary>
Task AcceptAsync(); Task AcceptAsync(RequestOptions options = null);
} }
} }

6
src/Discord.Net.Core/Entities/Messages/IUserMessage.cs
View File

@@ -7,11 +7,11 @@ namespace Discord
public interface IUserMessage : IMessage, IDeletable public interface IUserMessage : IMessage, IDeletable
{ {
/// <summary> Modifies this message. </summary> /// <summary> Modifies this message. </summary>
Task ModifyAsync(Action<ModifyMessageParams> func); Task ModifyAsync(Action<ModifyMessageParams> func, RequestOptions options = null);
/// <summary> Adds this message to its channel's pinned messages. </summary> /// <summary> Adds this message to its channel's pinned messages. </summary>
Task PinAsync(); Task PinAsync(RequestOptions options = null);
/// <summary> Removes this message from its channel's pinned messages. </summary> /// <summary> Removes this message from its channel's pinned messages. </summary>
Task UnpinAsync(); Task UnpinAsync(RequestOptions options = null);
/// <summary> Transforms this message's text into a human readable form, resolving mentions to that object's name. </summary> /// <summary> Transforms this message's text into a human readable form, resolving mentions to that object's name. </summary>
string Resolve(int startIndex, int length, string Resolve(int startIndex, int length,

8
src/Discord.Net.Core/Entities/Roles/IRole.cs
View File

@@ -1,4 +1,8 @@
namespace Discord using Discord.API.Rest;
using System;
using System.Threading.Tasks;
namespace Discord
{ {
public interface IRole : ISnowflakeEntity, IDeletable, IMentionable public interface IRole : ISnowflakeEntity, IDeletable, IMentionable
{ {
@@ -19,6 +23,6 @@
int Position { get; } int Position { get; }
///// <summary> Modifies this role. </summary> ///// <summary> Modifies this role. </summary>
//Task ModifyAsync(Action<ModifyGuildRoleParams> func); Task ModifyAsync(Action<ModifyGuildRoleParams> func, RequestOptions options = null);
} }
} }

2
src/Discord.Net.Core/Entities/Users/IGroupUser.cs
View File

@@ -3,6 +3,6 @@
public interface IGroupUser : IUser, IVoiceState public interface IGroupUser : IUser, IVoiceState
{ {
///// <summary> Kicks this user from this group. </summary> ///// <summary> Kicks this user from this group. </summary>
//Task KickAsync(); //Task KickAsync(RequestOptions options = null);
} }
} }

4
src/Discord.Net.Core/Entities/Users/IGuildUser.cs
View File

@@ -23,8 +23,8 @@ namespace Discord
ChannelPermissions GetPermissions(IGuildChannel channel); ChannelPermissions GetPermissions(IGuildChannel channel);
/// <summary> Kicks this user from this guild. </summary> /// <summary> Kicks this user from this guild. </summary>
Task KickAsync(); Task KickAsync(RequestOptions options = null);
/// <summary> Modifies this user's properties in this guild. </summary> /// <summary> Modifies this user's properties in this guild. </summary>
Task ModifyAsync(Action<ModifyGuildMemberParams> func); Task ModifyAsync(Action<ModifyGuildMemberParams> func, RequestOptions options = null);
} }
} }

4
src/Discord.Net.Core/Entities/Users/ISelfUser.cs
View File

@@ -13,7 +13,7 @@ namespace Discord
/// <summary> Returns true if this user has enabled MFA on their account. </summary> /// <summary> Returns true if this user has enabled MFA on their account. </summary>
bool IsMfaEnabled { get; } bool IsMfaEnabled { get; }
Task ModifyAsync(Action<ModifyCurrentUserParams> func); Task ModifyAsync(Action<ModifyCurrentUserParams> func, RequestOptions options = null);
Task ModifyStatusAsync(Action<ModifyPresenceParams> func); Task ModifyStatusAsync(Action<ModifyPresenceParams> func, RequestOptions options = null);
} }
} }

4
src/Discord.Net.Core/Entities/Users/IUser.cs
View File

@@ -18,8 +18,8 @@ namespace Discord
string Username { get; } string Username { get; }
/// <summary> Returns a private message channel to this user, creating one if it does not already exist. </summary> /// <summary> Returns a private message channel to this user, creating one if it does not already exist. </summary>
Task<IDMChannel> GetDMChannelAsync(CacheMode mode = CacheMode.AllowDownload); Task<IDMChannel> GetDMChannelAsync(CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
/// <summary> Returns a private message channel to this user, creating one if it does not already exist. </summary> /// <summary> Returns a private message channel to this user, creating one if it does not already exist. </summary>
Task<IDMChannel> CreateDMChannelAsync(); Task<IDMChannel> CreateDMChannelAsync(RequestOptions options = null);
} }
} }

97
src/Discord.Net.Rest/Entities/Channels/ChannelHelper.cs
View File

@@ -12,67 +12,64 @@ namespace Discord.Rest
internal static class ChannelHelper internal static class ChannelHelper
{ {
//General //General
public static async Task<Model> GetAsync(IGuildChannel channel, BaseDiscordClient client) public static async Task DeleteAsync(IChannel channel, BaseDiscordClient client,
{ RequestOptions options)
return await client.ApiClient.GetChannelAsync(channel.GuildId, channel.Id).ConfigureAwait(false);
}
public static async Task<Model> GetAsync(IPrivateChannel channel, BaseDiscordClient client)
{
return await client.ApiClient.GetChannelAsync(channel.Id).ConfigureAwait(false);
}
public static async Task DeleteAsync(IChannel channel, BaseDiscordClient client)
{ {
await client.ApiClient.DeleteChannelAsync(channel.Id).ConfigureAwait(false); await client.ApiClient.DeleteChannelAsync(channel.Id, options).ConfigureAwait(false);
} }
public static async Task ModifyAsync(IGuildChannel channel, BaseDiscordClient client, public static async Task ModifyAsync(IGuildChannel channel, BaseDiscordClient client,
Action<ModifyGuildChannelParams> func) Action<ModifyGuildChannelParams> func,
RequestOptions options)
{ {
var args = new ModifyGuildChannelParams(); var args = new ModifyGuildChannelParams();
func(args); func(args);
await client.ApiClient.ModifyGuildChannelAsync(channel.Id, args); await client.ApiClient.ModifyGuildChannelAsync(channel.Id, args, options);
} }
public static async Task ModifyAsync(ITextChannel channel, BaseDiscordClient client, public static async Task ModifyAsync(ITextChannel channel, BaseDiscordClient client,
Action<ModifyTextChannelParams> func) Action<ModifyTextChannelParams> func,
RequestOptions options)
{ {
var args = new ModifyTextChannelParams(); var args = new ModifyTextChannelParams();
func(args); func(args);
await client.ApiClient.ModifyGuildChannelAsync(channel.Id, args); await client.ApiClient.ModifyGuildChannelAsync(channel.Id, args, options);
} }
public static async Task ModifyAsync(IVoiceChannel channel, BaseDiscordClient client, public static async Task ModifyAsync(IVoiceChannel channel, BaseDiscordClient client,
Action<ModifyVoiceChannelParams> func) Action<ModifyVoiceChannelParams> func,
RequestOptions options)
{ {
var args = new ModifyVoiceChannelParams(); var args = new ModifyVoiceChannelParams();
func(args); func(args);
await client.ApiClient.ModifyGuildChannelAsync(channel.Id, args); await client.ApiClient.ModifyGuildChannelAsync(channel.Id, args, options);
} }
//Invites //Invites
public static async Task<IReadOnlyCollection<RestInviteMetadata>> GetInvitesAsync(IChannel channel, BaseDiscordClient client) public static async Task<IReadOnlyCollection<RestInviteMetadata>> GetInvitesAsync(IChannel channel, BaseDiscordClient client,
RequestOptions options)
{ {
var models = await client.ApiClient.GetChannelInvitesAsync(channel.Id); var models = await client.ApiClient.GetChannelInvitesAsync(channel.Id, options);
return models.Select(x => RestInviteMetadata.Create(client, x)).ToImmutableArray(); return models.Select(x => RestInviteMetadata.Create(client, x)).ToImmutableArray();
} }
public static async Task<RestInviteMetadata> CreateInviteAsync(IChannel channel, BaseDiscordClient client, public static async Task<RestInviteMetadata> CreateInviteAsync(IChannel channel, BaseDiscordClient client,
int? maxAge, int? maxUses, bool isTemporary) int? maxAge, int? maxUses, bool isTemporary, RequestOptions options)
{ {
var args = new CreateChannelInviteParams { IsTemporary = isTemporary }; var args = new CreateChannelInviteParams { IsTemporary = isTemporary };
if (maxAge.HasValue) if (maxAge.HasValue)
args.MaxAge = maxAge.Value; args.MaxAge = maxAge.Value;
if (maxUses.HasValue) if (maxUses.HasValue)
args.MaxUses = maxUses.Value; args.MaxUses = maxUses.Value;
var model = await client.ApiClient.CreateChannelInviteAsync(channel.Id, args); var model = await client.ApiClient.CreateChannelInviteAsync(channel.Id, args, options);
return RestInviteMetadata.Create(client, model); return RestInviteMetadata.Create(client, model);
} }
//Messages //Messages
public static async Task<RestMessage> GetMessageAsync(IChannel channel, BaseDiscordClient client, public static async Task<RestMessage> GetMessageAsync(IChannel channel, BaseDiscordClient client,
ulong id) ulong id, RequestOptions options)
{ {
var model = await client.ApiClient.GetChannelMessageAsync(channel.Id, id).ConfigureAwait(false); var model = await client.ApiClient.GetChannelMessageAsync(channel.Id, id, options).ConfigureAwait(false);
return RestMessage.Create(client, model); return RestMessage.Create(client, model);
} }
public static IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(IChannel channel, BaseDiscordClient client, public static IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(IChannel channel, BaseDiscordClient client,
ulong? fromMessageId = null, Direction dir = Direction.Before, int limit = DiscordConfig.MaxMessagesPerBatch) ulong? fromMessageId, Direction dir, int limit, RequestOptions options)
{ {
//TODO: Test this with Around direction //TODO: Test this with Around direction
return new PagedAsyncEnumerable<RestMessage>( return new PagedAsyncEnumerable<RestMessage>(
@@ -86,7 +83,7 @@ namespace Discord.Rest
}; };
if (info.Position != null) if (info.Position != null)
args.RelativeMessageId = info.Position.Value; args.RelativeMessageId = info.Position.Value;
var models = await client.ApiClient.GetChannelMessagesAsync(channel.Id, args); var models = await client.ApiClient.GetChannelMessagesAsync(channel.Id, args, options);
return models.Select(x => RestMessage.Create(client, x)).ToImmutableArray(); ; return models.Select(x => RestMessage.Create(client, x)).ToImmutableArray(); ;
}, },
nextPage: (info, lastPage) => nextPage: (info, lastPage) =>
@@ -102,71 +99,72 @@ namespace Discord.Rest
count: limit count: limit
); );
} }
public static async Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync(IChannel channel, BaseDiscordClient client) public static async Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync(IChannel channel, BaseDiscordClient client,
RequestOptions options)
{ {
var models = await client.ApiClient.GetPinsAsync(channel.Id).ConfigureAwait(false); var models = await client.ApiClient.GetPinsAsync(channel.Id, options).ConfigureAwait(false);
return models.Select(x => RestMessage.Create(client, x)).ToImmutableArray(); return models.Select(x => RestMessage.Create(client, x)).ToImmutableArray();
} }
public static async Task<RestUserMessage> SendMessageAsync(IChannel channel, BaseDiscordClient client, public static async Task<RestUserMessage> SendMessageAsync(IChannel channel, BaseDiscordClient client,
string text, bool isTTS) string text, bool isTTS, RequestOptions options)
{ {
var args = new CreateMessageParams(text) { IsTTS = isTTS }; var args = new CreateMessageParams(text) { IsTTS = isTTS };
var model = await client.ApiClient.CreateMessageAsync(channel.Id, args).ConfigureAwait(false); var model = await client.ApiClient.CreateMessageAsync(channel.Id, args, options).ConfigureAwait(false);
return RestUserMessage.Create(client, model); return RestUserMessage.Create(client, model);
} }
public static Task<RestUserMessage> SendFileAsync(IChannel channel, BaseDiscordClient client, public static Task<RestUserMessage> SendFileAsync(IChannel channel, BaseDiscordClient client,
string filePath, string text, bool isTTS) string filePath, string text, bool isTTS, RequestOptions options)
{ {
string filename = Path.GetFileName(filePath); string filename = Path.GetFileName(filePath);
using (var file = File.OpenRead(filePath)) using (var file = File.OpenRead(filePath))
return SendFileAsync(channel, client, file, filename, text, isTTS); return SendFileAsync(channel, client, file, filename, text, isTTS, options);
} }
public static async Task<RestUserMessage> SendFileAsync(IChannel channel, BaseDiscordClient client, public static async Task<RestUserMessage> SendFileAsync(IChannel channel, BaseDiscordClient client,
Stream stream, string filename, string text, bool isTTS) Stream stream, string filename, string text, bool isTTS, RequestOptions options)
{ {
var args = new UploadFileParams(stream) { Filename = filename, Content = text, IsTTS = isTTS }; var args = new UploadFileParams(stream) { Filename = filename, Content = text, IsTTS = isTTS };
var model = await client.ApiClient.UploadFileAsync(channel.Id, args).ConfigureAwait(false); var model = await client.ApiClient.UploadFileAsync(channel.Id, args, options).ConfigureAwait(false);
return RestUserMessage.Create(client, model); return RestUserMessage.Create(client, model);
} }
public static async Task DeleteMessagesAsync(IChannel channel, BaseDiscordClient client, public static async Task DeleteMessagesAsync(IChannel channel, BaseDiscordClient client,
IEnumerable<IMessage> messages) IEnumerable<IMessage> messages, RequestOptions options)
{ {
var args = new DeleteMessagesParams(messages.Select(x => x.Id).ToArray()); var args = new DeleteMessagesParams(messages.Select(x => x.Id).ToArray());
await client.ApiClient.DeleteMessagesAsync(channel.Id, args).ConfigureAwait(false); await client.ApiClient.DeleteMessagesAsync(channel.Id, args, options).ConfigureAwait(false);
} }
//Permission Overwrites //Permission Overwrites
public static async Task AddPermissionOverwriteAsync(IGuildChannel channel, BaseDiscordClient client, public static async Task AddPermissionOverwriteAsync(IGuildChannel channel, BaseDiscordClient client,
IUser user, OverwritePermissions perms) IUser user, OverwritePermissions perms, RequestOptions options)
{ {
var args = new ModifyChannelPermissionsParams("member", perms.AllowValue, perms.DenyValue); var args = new ModifyChannelPermissionsParams("member", perms.AllowValue, perms.DenyValue);
await client.ApiClient.ModifyChannelPermissionsAsync(channel.Id, user.Id, args).ConfigureAwait(false); await client.ApiClient.ModifyChannelPermissionsAsync(channel.Id, user.Id, args, options).ConfigureAwait(false);
} }
public static async Task AddPermissionOverwriteAsync(IGuildChannel channel, BaseDiscordClient client, public static async Task AddPermissionOverwriteAsync(IGuildChannel channel, BaseDiscordClient client,
IRole role, OverwritePermissions perms) IRole role, OverwritePermissions perms, RequestOptions options)
{ {
var args = new ModifyChannelPermissionsParams("role", perms.AllowValue, perms.DenyValue); var args = new ModifyChannelPermissionsParams("role", perms.AllowValue, perms.DenyValue);
await client.ApiClient.ModifyChannelPermissionsAsync(channel.Id, role.Id, args).ConfigureAwait(false); await client.ApiClient.ModifyChannelPermissionsAsync(channel.Id, role.Id, args, options).ConfigureAwait(false);
} }
public static async Task RemovePermissionOverwriteAsync(IGuildChannel channel, BaseDiscordClient client, public static async Task RemovePermissionOverwriteAsync(IGuildChannel channel, BaseDiscordClient client,
IUser user) IUser user, RequestOptions options)
{ {
await client.ApiClient.DeleteChannelPermissionAsync(channel.Id, user.Id).ConfigureAwait(false); await client.ApiClient.DeleteChannelPermissionAsync(channel.Id, user.Id, options).ConfigureAwait(false);
} }
public static async Task RemovePermissionOverwriteAsync(IGuildChannel channel, BaseDiscordClient client, public static async Task RemovePermissionOverwriteAsync(IGuildChannel channel, BaseDiscordClient client,
IRole role) IRole role, RequestOptions options)
{ {
await client.ApiClient.DeleteChannelPermissionAsync(channel.Id, role.Id).ConfigureAwait(false); await client.ApiClient.DeleteChannelPermissionAsync(channel.Id, role.Id, options).ConfigureAwait(false);
} }
//Users //Users
public static async Task<RestGuildUser> GetUserAsync(IGuildChannel channel, IGuild guild, BaseDiscordClient client, public static async Task<RestGuildUser> GetUserAsync(IGuildChannel channel, IGuild guild, BaseDiscordClient client,
ulong id) ulong id, RequestOptions options)
{ {
var model = await client.ApiClient.GetGuildMemberAsync(channel.GuildId, id); var model = await client.ApiClient.GetGuildMemberAsync(channel.GuildId, id, options);
if (model == null) if (model == null)
return null; return null;
var user = RestGuildUser.Create(client, guild, model); var user = RestGuildUser.Create(client, guild, model);
@@ -176,7 +174,7 @@ namespace Discord.Rest
return user; return user;
} }
public static IAsyncEnumerable<IReadOnlyCollection<RestGuildUser>> GetUsersAsync(IGuildChannel channel, IGuild guild, BaseDiscordClient client, public static IAsyncEnumerable<IReadOnlyCollection<RestGuildUser>> GetUsersAsync(IGuildChannel channel, IGuild guild, BaseDiscordClient client,
ulong? froUserId = null, int? limit = DiscordConfig.MaxUsersPerBatch) ulong? fromUserId, int? limit, RequestOptions options)
{ {
return new PagedAsyncEnumerable<RestGuildUser>( return new PagedAsyncEnumerable<RestGuildUser>(
DiscordConfig.MaxUsersPerBatch, DiscordConfig.MaxUsersPerBatch,
@@ -188,7 +186,7 @@ namespace Discord.Rest
}; };
if (info.Position != null) if (info.Position != null)
args.AfterUserId = info.Position.Value; args.AfterUserId = info.Position.Value;
var models = await guild.Discord.ApiClient.GetGuildMembersAsync(guild.Id, args); var models = await guild.Discord.ApiClient.GetGuildMembersAsync(guild.Id, args, options);
return models return models
.Select(x => RestGuildUser.Create(client, guild, x)) .Select(x => RestGuildUser.Create(client, guild, x))
.Where(x => x.GetPermissions(channel).ReadMessages) .Where(x => x.GetPermissions(channel).ReadMessages)
@@ -200,13 +198,14 @@ namespace Discord.Rest
if (lastPage.Count != DiscordConfig.MaxMessagesPerBatch) if (lastPage.Count != DiscordConfig.MaxMessagesPerBatch)
info.Remaining = 0; info.Remaining = 0;
}, },
start: froUserId, start: fromUserId,
count: limit count: limit
); );
} }
//Typing //Typing
public static IDisposable EnterTypingState(IChannel channel, BaseDiscordClient client) public static IDisposable EnterTypingState(IChannel channel, BaseDiscordClient client,
=> new TypingNotifier(client, channel); RequestOptions options)
=> new TypingNotifier(client, channel, options);
} }
} }

16
src/Discord.Net.Rest/Entities/Channels/IRestMessageChannel.cs
View File

@@ -7,21 +7,21 @@ namespace Discord.Rest
public interface IRestMessageChannel : IMessageChannel public interface IRestMessageChannel : IMessageChannel
{ {
/// <summary> Sends a message to this message channel. </summary> /// <summary> Sends a message to this message channel. </summary>
new Task<RestUserMessage> SendMessageAsync(string text, bool isTTS = false); new Task<RestUserMessage> SendMessageAsync(string text, bool isTTS = false, RequestOptions options = null);
/// <summary> Sends a file to this text channel, with an optional caption. </summary> /// <summary> Sends a file to this text channel, with an optional caption. </summary>
new Task<RestUserMessage> SendFileAsync(string filePath, string text = null, bool isTTS = false); new Task<RestUserMessage> SendFileAsync(string filePath, string text = null, bool isTTS = false, RequestOptions options = null);
/// <summary> Sends a file to this text channel, with an optional caption. </summary> /// <summary> Sends a file to this text channel, with an optional caption. </summary>
new Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text = null, bool isTTS = false); new Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text = null, bool isTTS = false, RequestOptions options = null);
/// <summary> Gets a message from this message channel with the given id, or null if not found. </summary> /// <summary> Gets a message from this message channel with the given id, or null if not found. </summary>
Task<RestMessage> GetMessageAsync(ulong id); Task<RestMessage> GetMessageAsync(ulong id, RequestOptions options = null);
/// <summary> Gets the last N messages from this message channel. </summary> /// <summary> Gets the last N messages from this message channel. </summary>
IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch); IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null);
/// <summary> Gets a collection of messages in this channel. </summary> /// <summary> Gets a collection of messages in this channel. </summary>
IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch); IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null);
/// <summary> Gets a collection of messages in this channel. </summary> /// <summary> Gets a collection of messages in this channel. </summary>
IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch); IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null);
/// <summary> Gets a collection of pinned messages in this channel. </summary> /// <summary> Gets a collection of pinned messages in this channel. </summary>
new Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync(); new Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync(RequestOptions options = null);
} }
} }

6
src/Discord.Net.Rest/Entities/Channels/RestChannel.cs
View File

@@ -41,12 +41,12 @@ namespace Discord.Rest
} }
internal abstract void Update(Model model); internal abstract void Update(Model model);
public abstract Task UpdateAsync(); public abstract Task UpdateAsync(RequestOptions options = null);
//IChannel //IChannel
Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode) Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IUser>(null); //Overriden => Task.FromResult<IUser>(null); //Overriden
IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode, RequestOptions options)
=> AsyncEnumerable.Empty<IReadOnlyCollection<IUser>>(); //Overriden => AsyncEnumerable.Empty<IReadOnlyCollection<IUser>>(); //Overriden
} }
} }

92
src/Discord.Net.Rest/Entities/Channels/RestDMChannel.cs
View File

@@ -34,10 +34,13 @@ namespace Discord.Rest
Recipient.Update(model.Recipients.Value[0]); Recipient.Update(model.Recipients.Value[0]);
} }
public override async Task UpdateAsync() public override async Task UpdateAsync(RequestOptions options = null)
=> Update(await ChannelHelper.GetAsync(this, Discord)); {
public Task CloseAsync() var model = await Discord.ApiClient.GetChannelAsync(Id, options);
=> ChannelHelper.DeleteAsync(this, Discord); Update(model);
}
public Task CloseAsync(RequestOptions options = null)
=> ChannelHelper.DeleteAsync(this, Discord, options);
public RestUser GetUser(ulong id) public RestUser GetUser(ulong id)
{ {
@@ -49,29 +52,29 @@ namespace Discord.Rest
return null; return null;
} }
public Task<RestMessage> GetMessageAsync(ulong id) public Task<RestMessage> GetMessageAsync(ulong id, RequestOptions options = null)
=> ChannelHelper.GetMessageAsync(this, Discord, id); => ChannelHelper.GetMessageAsync(this, Discord, id, options);
public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> ChannelHelper.GetMessagesAsync(this, Discord, limit: limit); => ChannelHelper.GetMessagesAsync(this, Discord, null, Direction.Before, limit, options);
public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> ChannelHelper.GetMessagesAsync(this, Discord, fromMessageId, dir, limit); => ChannelHelper.GetMessagesAsync(this, Discord, fromMessageId, dir, limit, options);
public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> ChannelHelper.GetMessagesAsync(this, Discord, fromMessage.Id, dir, limit); => ChannelHelper.GetMessagesAsync(this, Discord, fromMessage.Id, dir, limit, options);
public Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync() public Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync(RequestOptions options = null)
=> ChannelHelper.GetPinnedMessagesAsync(this, Discord); => ChannelHelper.GetPinnedMessagesAsync(this, Discord, options);
public Task<RestUserMessage> SendMessageAsync(string text, bool isTTS) public Task<RestUserMessage> SendMessageAsync(string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendMessageAsync(this, Discord, text, isTTS); => ChannelHelper.SendMessageAsync(this, Discord, text, isTTS, options);
public Task<RestUserMessage> SendFileAsync(string filePath, string text, bool isTTS) public Task<RestUserMessage> SendFileAsync(string filePath, string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendFileAsync(this, Discord, filePath, text, isTTS); => ChannelHelper.SendFileAsync(this, Discord, filePath, text, isTTS, options);
public Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text, bool isTTS) public Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendFileAsync(this, Discord, stream, filename, text, isTTS); => ChannelHelper.SendFileAsync(this, Discord, stream, filename, text, isTTS, options);
public Task DeleteMessagesAsync(IEnumerable<IMessage> messages) public Task DeleteMessagesAsync(IEnumerable<IMessage> messages, RequestOptions options = null)
=> ChannelHelper.DeleteMessagesAsync(this, Discord, messages); => ChannelHelper.DeleteMessagesAsync(this, Discord, messages, options);
public IDisposable EnterTypingState() public IDisposable EnterTypingState(RequestOptions options = null)
=> ChannelHelper.EnterTypingState(this, Discord); => ChannelHelper.EnterTypingState(this, Discord, options);
public override string ToString() => $"@{Recipient}"; public override string ToString() => $"@{Recipient}";
private string DebuggerDisplay => $"@{Recipient} ({Id}, DM)"; private string DebuggerDisplay => $"@{Recipient} ({Id}, DM)";
@@ -86,49 +89,50 @@ namespace Discord.Rest
IReadOnlyCollection<IUser> IPrivateChannel.Recipients => ImmutableArray.Create<IUser>(Recipient); IReadOnlyCollection<IUser> IPrivateChannel.Recipients => ImmutableArray.Create<IUser>(Recipient);
//IMessageChannel //IMessageChannel
async Task<IMessage> IMessageChannel.GetMessageAsync(ulong id, CacheMode mode) async Task<IMessage> IMessageChannel.GetMessageAsync(ulong id, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetMessageAsync(id); return await GetMessageAsync(id, options);
else else
return null; return null;
} }
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(int limit, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return GetMessagesAsync(limit); return GetMessagesAsync(limit, options);
else else
return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>(); return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>();
} }
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(ulong fromMessageId, Direction dir, int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(ulong fromMessageId, Direction dir, int limit, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return GetMessagesAsync(fromMessageId, dir, limit); return GetMessagesAsync(fromMessageId, dir, limit, options);
else else
return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>(); return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>();
} }
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(IMessage fromMessage, Direction dir, int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(IMessage fromMessage, Direction dir, int limit, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return GetMessagesAsync(fromMessage, dir, limit); return GetMessagesAsync(fromMessage, dir, limit, options);
else else
return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>(); return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>();
} }
async Task<IReadOnlyCollection<IMessage>> IMessageChannel.GetPinnedMessagesAsync() async Task<IReadOnlyCollection<IMessage>> IMessageChannel.GetPinnedMessagesAsync(RequestOptions options)
=> await GetPinnedMessagesAsync().ConfigureAwait(false); => await GetPinnedMessagesAsync(options);
async Task<IUserMessage> IMessageChannel.SendFileAsync(string filePath, string text, bool isTTS)
=> await SendFileAsync(filePath, text, isTTS); async Task<IUserMessage> IMessageChannel.SendFileAsync(string filePath, string text, bool isTTS, RequestOptions options)
async Task<IUserMessage> IMessageChannel.SendFileAsync(Stream stream, string filename, string text, bool isTTS) => await SendFileAsync(filePath, text, isTTS, options);
=> await SendFileAsync(stream, filename, text, isTTS); async Task<IUserMessage> IMessageChannel.SendFileAsync(Stream stream, string filename, string text, bool isTTS, RequestOptions options)
async Task<IUserMessage> IMessageChannel.SendMessageAsync(string text, bool isTTS) => await SendFileAsync(stream, filename, text, isTTS, options);
=> await SendMessageAsync(text, isTTS); async Task<IUserMessage> IMessageChannel.SendMessageAsync(string text, bool isTTS, RequestOptions options)
IDisposable IMessageChannel.EnterTypingState() => await SendMessageAsync(text, isTTS, options);
=> EnterTypingState(); IDisposable IMessageChannel.EnterTypingState(RequestOptions options)
=> EnterTypingState(options);
//IChannel //IChannel
Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode) Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IUser>(GetUser(id)); => Task.FromResult<IUser>(GetUser(id));
IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode, RequestOptions options)
=> ImmutableArray.Create<IReadOnlyCollection<IUser>>(Users).ToAsyncEnumerable(); => ImmutableArray.Create<IReadOnlyCollection<IUser>>(Users).ToAsyncEnumerable();
} }
} }

95
src/Discord.Net.Rest/Entities/Channels/RestGroupChannel.cs
View File

@@ -49,12 +49,15 @@ namespace Discord.Rest
_users = users.ToImmutable(); _users = users.ToImmutable();
} }
public override async Task UpdateAsync() public override async Task UpdateAsync(RequestOptions options = null)
=> Update(await ChannelHelper.GetAsync(this, Discord)); {
public Task LeaveAsync() var model = await Discord.ApiClient.GetChannelAsync(Id, options);
=> ChannelHelper.DeleteAsync(this, Discord); Update(model);
}
public Task LeaveAsync(RequestOptions options = null)
=> ChannelHelper.DeleteAsync(this, Discord, options);
public IUser GetUser(ulong id) public RestUser GetUser(ulong id)
{ {
RestGroupUser user; RestGroupUser user;
if (_users.TryGetValue(id, out user)) if (_users.TryGetValue(id, out user))
@@ -62,29 +65,29 @@ namespace Discord.Rest
return null; return null;
} }
public Task<RestMessage> GetMessageAsync(ulong id) public Task<RestMessage> GetMessageAsync(ulong id, RequestOptions options = null)
=> ChannelHelper.GetMessageAsync(this, Discord, id); => ChannelHelper.GetMessageAsync(this, Discord, id, options);
public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> ChannelHelper.GetMessagesAsync(this, Discord, limit: limit); => ChannelHelper.GetMessagesAsync(this, Discord, null, Direction.Before, limit, options);
public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> ChannelHelper.GetMessagesAsync(this, Discord, fromMessageId, dir, limit); => ChannelHelper.GetMessagesAsync(this, Discord, fromMessageId, dir, limit, options);
public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> ChannelHelper.GetMessagesAsync(this, Discord, fromMessage.Id, dir, limit); => ChannelHelper.GetMessagesAsync(this, Discord, fromMessage.Id, dir, limit, options);
public Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync() public Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync(RequestOptions options = null)
=> ChannelHelper.GetPinnedMessagesAsync(this, Discord); => ChannelHelper.GetPinnedMessagesAsync(this, Discord, options);
public Task<RestUserMessage> SendMessageAsync(string text, bool isTTS) public Task<RestUserMessage> SendMessageAsync(string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendMessageAsync(this, Discord, text, isTTS); => ChannelHelper.SendMessageAsync(this, Discord, text, isTTS, options);
public Task<RestUserMessage> SendFileAsync(string filePath, string text, bool isTTS) public Task<RestUserMessage> SendFileAsync(string filePath, string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendFileAsync(this, Discord, filePath, text, isTTS); => ChannelHelper.SendFileAsync(this, Discord, filePath, text, isTTS, options);
public Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text, bool isTTS) public Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendFileAsync(this, Discord, stream, filename, text, isTTS); => ChannelHelper.SendFileAsync(this, Discord, stream, filename, text, isTTS, options);
public Task DeleteMessagesAsync(IEnumerable<IMessage> messages) public Task DeleteMessagesAsync(IEnumerable<IMessage> messages, RequestOptions options = null)
=> ChannelHelper.DeleteMessagesAsync(this, Discord, messages); => ChannelHelper.DeleteMessagesAsync(this, Discord, messages, options);
public IDisposable EnterTypingState() public IDisposable EnterTypingState(RequestOptions options = null)
=> ChannelHelper.EnterTypingState(this, Discord); => ChannelHelper.EnterTypingState(this, Discord, options);
public override string ToString() => Name; public override string ToString() => Name;
private string DebuggerDisplay => $"{Name} ({Id}, Group)"; private string DebuggerDisplay => $"{Name} ({Id}, Group)";
@@ -96,50 +99,50 @@ namespace Discord.Rest
IReadOnlyCollection<IUser> IPrivateChannel.Recipients => Recipients; IReadOnlyCollection<IUser> IPrivateChannel.Recipients => Recipients;
//IMessageChannel //IMessageChannel
async Task<IMessage> IMessageChannel.GetMessageAsync(ulong id, CacheMode mode) async Task<IMessage> IMessageChannel.GetMessageAsync(ulong id, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetMessageAsync(id); return await GetMessageAsync(id, options);
else else
return null; return null;
} }
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(int limit, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return GetMessagesAsync(limit); return GetMessagesAsync(limit, options);
else else
return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>(); return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>();
} }
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(ulong fromMessageId, Direction dir, int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(ulong fromMessageId, Direction dir, int limit, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return GetMessagesAsync(fromMessageId, dir, limit); return GetMessagesAsync(fromMessageId, dir, limit, options);
else else
return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>(); return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>();
} }
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(IMessage fromMessage, Direction dir, int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(IMessage fromMessage, Direction dir, int limit, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return GetMessagesAsync(fromMessage, dir, limit); return GetMessagesAsync(fromMessage, dir, limit, options);
else else
return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>(); return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>();
} }
async Task<IReadOnlyCollection<IMessage>> IMessageChannel.GetPinnedMessagesAsync() async Task<IReadOnlyCollection<IMessage>> IMessageChannel.GetPinnedMessagesAsync(RequestOptions options)
=> await GetPinnedMessagesAsync(); => await GetPinnedMessagesAsync(options);
async Task<IUserMessage> IMessageChannel.SendFileAsync(string filePath, string text, bool isTTS) async Task<IUserMessage> IMessageChannel.SendFileAsync(string filePath, string text, bool isTTS, RequestOptions options)
=> await SendFileAsync(filePath, text, isTTS); => await SendFileAsync(filePath, text, isTTS, options);
async Task<IUserMessage> IMessageChannel.SendFileAsync(Stream stream, string filename, string text, bool isTTS) async Task<IUserMessage> IMessageChannel.SendFileAsync(Stream stream, string filename, string text, bool isTTS, RequestOptions options)
=> await SendFileAsync(stream, filename, text, isTTS); => await SendFileAsync(stream, filename, text, isTTS, options);
async Task<IUserMessage> IMessageChannel.SendMessageAsync(string text, bool isTTS) async Task<IUserMessage> IMessageChannel.SendMessageAsync(string text, bool isTTS, RequestOptions options)
=> await SendMessageAsync(text, isTTS); => await SendMessageAsync(text, isTTS, options);
IDisposable IMessageChannel.EnterTypingState() IDisposable IMessageChannel.EnterTypingState(RequestOptions options)
=> EnterTypingState(); => EnterTypingState(options);
//IChannel //IChannel
Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode) Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult(GetUser(id)); => Task.FromResult<IUser>(GetUser(id));
IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode, RequestOptions options)
=> ImmutableArray.Create<IReadOnlyCollection<IUser>>(Users).ToAsyncEnumerable(); => ImmutableArray.Create<IReadOnlyCollection<IUser>>(Users).ToAsyncEnumerable();
} }
} }

71
src/Discord.Net.Rest/Entities/Channels/RestGuildChannel.cs
View File

@@ -49,12 +49,15 @@ namespace Discord.Rest
_overwrites = newOverwrites.ToImmutable(); _overwrites = newOverwrites.ToImmutable();
} }
public override async Task UpdateAsync() public override async Task UpdateAsync(RequestOptions options = null)
=> Update(await ChannelHelper.GetAsync(this, Discord)); {
public Task ModifyAsync(Action<ModifyGuildChannelParams> func) var model = await Discord.ApiClient.GetChannelAsync(GuildId, Id, options);
=> ChannelHelper.ModifyAsync(this, Discord, func); Update(model);
public Task DeleteAsync() }
=> ChannelHelper.DeleteAsync(this, Discord); public Task ModifyAsync(Action<ModifyGuildChannelParams> func, RequestOptions options = null)
=> ChannelHelper.ModifyAsync(this, Discord, func, options);
public Task DeleteAsync(RequestOptions options = null)
=> ChannelHelper.DeleteAsync(this, Discord, options);
public OverwritePermissions? GetPermissionOverwrite(IUser user) public OverwritePermissions? GetPermissionOverwrite(IUser user)
{ {
@@ -74,19 +77,19 @@ namespace Discord.Rest
} }
return null; return null;
} }
public async Task AddPermissionOverwriteAsync(IUser user, OverwritePermissions perms) public async Task AddPermissionOverwriteAsync(IUser user, OverwritePermissions perms, RequestOptions options = null)
{ {
await ChannelHelper.AddPermissionOverwriteAsync(this, Discord, user, perms).ConfigureAwait(false); await ChannelHelper.AddPermissionOverwriteAsync(this, Discord, user, perms, options).ConfigureAwait(false);
_overwrites = _overwrites.Add(new Overwrite(new API.Overwrite { Allow = perms.AllowValue, Deny = perms.DenyValue, TargetId = user.Id, TargetType = PermissionTarget.User })); _overwrites = _overwrites.Add(new Overwrite(new API.Overwrite { Allow = perms.AllowValue, Deny = perms.DenyValue, TargetId = user.Id, TargetType = PermissionTarget.User }));
} }
public async Task AddPermissionOverwriteAsync(IRole role, OverwritePermissions perms) public async Task AddPermissionOverwriteAsync(IRole role, OverwritePermissions perms, RequestOptions options = null)
{ {
await ChannelHelper.AddPermissionOverwriteAsync(this, Discord, role, perms).ConfigureAwait(false); await ChannelHelper.AddPermissionOverwriteAsync(this, Discord, role, perms, options).ConfigureAwait(false);
_overwrites.Add(new Overwrite(new API.Overwrite { Allow = perms.AllowValue, Deny = perms.DenyValue, TargetId = role.Id, TargetType = PermissionTarget.Role })); _overwrites.Add(new Overwrite(new API.Overwrite { Allow = perms.AllowValue, Deny = perms.DenyValue, TargetId = role.Id, TargetType = PermissionTarget.Role }));
} }
public async Task RemovePermissionOverwriteAsync(IUser user) public async Task RemovePermissionOverwriteAsync(IUser user, RequestOptions options = null)
{ {
await ChannelHelper.RemovePermissionOverwriteAsync(this, Discord, user).ConfigureAwait(false); await ChannelHelper.RemovePermissionOverwriteAsync(this, Discord, user, options).ConfigureAwait(false);
for (int i = 0; i < _overwrites.Length; i++) for (int i = 0; i < _overwrites.Length; i++)
{ {
@@ -97,9 +100,9 @@ namespace Discord.Rest
} }
} }
} }
public async Task RemovePermissionOverwriteAsync(IRole role) public async Task RemovePermissionOverwriteAsync(IRole role, RequestOptions options = null)
{ {
await ChannelHelper.RemovePermissionOverwriteAsync(this, Discord, role).ConfigureAwait(false); await ChannelHelper.RemovePermissionOverwriteAsync(this, Discord, role, options).ConfigureAwait(false);
for (int i = 0; i < _overwrites.Length; i++) for (int i = 0; i < _overwrites.Length; i++)
{ {
@@ -111,41 +114,41 @@ namespace Discord.Rest
} }
} }
public async Task<IReadOnlyCollection<RestInviteMetadata>> GetInvitesAsync() public async Task<IReadOnlyCollection<RestInviteMetadata>> GetInvitesAsync(RequestOptions options = null)
=> await ChannelHelper.GetInvitesAsync(this, Discord); => await ChannelHelper.GetInvitesAsync(this, Discord, options);
public async Task<RestInviteMetadata> CreateInviteAsync(int? maxAge = 3600, int? maxUses = null, bool isTemporary = true) public async Task<RestInviteMetadata> CreateInviteAsync(int? maxAge = 3600, int? maxUses = null, bool isTemporary = true, RequestOptions options = null)
=> await ChannelHelper.CreateInviteAsync(this, Discord, maxAge, maxUses, isTemporary); => await ChannelHelper.CreateInviteAsync(this, Discord, maxAge, maxUses, isTemporary, options);
public override string ToString() => Name; public override string ToString() => Name;
//IGuildChannel //IGuildChannel
async Task<IReadOnlyCollection<IInviteMetadata>> IGuildChannel.GetInvitesAsync() async Task<IReadOnlyCollection<IInviteMetadata>> IGuildChannel.GetInvitesAsync(RequestOptions options)
=> await GetInvitesAsync(); => await GetInvitesAsync(options);
async Task<IInviteMetadata> IGuildChannel.CreateInviteAsync(int? maxAge, int? maxUses, bool isTemporary) async Task<IInviteMetadata> IGuildChannel.CreateInviteAsync(int? maxAge, int? maxUses, bool isTemporary, RequestOptions options)
=> await CreateInviteAsync(maxAge, maxUses, isTemporary); => await CreateInviteAsync(maxAge, maxUses, isTemporary, options);
OverwritePermissions? IGuildChannel.GetPermissionOverwrite(IRole role) OverwritePermissions? IGuildChannel.GetPermissionOverwrite(IRole role)
=> GetPermissionOverwrite(role); => GetPermissionOverwrite(role);
OverwritePermissions? IGuildChannel.GetPermissionOverwrite(IUser user) OverwritePermissions? IGuildChannel.GetPermissionOverwrite(IUser user)
=> GetPermissionOverwrite(user); => GetPermissionOverwrite(user);
async Task IGuildChannel.AddPermissionOverwriteAsync(IRole role, OverwritePermissions permissions) async Task IGuildChannel.AddPermissionOverwriteAsync(IRole role, OverwritePermissions permissions, RequestOptions options)
=> await AddPermissionOverwriteAsync(role, permissions); => await AddPermissionOverwriteAsync(role, permissions, options);
async Task IGuildChannel.AddPermissionOverwriteAsync(IUser user, OverwritePermissions permissions) async Task IGuildChannel.AddPermissionOverwriteAsync(IUser user, OverwritePermissions permissions, RequestOptions options)
=> await AddPermissionOverwriteAsync(user, permissions); => await AddPermissionOverwriteAsync(user, permissions, options);
async Task IGuildChannel.RemovePermissionOverwriteAsync(IRole role) async Task IGuildChannel.RemovePermissionOverwriteAsync(IRole role, RequestOptions options)
=> await RemovePermissionOverwriteAsync(role); => await RemovePermissionOverwriteAsync(role, options);
async Task IGuildChannel.RemovePermissionOverwriteAsync(IUser user) async Task IGuildChannel.RemovePermissionOverwriteAsync(IUser user, RequestOptions options)
=> await RemovePermissionOverwriteAsync(user); => await RemovePermissionOverwriteAsync(user, options);
IAsyncEnumerable<IReadOnlyCollection<IGuildUser>> IGuildChannel.GetUsersAsync(CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IGuildUser>> IGuildChannel.GetUsersAsync(CacheMode mode, RequestOptions options)
=> AsyncEnumerable.Empty<IReadOnlyCollection<IGuildUser>>(); //Overriden //Overriden in Text/Voice //TODO: Does this actually override? => AsyncEnumerable.Empty<IReadOnlyCollection<IGuildUser>>(); //Overriden //Overriden in Text/Voice //TODO: Does this actually override?
Task<IGuildUser> IGuildChannel.GetUserAsync(ulong id, CacheMode mode) Task<IGuildUser> IGuildChannel.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IGuildUser>(null); //Overriden in Text/Voice //TODO: Does this actually override? => Task.FromResult<IGuildUser>(null); //Overriden in Text/Voice //TODO: Does this actually override?
//IChannel //IChannel
IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode, RequestOptions options)
=> AsyncEnumerable.Empty<IReadOnlyCollection<IUser>>(); //Overriden in Text/Voice //TODO: Does this actually override? => AsyncEnumerable.Empty<IReadOnlyCollection<IUser>>(); //Overriden in Text/Voice //TODO: Does this actually override?
Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode) Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IUser>(null); //Overriden in Text/Voice //TODO: Does this actually override? => Task.FromResult<IUser>(null); //Overriden in Text/Voice //TODO: Does this actually override?
} }
} }

96
src/Discord.Net.Rest/Entities/Channels/RestTextChannel.cs
View File

@@ -34,95 +34,95 @@ namespace Discord.Rest
} }
public Task ModifyAsync(Action<ModifyTextChannelParams> func) public Task ModifyAsync(Action<ModifyTextChannelParams> func, RequestOptions options = null)
=> ChannelHelper.ModifyAsync(this, Discord, func); => ChannelHelper.ModifyAsync(this, Discord, func, options);
public Task<RestGuildUser> GetUserAsync(ulong id) public Task<RestGuildUser> GetUserAsync(ulong id, RequestOptions options = null)
=> ChannelHelper.GetUserAsync(this, Guild, Discord, id); => ChannelHelper.GetUserAsync(this, Guild, Discord, id, options);
public IAsyncEnumerable<IReadOnlyCollection<RestGuildUser>> GetUsersAsync() public IAsyncEnumerable<IReadOnlyCollection<RestGuildUser>> GetUsersAsync(RequestOptions options = null)
=> ChannelHelper.GetUsersAsync(this, Guild, Discord); => ChannelHelper.GetUsersAsync(this, Guild, Discord, null, null, options);
public Task<RestMessage> GetMessageAsync(ulong id) public Task<RestMessage> GetMessageAsync(ulong id, RequestOptions options = null)
=> ChannelHelper.GetMessageAsync(this, Discord, id); => ChannelHelper.GetMessageAsync(this, Discord, id, options);
public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> ChannelHelper.GetMessagesAsync(this, Discord, limit: limit); => ChannelHelper.GetMessagesAsync(this, Discord, null, Direction.Before, limit, options);
public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> ChannelHelper.GetMessagesAsync(this, Discord, fromMessageId, dir, limit); => ChannelHelper.GetMessagesAsync(this, Discord, fromMessageId, dir, limit, options);
public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> ChannelHelper.GetMessagesAsync(this, Discord, fromMessage.Id, dir, limit); => ChannelHelper.GetMessagesAsync(this, Discord, fromMessage.Id, dir, limit, options);
public Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync() public Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync(RequestOptions options = null)
=> ChannelHelper.GetPinnedMessagesAsync(this, Discord); => ChannelHelper.GetPinnedMessagesAsync(this, Discord, options);
public Task<RestUserMessage> SendMessageAsync(string text, bool isTTS) public Task<RestUserMessage> SendMessageAsync(string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendMessageAsync(this, Discord, text, isTTS); => ChannelHelper.SendMessageAsync(this, Discord, text, isTTS, options);
public Task<RestUserMessage> SendFileAsync(string filePath, string text, bool isTTS) public Task<RestUserMessage> SendFileAsync(string filePath, string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendFileAsync(this, Discord, filePath, text, isTTS); => ChannelHelper.SendFileAsync(this, Discord, filePath, text, isTTS, options);
public Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text, bool isTTS) public Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendFileAsync(this, Discord, stream, filename, text, isTTS); => ChannelHelper.SendFileAsync(this, Discord, stream, filename, text, isTTS, options);
public Task DeleteMessagesAsync(IEnumerable<IMessage> messages) public Task DeleteMessagesAsync(IEnumerable<IMessage> messages, RequestOptions options = null)
=> ChannelHelper.DeleteMessagesAsync(this, Discord, messages); => ChannelHelper.DeleteMessagesAsync(this, Discord, messages, options);
public IDisposable EnterTypingState() public IDisposable EnterTypingState(RequestOptions options = null)
=> ChannelHelper.EnterTypingState(this, Discord); => ChannelHelper.EnterTypingState(this, Discord, options);
private string DebuggerDisplay => $"{Name} ({Id}, Text)"; private string DebuggerDisplay => $"{Name} ({Id}, Text)";
//IGuildChannel //IGuildChannel
async Task<IGuildUser> IGuildChannel.GetUserAsync(ulong id, CacheMode mode) async Task<IGuildUser> IGuildChannel.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetUserAsync(id); return await GetUserAsync(id, options);
else else
return null; return null;
} }
IAsyncEnumerable<IReadOnlyCollection<IGuildUser>> IGuildChannel.GetUsersAsync(CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IGuildUser>> IGuildChannel.GetUsersAsync(CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return GetUsersAsync(); return GetUsersAsync(options);
else else
return AsyncEnumerable.Empty<IReadOnlyCollection<IGuildUser>>(); //Overriden return AsyncEnumerable.Empty<IReadOnlyCollection<IGuildUser>>(); //Overriden
} }
//IMessageChannel //IMessageChannel
async Task<IMessage> IMessageChannel.GetMessageAsync(ulong id, CacheMode mode) async Task<IMessage> IMessageChannel.GetMessageAsync(ulong id, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetMessageAsync(id); return await GetMessageAsync(id, options);
else else
return null; return null;
} }
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(int limit, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return GetMessagesAsync(limit); return GetMessagesAsync(limit, options);
else else
return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>(); return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>();
} }
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(ulong fromMessageId, Direction dir, int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(ulong fromMessageId, Direction dir, int limit, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return GetMessagesAsync(fromMessageId, dir, limit); return GetMessagesAsync(fromMessageId, dir, limit, options);
else else
return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>(); return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>();
} }
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(IMessage fromMessage, Direction dir, int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(IMessage fromMessage, Direction dir, int limit, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return GetMessagesAsync(fromMessage, dir, limit); return GetMessagesAsync(fromMessage, dir, limit, options);
else else
return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>(); return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>();
} }
async Task<IReadOnlyCollection<IMessage>> IMessageChannel.GetPinnedMessagesAsync() async Task<IReadOnlyCollection<IMessage>> IMessageChannel.GetPinnedMessagesAsync(RequestOptions options)
=> await GetPinnedMessagesAsync(); => await GetPinnedMessagesAsync(options);
async Task<IUserMessage> IMessageChannel.SendFileAsync(string filePath, string text, bool isTTS) async Task<IUserMessage> IMessageChannel.SendFileAsync(string filePath, string text, bool isTTS, RequestOptions options)
=> await SendFileAsync(filePath, text, isTTS); => await SendFileAsync(filePath, text, isTTS, options);
async Task<IUserMessage> IMessageChannel.SendFileAsync(Stream stream, string filename, string text, bool isTTS) async Task<IUserMessage> IMessageChannel.SendFileAsync(Stream stream, string filename, string text, bool isTTS, RequestOptions options)
=> await SendFileAsync(stream, filename, text, isTTS); => await SendFileAsync(stream, filename, text, isTTS, options);
async Task<IUserMessage> IMessageChannel.SendMessageAsync(string text, bool isTTS) async Task<IUserMessage> IMessageChannel.SendMessageAsync(string text, bool isTTS, RequestOptions options)
=> await SendMessageAsync(text, isTTS); => await SendMessageAsync(text, isTTS, options);
IDisposable IMessageChannel.EnterTypingState() IDisposable IMessageChannel.EnterTypingState(RequestOptions options)
=> EnterTypingState(); => EnterTypingState(options);
} }
} }

8
src/Discord.Net.Rest/Entities/Channels/RestVoiceChannel.cs
View File

@@ -33,8 +33,8 @@ namespace Discord.Rest
UserLimit = model.UserLimit.Value; UserLimit = model.UserLimit.Value;
} }
public Task ModifyAsync(Action<ModifyVoiceChannelParams> func) public Task ModifyAsync(Action<ModifyVoiceChannelParams> func, RequestOptions options = null)
=> ChannelHelper.ModifyAsync(this, Discord, func); => ChannelHelper.ModifyAsync(this, Discord, func, options);
private string DebuggerDisplay => $"{Name} ({Id}, Voice)"; private string DebuggerDisplay => $"{Name} ({Id}, Voice)";
@@ -42,9 +42,9 @@ namespace Discord.Rest
Task<IAudioClient> IVoiceChannel.ConnectAsync() { throw new NotSupportedException(); } Task<IAudioClient> IVoiceChannel.ConnectAsync() { throw new NotSupportedException(); }
//IGuildChannel //IGuildChannel
Task<IGuildUser> IGuildChannel.GetUserAsync(ulong id, CacheMode mode) Task<IGuildUser> IGuildChannel.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IGuildUser>(null); => Task.FromResult<IGuildUser>(null);
IAsyncEnumerable<IReadOnlyCollection<IGuildUser>> IGuildChannel.GetUsersAsync(CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IGuildUser>> IGuildChannel.GetUsersAsync(CacheMode mode, RequestOptions options)
=> AsyncEnumerable.Empty<IReadOnlyCollection<IGuildUser>>(); => AsyncEnumerable.Empty<IReadOnlyCollection<IGuildUser>>();
} }
} }

95
src/Discord.Net.Rest/Entities/Guilds/GuildHelper.cs
View File

@@ -14,7 +14,7 @@ namespace Discord.Rest
{ {
//General //General
public static async Task<Model> ModifyAsync(IGuild guild, BaseDiscordClient client, public static async Task<Model> ModifyAsync(IGuild guild, BaseDiscordClient client,
Action<ModifyGuildParams> func) Action<ModifyGuildParams> func, RequestOptions options)
{ {
if (func == null) throw new NullReferenceException(nameof(func)); if (func == null) throw new NullReferenceException(nameof(func));
@@ -26,116 +26,122 @@ namespace Discord.Rest
if (args.Icon.IsSpecified && guild.IconId != null) if (args.Icon.IsSpecified && guild.IconId != null)
args.Icon = new API.Image(guild.IconId); args.Icon = new API.Image(guild.IconId);
return await client.ApiClient.ModifyGuildAsync(guild.Id, args).ConfigureAwait(false); return await client.ApiClient.ModifyGuildAsync(guild.Id, args, options).ConfigureAwait(false);
} }
public static async Task<EmbedModel> ModifyEmbedAsync(IGuild guild, BaseDiscordClient client, public static async Task<EmbedModel> ModifyEmbedAsync(IGuild guild, BaseDiscordClient client,
Action<ModifyGuildEmbedParams> func) Action<ModifyGuildEmbedParams> func, RequestOptions options)
{ {
if (func == null) throw new NullReferenceException(nameof(func)); if (func == null) throw new NullReferenceException(nameof(func));
var args = new ModifyGuildEmbedParams(); var args = new ModifyGuildEmbedParams();
func(args); func(args);
return await client.ApiClient.ModifyGuildEmbedAsync(guild.Id, args).ConfigureAwait(false); return await client.ApiClient.ModifyGuildEmbedAsync(guild.Id, args, options).ConfigureAwait(false);
} }
public static async Task ModifyChannelsAsync(IGuild guild, BaseDiscordClient client, public static async Task ModifyChannelsAsync(IGuild guild, BaseDiscordClient client,
IEnumerable<ModifyGuildChannelsParams> args) IEnumerable<ModifyGuildChannelsParams> args, RequestOptions options)
{ {
await client.ApiClient.ModifyGuildChannelsAsync(guild.Id, args).ConfigureAwait(false); await client.ApiClient.ModifyGuildChannelsAsync(guild.Id, args, options).ConfigureAwait(false);
} }
public static async Task<IReadOnlyCollection<RoleModel>> ModifyRolesAsync(IGuild guild, BaseDiscordClient client, public static async Task<IReadOnlyCollection<RoleModel>> ModifyRolesAsync(IGuild guild, BaseDiscordClient client,
IEnumerable<ModifyGuildRolesParams> args) IEnumerable<ModifyGuildRolesParams> args, RequestOptions options)
{ {
return await client.ApiClient.ModifyGuildRolesAsync(guild.Id, args).ConfigureAwait(false); return await client.ApiClient.ModifyGuildRolesAsync(guild.Id, args, options).ConfigureAwait(false);
} }
public static async Task LeaveAsync(IGuild guild, BaseDiscordClient client) public static async Task LeaveAsync(IGuild guild, BaseDiscordClient client,
RequestOptions options)
{ {
await client.ApiClient.LeaveGuildAsync(guild.Id).ConfigureAwait(false); await client.ApiClient.LeaveGuildAsync(guild.Id, options).ConfigureAwait(false);
} }
public static async Task DeleteAsync(IGuild guild, BaseDiscordClient client) public static async Task DeleteAsync(IGuild guild, BaseDiscordClient client,
RequestOptions options)
{ {
await client.ApiClient.DeleteGuildAsync(guild.Id).ConfigureAwait(false); await client.ApiClient.DeleteGuildAsync(guild.Id, options).ConfigureAwait(false);
} }
//Bans //Bans
public static async Task<IReadOnlyCollection<RestBan>> GetBansAsync(IGuild guild, BaseDiscordClient client) public static async Task<IReadOnlyCollection<RestBan>> GetBansAsync(IGuild guild, BaseDiscordClient client,
RequestOptions options)
{ {
var models = await client.ApiClient.GetGuildBansAsync(guild.Id); var models = await client.ApiClient.GetGuildBansAsync(guild.Id, options);
return models.Select(x => RestBan.Create(client, x)).ToImmutableArray(); return models.Select(x => RestBan.Create(client, x)).ToImmutableArray();
} }
public static async Task AddBanAsync(IGuild guild, BaseDiscordClient client, public static async Task AddBanAsync(IGuild guild, BaseDiscordClient client,
ulong userId, int pruneDays) ulong userId, int pruneDays, RequestOptions options)
{ {
var args = new CreateGuildBanParams { DeleteMessageDays = pruneDays }; var args = new CreateGuildBanParams { DeleteMessageDays = pruneDays };
await client.ApiClient.CreateGuildBanAsync(guild.Id, userId, args); await client.ApiClient.CreateGuildBanAsync(guild.Id, userId, args, options);
} }
public static async Task RemoveBanAsync(IGuild guild, BaseDiscordClient client, public static async Task RemoveBanAsync(IGuild guild, BaseDiscordClient client,
ulong userId) ulong userId, RequestOptions options)
{ {
await client.ApiClient.RemoveGuildBanAsync(guild.Id, userId); await client.ApiClient.RemoveGuildBanAsync(guild.Id, userId, options);
} }
//Channels //Channels
public static async Task<RestGuildChannel> GetChannelAsync(IGuild guild, BaseDiscordClient client, public static async Task<RestGuildChannel> GetChannelAsync(IGuild guild, BaseDiscordClient client,
ulong id) ulong id, RequestOptions options)
{ {
var model = await client.ApiClient.GetChannelAsync(guild.Id, id).ConfigureAwait(false); var model = await client.ApiClient.GetChannelAsync(guild.Id, id, options).ConfigureAwait(false);
if (model != null) if (model != null)
return RestGuildChannel.Create(client, guild, model); return RestGuildChannel.Create(client, guild, model);
return null; return null;
} }
public static async Task<IReadOnlyCollection<RestGuildChannel>> GetChannelsAsync(IGuild guild, BaseDiscordClient client) public static async Task<IReadOnlyCollection<RestGuildChannel>> GetChannelsAsync(IGuild guild, BaseDiscordClient client,
RequestOptions options)
{ {
var models = await client.ApiClient.GetGuildChannelsAsync(guild.Id).ConfigureAwait(false); var models = await client.ApiClient.GetGuildChannelsAsync(guild.Id, options).ConfigureAwait(false);
return models.Select(x => RestGuildChannel.Create(client, guild, x)).ToImmutableArray(); return models.Select(x => RestGuildChannel.Create(client, guild, x)).ToImmutableArray();
} }
public static async Task<RestTextChannel> CreateTextChannelAsync(IGuild guild, BaseDiscordClient client, public static async Task<RestTextChannel> CreateTextChannelAsync(IGuild guild, BaseDiscordClient client,
string name) string name, RequestOptions options)
{ {
if (name == null) throw new ArgumentNullException(nameof(name)); if (name == null) throw new ArgumentNullException(nameof(name));
var args = new CreateGuildChannelParams(name, ChannelType.Text); var args = new CreateGuildChannelParams(name, ChannelType.Text);
var model = await client.ApiClient.CreateGuildChannelAsync(guild.Id, args).ConfigureAwait(false); var model = await client.ApiClient.CreateGuildChannelAsync(guild.Id, args, options).ConfigureAwait(false);
return RestTextChannel.Create(client, guild, model); return RestTextChannel.Create(client, guild, model);
} }
public static async Task<RestVoiceChannel> CreateVoiceChannelAsync(IGuild guild, BaseDiscordClient client, public static async Task<RestVoiceChannel> CreateVoiceChannelAsync(IGuild guild, BaseDiscordClient client,
string name) string name, RequestOptions options)
{ {
if (name == null) throw new ArgumentNullException(nameof(name)); if (name == null) throw new ArgumentNullException(nameof(name));
var args = new CreateGuildChannelParams(name, ChannelType.Voice); var args = new CreateGuildChannelParams(name, ChannelType.Voice);
var model = await client.ApiClient.CreateGuildChannelAsync(guild.Id, args).ConfigureAwait(false); var model = await client.ApiClient.CreateGuildChannelAsync(guild.Id, args, options).ConfigureAwait(false);
return RestVoiceChannel.Create(client, guild, model); return RestVoiceChannel.Create(client, guild, model);
} }
//Integrations //Integrations
public static async Task<IReadOnlyCollection<RestGuildIntegration>> GetIntegrationsAsync(IGuild guild, BaseDiscordClient client) public static async Task<IReadOnlyCollection<RestGuildIntegration>> GetIntegrationsAsync(IGuild guild, BaseDiscordClient client,
RequestOptions options)
{ {
var models = await client.ApiClient.GetGuildIntegrationsAsync(guild.Id).ConfigureAwait(false); var models = await client.ApiClient.GetGuildIntegrationsAsync(guild.Id, options).ConfigureAwait(false);
return models.Select(x => RestGuildIntegration.Create(client, x)).ToImmutableArray(); return models.Select(x => RestGuildIntegration.Create(client, x)).ToImmutableArray();
} }
public static async Task<RestGuildIntegration> CreateIntegrationAsync(IGuild guild, BaseDiscordClient client, public static async Task<RestGuildIntegration> CreateIntegrationAsync(IGuild guild, BaseDiscordClient client,
ulong id, string type) ulong id, string type, RequestOptions options)
{ {
var args = new CreateGuildIntegrationParams(id, type); var args = new CreateGuildIntegrationParams(id, type);
var model = await client.ApiClient.CreateGuildIntegrationAsync(guild.Id, args).ConfigureAwait(false); var model = await client.ApiClient.CreateGuildIntegrationAsync(guild.Id, args, options).ConfigureAwait(false);
return RestGuildIntegration.Create(client, model); return RestGuildIntegration.Create(client, model);
} }
//Invites //Invites
public static async Task<IReadOnlyCollection<RestInviteMetadata>> GetInvitesAsync(IGuild guild, BaseDiscordClient client) public static async Task<IReadOnlyCollection<RestInviteMetadata>> GetInvitesAsync(IGuild guild, BaseDiscordClient client,
RequestOptions options)
{ {
var models = await client.ApiClient.GetGuildInvitesAsync(guild.Id).ConfigureAwait(false); var models = await client.ApiClient.GetGuildInvitesAsync(guild.Id, options).ConfigureAwait(false);
return models.Select(x => RestInviteMetadata.Create(client, x)).ToImmutableArray(); return models.Select(x => RestInviteMetadata.Create(client, x)).ToImmutableArray();
} }
//Roles //Roles
public static async Task<RestRole> CreateRoleAsync(IGuild guild, BaseDiscordClient client, public static async Task<RestRole> CreateRoleAsync(IGuild guild, BaseDiscordClient client,
string name, GuildPermissions? permissions = null, Color? color = null, bool isHoisted = false) string name, GuildPermissions? permissions, Color? color, bool isHoisted, RequestOptions options)
{ {
if (name == null) throw new ArgumentNullException(nameof(name)); if (name == null) throw new ArgumentNullException(nameof(name));
var model = await client.ApiClient.CreateGuildRoleAsync(guild.Id).ConfigureAwait(false); var model = await client.ApiClient.CreateGuildRoleAsync(guild.Id, options).ConfigureAwait(false);
var role = RestRole.Create(client, model); var role = RestRole.Create(client, model);
await role.ModifyAsync(x => await role.ModifyAsync(x =>
@@ -144,26 +150,27 @@ namespace Discord.Rest
x.Permissions = (permissions ?? role.Permissions).RawValue; x.Permissions = (permissions ?? role.Permissions).RawValue;
x.Color = (color ?? Color.Default).RawValue; x.Color = (color ?? Color.Default).RawValue;
x.Hoist = isHoisted; x.Hoist = isHoisted;
}).ConfigureAwait(false); }, options).ConfigureAwait(false);
return role; return role;
} }
//Users //Users
public static async Task<RestGuildUser> GetUserAsync(IGuild guild, BaseDiscordClient client, public static async Task<RestGuildUser> GetUserAsync(IGuild guild, BaseDiscordClient client,
ulong id) ulong id, RequestOptions options)
{ {
var model = await client.ApiClient.GetGuildMemberAsync(guild.Id, id).ConfigureAwait(false); var model = await client.ApiClient.GetGuildMemberAsync(guild.Id, id, options).ConfigureAwait(false);
if (model != null) if (model != null)
return RestGuildUser.Create(client, guild, model); return RestGuildUser.Create(client, guild, model);
return null; return null;
} }
public static async Task<RestGuildUser> GetCurrentUserAsync(IGuild guild, BaseDiscordClient client) public static async Task<RestGuildUser> GetCurrentUserAsync(IGuild guild, BaseDiscordClient client,
RequestOptions options)
{ {
return await GetUserAsync(guild, client, client.CurrentUser.Id).ConfigureAwait(false); return await GetUserAsync(guild, client, client.CurrentUser.Id, options).ConfigureAwait(false);
} }
public static IAsyncEnumerable<IReadOnlyCollection<RestGuildUser>> GetUsersAsync(IGuild guild, BaseDiscordClient client, public static IAsyncEnumerable<IReadOnlyCollection<RestGuildUser>> GetUsersAsync(IGuild guild, BaseDiscordClient client,
ulong? fromUserId = null, int limit = DiscordConfig.MaxMessagesPerBatch) ulong? fromUserId, int? limit, RequestOptions options)
{ {
return new PagedAsyncEnumerable<RestGuildUser>( return new PagedAsyncEnumerable<RestGuildUser>(
DiscordConfig.MaxMessagesPerBatch, DiscordConfig.MaxMessagesPerBatch,
@@ -175,7 +182,7 @@ namespace Discord.Rest
}; };
if (info.Position != null) if (info.Position != null)
args.AfterUserId = info.Position.Value; args.AfterUserId = info.Position.Value;
var models = await client.ApiClient.GetGuildMembersAsync(guild.Id, args); var models = await client.ApiClient.GetGuildMembersAsync(guild.Id, args, options);
return models.Select(x => RestGuildUser.Create(client, guild, x)).ToImmutableArray(); return models.Select(x => RestGuildUser.Create(client, guild, x)).ToImmutableArray();
}, },
nextPage: (info, lastPage) => nextPage: (info, lastPage) =>
@@ -189,14 +196,14 @@ namespace Discord.Rest
); );
} }
public static async Task<int> PruneUsersAsync(IGuild guild, BaseDiscordClient client, public static async Task<int> PruneUsersAsync(IGuild guild, BaseDiscordClient client,
int days = 30, bool simulate = false) int days, bool simulate, RequestOptions options)
{ {
var args = new GuildPruneParams(days); var args = new GuildPruneParams(days);
GetGuildPruneCountResponse model; GetGuildPruneCountResponse model;
if (simulate) if (simulate)
model = await client.ApiClient.GetGuildPruneCountAsync(guild.Id, args).ConfigureAwait(false); model = await client.ApiClient.GetGuildPruneCountAsync(guild.Id, args, options).ConfigureAwait(false);
else else
model = await client.ApiClient.BeginGuildPruneAsync(guild.Id, args).ConfigureAwait(false); model = await client.ApiClient.BeginGuildPruneAsync(guild.Id, args, options).ConfigureAwait(false);
return model.Pruned; return model.Pruned;
} }
} }

146
src/Discord.Net.Rest/Entities/Guilds/RestGuild.cs
View File

@@ -4,7 +4,6 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Collections.Immutable; using System.Collections.Immutable;
using System.Diagnostics; using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks; using System.Threading.Tasks;
using Model = Discord.API.Guild; using Model = Discord.API.Guild;
@@ -93,56 +92,56 @@ namespace Discord.Rest
} }
//General //General
public async Task UpdateAsync() public async Task UpdateAsync(RequestOptions options = null)
=> Update(await Discord.ApiClient.GetGuildAsync(Id)); => Update(await Discord.ApiClient.GetGuildAsync(Id, options));
public Task DeleteAsync() public Task DeleteAsync(RequestOptions options = null)
=> GuildHelper.DeleteAsync(this, Discord); => GuildHelper.DeleteAsync(this, Discord, options);
public Task ModifyAsync(Action<ModifyGuildParams> func) public Task ModifyAsync(Action<ModifyGuildParams> func, RequestOptions options = null)
=> GuildHelper.ModifyAsync(this, Discord, func); => GuildHelper.ModifyAsync(this, Discord, func, options);
public Task ModifyEmbedAsync(Action<ModifyGuildEmbedParams> func) public Task ModifyEmbedAsync(Action<ModifyGuildEmbedParams> func, RequestOptions options = null)
=> GuildHelper.ModifyEmbedAsync(this, Discord, func); => GuildHelper.ModifyEmbedAsync(this, Discord, func, options);
public Task ModifyChannelsAsync(IEnumerable<ModifyGuildChannelsParams> args) public Task ModifyChannelsAsync(IEnumerable<ModifyGuildChannelsParams> args, RequestOptions options = null)
=> GuildHelper.ModifyChannelsAsync(this, Discord, args); => GuildHelper.ModifyChannelsAsync(this, Discord, args, options);
public Task ModifyRolesAsync(IEnumerable<ModifyGuildRolesParams> args) public Task ModifyRolesAsync(IEnumerable<ModifyGuildRolesParams> args, RequestOptions options = null)
=> GuildHelper.ModifyRolesAsync(this, Discord, args); => GuildHelper.ModifyRolesAsync(this, Discord, args, options);
public Task LeaveAsync() public Task LeaveAsync(RequestOptions options = null)
=> GuildHelper.LeaveAsync(this, Discord); => GuildHelper.LeaveAsync(this, Discord, options);
//Bans //Bans
public Task<IReadOnlyCollection<RestBan>> GetBansAsync() public Task<IReadOnlyCollection<RestBan>> GetBansAsync(RequestOptions options = null)
=> GuildHelper.GetBansAsync(this, Discord); => GuildHelper.GetBansAsync(this, Discord, options);
public Task AddBanAsync(IUser user, int pruneDays = 0) public Task AddBanAsync(IUser user, int pruneDays = 0, RequestOptions options = null)
=> GuildHelper.AddBanAsync(this, Discord, user.Id, pruneDays); => GuildHelper.AddBanAsync(this, Discord, user.Id, pruneDays, options);
public Task AddBanAsync(ulong userId, int pruneDays = 0) public Task AddBanAsync(ulong userId, int pruneDays = 0, RequestOptions options = null)
=> GuildHelper.AddBanAsync(this, Discord, userId, pruneDays); => GuildHelper.AddBanAsync(this, Discord, userId, pruneDays, options);
public Task RemoveBanAsync(IUser user) public Task RemoveBanAsync(IUser user, RequestOptions options = null)
=> GuildHelper.RemoveBanAsync(this, Discord, user.Id); => GuildHelper.RemoveBanAsync(this, Discord, user.Id, options);
public Task RemoveBanAsync(ulong userId) public Task RemoveBanAsync(ulong userId, RequestOptions options = null)
=> GuildHelper.RemoveBanAsync(this, Discord, userId); => GuildHelper.RemoveBanAsync(this, Discord, userId, options);
//Channels //Channels
public Task<IReadOnlyCollection<RestGuildChannel>> GetChannelsAsync() public Task<IReadOnlyCollection<RestGuildChannel>> GetChannelsAsync(RequestOptions options = null)
=> GuildHelper.GetChannelsAsync(this, Discord); => GuildHelper.GetChannelsAsync(this, Discord, options);
public Task<RestGuildChannel> GetChannelAsync(ulong id) public Task<RestGuildChannel> GetChannelAsync(ulong id, RequestOptions options = null)
=> GuildHelper.GetChannelAsync(this, Discord, id); => GuildHelper.GetChannelAsync(this, Discord, id, options);
public Task<RestTextChannel> CreateTextChannelAsync(string name) public Task<RestTextChannel> CreateTextChannelAsync(string name, RequestOptions options = null)
=> GuildHelper.CreateTextChannelAsync(this, Discord, name); => GuildHelper.CreateTextChannelAsync(this, Discord, name, options);
public Task<RestVoiceChannel> CreateVoiceChannelAsync(string name) public Task<RestVoiceChannel> CreateVoiceChannelAsync(string name, RequestOptions options = null)
=> GuildHelper.CreateVoiceChannelAsync(this, Discord, name); => GuildHelper.CreateVoiceChannelAsync(this, Discord, name, options);
//Integrations //Integrations
public Task<IReadOnlyCollection<RestGuildIntegration>> GetIntegrationsAsync() public Task<IReadOnlyCollection<RestGuildIntegration>> GetIntegrationsAsync(RequestOptions options = null)
=> GuildHelper.GetIntegrationsAsync(this, Discord); => GuildHelper.GetIntegrationsAsync(this, Discord, options);
public Task<RestGuildIntegration> CreateIntegrationAsync(ulong id, string type) public Task<RestGuildIntegration> CreateIntegrationAsync(ulong id, string type, RequestOptions options = null)
=> GuildHelper.CreateIntegrationAsync(this, Discord, id, type); => GuildHelper.CreateIntegrationAsync(this, Discord, id, type, options);
//Invites //Invites
public Task<IReadOnlyCollection<RestInviteMetadata>> GetInvitesAsync() public Task<IReadOnlyCollection<RestInviteMetadata>> GetInvitesAsync(RequestOptions options = null)
=> GuildHelper.GetInvitesAsync(this, Discord); => GuildHelper.GetInvitesAsync(this, Discord, options);
//Roles //Roles
public RestRole GetRole(ulong id) public RestRole GetRole(ulong id)
@@ -153,23 +152,24 @@ namespace Discord.Rest
return null; return null;
} }
public async Task<RestRole> CreateRoleAsync(string name, GuildPermissions? permissions = default(GuildPermissions?), Color? color = default(Color?), bool isHoisted = false) public async Task<RestRole> CreateRoleAsync(string name, GuildPermissions? permissions = default(GuildPermissions?), Color? color = default(Color?),
bool isHoisted = false, RequestOptions options = null)
{ {
var role = await GuildHelper.CreateRoleAsync(this, Discord, name, permissions, color, isHoisted); var role = await GuildHelper.CreateRoleAsync(this, Discord, name, permissions, color, isHoisted, options);
_roles = _roles.Add(role.Id, role); _roles = _roles.Add(role.Id, role);
return role; return role;
} }
//Users //Users
public IAsyncEnumerable<IReadOnlyCollection<RestGuildUser>> GetUsersAsync() public IAsyncEnumerable<IReadOnlyCollection<RestGuildUser>> GetUsersAsync(RequestOptions options = null)
=> GuildHelper.GetUsersAsync(this, Discord); => GuildHelper.GetUsersAsync(this, Discord, null, null, options);
public Task<RestGuildUser> GetUserAsync(ulong id) public Task<RestGuildUser> GetUserAsync(ulong id, RequestOptions options = null)
=> GuildHelper.GetUserAsync(this, Discord, id); => GuildHelper.GetUserAsync(this, Discord, id, options);
public Task<RestGuildUser> GetCurrentUserAsync() public Task<RestGuildUser> GetCurrentUserAsync(RequestOptions options = null)
=> GuildHelper.GetUserAsync(this, Discord, Discord.CurrentUser.Id); => GuildHelper.GetUserAsync(this, Discord, Discord.CurrentUser.Id, options);
public Task<int> PruneUsersAsync(int days = 30, bool simulate = false) public Task<int> PruneUsersAsync(int days = 30, bool simulate = false, RequestOptions options = null)
=> GuildHelper.PruneUsersAsync(this, Discord, days, simulate); => GuildHelper.PruneUsersAsync(this, Discord, days, simulate, options);
public override string ToString() => Name; public override string ToString() => Name;
private string DebuggerDisplay => $"{Name} ({Id})"; private string DebuggerDisplay => $"{Name} ({Id})";
@@ -180,59 +180,59 @@ namespace Discord.Rest
IRole IGuild.EveryoneRole => EveryoneRole; IRole IGuild.EveryoneRole => EveryoneRole;
IReadOnlyCollection<IRole> IGuild.Roles => Roles; IReadOnlyCollection<IRole> IGuild.Roles => Roles;
async Task<IReadOnlyCollection<IBan>> IGuild.GetBansAsync() async Task<IReadOnlyCollection<IBan>> IGuild.GetBansAsync(RequestOptions options)
=> await GetBansAsync(); => await GetBansAsync(options);
async Task<IReadOnlyCollection<IGuildChannel>> IGuild.GetChannelsAsync(CacheMode mode) async Task<IReadOnlyCollection<IGuildChannel>> IGuild.GetChannelsAsync(CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetChannelsAsync(); return await GetChannelsAsync(options);
else else
return ImmutableArray.Create<IGuildChannel>(); return ImmutableArray.Create<IGuildChannel>();
} }
async Task<IGuildChannel> IGuild.GetChannelAsync(ulong id, CacheMode mode) async Task<IGuildChannel> IGuild.GetChannelAsync(ulong id, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetChannelAsync(id); return await GetChannelAsync(id, options);
else else
return null; return null;
} }
async Task<ITextChannel> IGuild.CreateTextChannelAsync(string name) async Task<ITextChannel> IGuild.CreateTextChannelAsync(string name, RequestOptions options)
=> await CreateTextChannelAsync(name); => await CreateTextChannelAsync(name, options);
async Task<IVoiceChannel> IGuild.CreateVoiceChannelAsync(string name) async Task<IVoiceChannel> IGuild.CreateVoiceChannelAsync(string name, RequestOptions options)
=> await CreateVoiceChannelAsync(name); => await CreateVoiceChannelAsync(name, options);
async Task<IReadOnlyCollection<IGuildIntegration>> IGuild.GetIntegrationsAsync() async Task<IReadOnlyCollection<IGuildIntegration>> IGuild.GetIntegrationsAsync(RequestOptions options)
=> await GetIntegrationsAsync(); => await GetIntegrationsAsync(options);
async Task<IGuildIntegration> IGuild.CreateIntegrationAsync(ulong id, string type) async Task<IGuildIntegration> IGuild.CreateIntegrationAsync(ulong id, string type, RequestOptions options)
=> await CreateIntegrationAsync(id, type); => await CreateIntegrationAsync(id, type, options);
async Task<IReadOnlyCollection<IInviteMetadata>> IGuild.GetInvitesAsync() async Task<IReadOnlyCollection<IInviteMetadata>> IGuild.GetInvitesAsync(RequestOptions options)
=> await GetInvitesAsync(); => await GetInvitesAsync(options);
IRole IGuild.GetRole(ulong id) IRole IGuild.GetRole(ulong id)
=> GetRole(id); => GetRole(id);
async Task<IRole> IGuild.CreateRoleAsync(string name, GuildPermissions? permissions, Color? color, bool isHoisted) async Task<IRole> IGuild.CreateRoleAsync(string name, GuildPermissions? permissions, Color? color, bool isHoisted, RequestOptions options)
=> await CreateRoleAsync(name, permissions, color, isHoisted); => await CreateRoleAsync(name, permissions, color, isHoisted, options);
async Task<IGuildUser> IGuild.GetUserAsync(ulong id, CacheMode mode) async Task<IGuildUser> IGuild.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetUserAsync(id); return await GetUserAsync(id, options);
else else
return null; return null;
} }
async Task<IGuildUser> IGuild.GetCurrentUserAsync(CacheMode mode) async Task<IGuildUser> IGuild.GetCurrentUserAsync(CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetCurrentUserAsync(); return await GetCurrentUserAsync(options);
else else
return null; return null;
} }
async Task<IReadOnlyCollection<IGuildUser>> IGuild.GetUsersAsync(CacheMode mode) async Task<IReadOnlyCollection<IGuildUser>> IGuild.GetUsersAsync(CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return (await GetUsersAsync().Flatten()).ToImmutableArray(); return (await GetUsersAsync(options).Flatten()).ToImmutableArray();
else else
return ImmutableArray.Create<IGuildUser>(); return ImmutableArray.Create<IGuildUser>();
} }

8
src/Discord.Net.Rest/Entities/Guilds/RestUserGuild.cs
View File

@@ -34,13 +34,13 @@ namespace Discord.Rest
Permissions = new GuildPermissions(model.Permissions); Permissions = new GuildPermissions(model.Permissions);
} }
public async Task LeaveAsync() public async Task LeaveAsync(RequestOptions options = null)
{ {
await Discord.ApiClient.LeaveGuildAsync(Id).ConfigureAwait(false); await Discord.ApiClient.LeaveGuildAsync(Id, options).ConfigureAwait(false);
} }
public async Task DeleteAsync() public async Task DeleteAsync(RequestOptions options = null)
{ {
await Discord.ApiClient.DeleteGuildAsync(Id).ConfigureAwait(false); await Discord.ApiClient.DeleteGuildAsync(Id, options).ConfigureAwait(false);
} }
public override string ToString() => Name; public override string ToString() => Name;

14
src/Discord.Net.Rest/Entities/Invites/InviteHelper.cs
View File

@@ -5,17 +5,15 @@ namespace Discord.Rest
{ {
internal static class InviteHelper internal static class InviteHelper
{ {
public static async Task<Model> GetAsync(IInvite invite, BaseDiscordClient client) public static async Task AcceptAsync(IInvite invite, BaseDiscordClient client,
RequestOptions options)
{ {
return await client.ApiClient.GetInviteAsync(invite.Code).ConfigureAwait(false); await client.ApiClient.AcceptInviteAsync(invite.Code, options).ConfigureAwait(false);
} }
public static async Task AcceptAsync(IInvite invite, BaseDiscordClient client) public static async Task DeleteAsync(IInvite invite, BaseDiscordClient client,
RequestOptions options)
{ {
await client.ApiClient.AcceptInviteAsync(invite.Code).ConfigureAwait(false); await client.ApiClient.DeleteInviteAsync(invite.Code, options).ConfigureAwait(false);
}
public static async Task DeleteAsync(IInvite invite, BaseDiscordClient client)
{
await client.ApiClient.DeleteInviteAsync(invite.Code).ConfigureAwait(false);
} }
} }
} }

17
src/Discord.Net.Rest/Entities/Invites/RestInvite.cs
View File

@@ -32,14 +32,17 @@ namespace Discord.Rest
GuildName = model.Guild.Name; GuildName = model.Guild.Name;
ChannelName = model.Channel.Name; ChannelName = model.Channel.Name;
} }
public async Task UpdateAsync(RequestOptions options = null)
{
var model = await Discord.ApiClient.GetInviteAsync(Code, options);
Update(model);
}
public Task DeleteAsync(RequestOptions options = null)
=> InviteHelper.DeleteAsync(this, Discord, options);
public async Task UpdateAsync() public Task AcceptAsync(RequestOptions options = null)
=> Update(await InviteHelper.GetAsync(this, Discord).ConfigureAwait(false)); => InviteHelper.AcceptAsync(this, Discord, options);
public Task DeleteAsync()
=> InviteHelper.DeleteAsync(this, Discord);
public Task AcceptAsync()
=> InviteHelper.AcceptAsync(this, Discord);
public override string ToString() => Url; public override string ToString() => Url;
private string DebuggerDisplay => $"{Url} ({GuildName} / {ChannelName})"; private string DebuggerDisplay => $"{Url} ({GuildName} / {ChannelName})";

24
src/Discord.Net.Rest/Entities/Messages/MessageHelper.cs
View File

@@ -6,28 +6,28 @@ namespace Discord.Rest
{ {
internal static class MessageHelper internal static class MessageHelper
{ {
public static async Task GetAsync(IMessage msg, BaseDiscordClient client) public static async Task ModifyAsync(IMessage msg, BaseDiscordClient client, Action<ModifyMessageParams> func,
{ RequestOptions options)
await client.ApiClient.GetChannelMessageAsync(msg.ChannelId, msg.Id);
}
public static async Task ModifyAsync(IMessage msg, BaseDiscordClient client, Action<ModifyMessageParams> func)
{ {
var args = new ModifyMessageParams(); var args = new ModifyMessageParams();
func(args); func(args);
await client.ApiClient.ModifyMessageAsync(msg.ChannelId, msg.Id, args); await client.ApiClient.ModifyMessageAsync(msg.ChannelId, msg.Id, args, options);
} }
public static async Task DeleteAsync(IMessage msg, BaseDiscordClient client) public static async Task DeleteAsync(IMessage msg, BaseDiscordClient client,
RequestOptions options)
{ {
await client.ApiClient.DeleteMessageAsync(msg.ChannelId, msg.Id); await client.ApiClient.DeleteMessageAsync(msg.ChannelId, msg.Id, options);
} }
public static async Task PinAsync(IMessage msg, BaseDiscordClient client) public static async Task PinAsync(IMessage msg, BaseDiscordClient client,
RequestOptions options)
{ {
await client.ApiClient.AddPinAsync(msg.ChannelId, msg.Id); await client.ApiClient.AddPinAsync(msg.ChannelId, msg.Id, options);
} }
public static async Task UnpinAsync(IMessage msg, BaseDiscordClient client) public static async Task UnpinAsync(IMessage msg, BaseDiscordClient client,
RequestOptions options)
{ {
await client.ApiClient.RemovePinAsync(msg.ChannelId, msg.Id); await client.ApiClient.RemovePinAsync(msg.ChannelId, msg.Id, options);
} }
} }
} }

4
src/Discord.Net.Rest/Entities/Messages/RestMessage.cs
View File

@@ -48,9 +48,9 @@ namespace Discord.Rest
Content = model.Content.Value; Content = model.Content.Value;
} }
public async Task UpdateAsync() public async Task UpdateAsync(RequestOptions options)
{ {
var model = await Discord.ApiClient.GetChannelMessageAsync(ChannelId, Id).ConfigureAwait(false); var model = await Discord.ApiClient.GetChannelMessageAsync(ChannelId, Id, options).ConfigureAwait(false);
Update(model); Update(model);
} }

16
src/Discord.Net.Rest/Entities/Messages/RestUserMessage.cs
View File

@@ -109,15 +109,15 @@ namespace Discord.Rest
} }
} }
public Task ModifyAsync(Action<ModifyMessageParams> func) public Task ModifyAsync(Action<ModifyMessageParams> func, RequestOptions options)
=> MessageHelper.ModifyAsync(this, Discord, func); => MessageHelper.ModifyAsync(this, Discord, func, options);
public Task DeleteAsync() public Task DeleteAsync(RequestOptions options)
=> MessageHelper.DeleteAsync(this, Discord); => MessageHelper.DeleteAsync(this, Discord, options);
public Task PinAsync() public Task PinAsync(RequestOptions options)
=> MessageHelper.PinAsync(this, Discord); => MessageHelper.PinAsync(this, Discord, options);
public Task UnpinAsync() public Task UnpinAsync(RequestOptions options)
=> MessageHelper.UnpinAsync(this, Discord); => MessageHelper.UnpinAsync(this, Discord, options);
public string Resolve(UserMentionHandling userHandling = UserMentionHandling.Name, ChannelMentionHandling channelHandling = ChannelMentionHandling.Name, public string Resolve(UserMentionHandling userHandling = UserMentionHandling.Name, ChannelMentionHandling channelHandling = ChannelMentionHandling.Name,
RoleMentionHandling roleHandling = RoleMentionHandling.Name, EveryoneMentionHandling everyoneHandling = EveryoneMentionHandling.Ignore) RoleMentionHandling roleHandling = RoleMentionHandling.Name, EveryoneMentionHandling everyoneHandling = EveryoneMentionHandling.Ignore)

8
src/Discord.Net.Rest/Entities/Roles/RestRole.cs
View File

@@ -40,10 +40,10 @@ namespace Discord.Rest
Permissions = new GuildPermissions(model.Permissions); Permissions = new GuildPermissions(model.Permissions);
} }
public Task ModifyAsync(Action<ModifyGuildRoleParams> func) public Task ModifyAsync(Action<ModifyGuildRoleParams> func, RequestOptions options)
=> RoleHelper.ModifyAsync(this, Discord, func); => RoleHelper.ModifyAsync(this, Discord, func, options);
public Task DeleteAsync() public Task DeleteAsync(RequestOptions options)
=> RoleHelper.DeleteAsync(this, Discord); => RoleHelper.DeleteAsync(this, Discord, options);
public override string ToString() => Name; public override string ToString() => Name;
private string DebuggerDisplay => $"{Name} ({Id})"; private string DebuggerDisplay => $"{Name} ({Id})";

9
src/Discord.Net.Rest/Entities/Roles/RoleHelper.cs
View File

@@ -7,16 +7,17 @@ namespace Discord.Rest
internal static class RoleHelper internal static class RoleHelper
{ {
//General //General
public static async Task DeleteAsync(IRole role, BaseDiscordClient client) public static async Task DeleteAsync(IRole role, BaseDiscordClient client,
RequestOptions options)
{ {
await client.ApiClient.DeleteGuildRoleAsync(role.Guild.Id, role.Id).ConfigureAwait(false); await client.ApiClient.DeleteGuildRoleAsync(role.Guild.Id, role.Id, options).ConfigureAwait(false);
} }
public static async Task ModifyAsync(IRole role, BaseDiscordClient client, public static async Task ModifyAsync(IRole role, BaseDiscordClient client,
Action<ModifyGuildRoleParams> func) Action<ModifyGuildRoleParams> func, RequestOptions options)
{ {
var args = new ModifyGuildRoleParams(); var args = new ModifyGuildRoleParams();
func(args); func(args);
await client.ApiClient.ModifyGuildRoleAsync(role.Guild.Id, role.Id, args); await client.ApiClient.ModifyGuildRoleAsync(role.Guild.Id, role.Id, args, options);
} }
} }
} }

17
src/Discord.Net.Rest/Entities/Users/RestGuildUser.cs
View File

@@ -57,13 +57,16 @@ namespace Discord.Rest
roles.Add(roleIds[i]); roles.Add(roleIds[i]);
_roleIds = roles.ToImmutable(); _roleIds = roles.ToImmutable();
} }
public override async Task UpdateAsync() public override async Task UpdateAsync(RequestOptions options = null)
=> Update(await UserHelper.GetAsync(this, Discord)); {
public Task ModifyAsync(Action<ModifyGuildMemberParams> func) var model = await Discord.ApiClient.GetGuildMemberAsync(GuildId, Id, options);
=> UserHelper.ModifyAsync(this, Discord, func); Update(model);
public Task KickAsync() }
=> UserHelper.KickAsync(this, Discord); public Task ModifyAsync(Action<ModifyGuildMemberParams> func, RequestOptions options = null)
=> UserHelper.ModifyAsync(this, Discord, func, options);
public Task KickAsync(RequestOptions options = null)
=> UserHelper.KickAsync(this, Discord, options);
public ChannelPermissions GetPermissions(IGuildChannel channel) public ChannelPermissions GetPermissions(IGuildChannel channel)
{ {

20
src/Discord.Net.Rest/Entities/Users/RestSelfUser.cs
View File

@@ -35,11 +35,21 @@ namespace Discord.Rest
IsMfaEnabled = model.MfaEnabled.Value; IsMfaEnabled = model.MfaEnabled.Value;
} }
public override async Task UpdateAsync() public override async Task UpdateAsync(RequestOptions options = null)
=> Update(await UserHelper.GetAsync(this, Discord)); {
public Task ModifyAsync(Action<ModifyCurrentUserParams> func) var model = await Discord.ApiClient.GetMyUserAsync(options);
=> UserHelper.ModifyAsync(this, Discord, func); if (model.Id != Id)
throw new InvalidOperationException("Unable to update this object using a different token.");
Update(model);
}
Task ISelfUser.ModifyStatusAsync(Action<ModifyPresenceParams> func) { throw new NotSupportedException(); } public async Task ModifyAsync(Action<ModifyCurrentUserParams> func, RequestOptions options = null)
{
if (Id != Discord.CurrentUser.Id)
throw new InvalidOperationException("Unable to modify this object using a different token.");
await UserHelper.ModifyAsync(this, Discord, func, options);
}
Task ISelfUser.ModifyStatusAsync(Action<ModifyPresenceParams> func, RequestOptions options) { throw new NotSupportedException(); }
} }
} }

19
src/Discord.Net.Rest/Entities/Users/RestUser.cs
View File

@@ -39,20 +39,23 @@ namespace Discord.Rest
if (model.Username.IsSpecified) if (model.Username.IsSpecified)
Username = model.Username.Value; Username = model.Username.Value;
} }
public virtual async Task UpdateAsync()
=> Update(await UserHelper.GetAsync(this, Discord));
public Task<RestDMChannel> CreateDMChannelAsync() public virtual async Task UpdateAsync(RequestOptions options = null)
=> UserHelper.CreateDMChannelAsync(this, Discord); {
var model = await Discord.ApiClient.GetUserAsync(Id, options);
Update(model);
}
public Task<RestDMChannel> CreateDMChannelAsync(RequestOptions options = null)
=> UserHelper.CreateDMChannelAsync(this, Discord, options);
public override string ToString() => $"{Username}#{Discriminator}"; public override string ToString() => $"{Username}#{Discriminator}";
internal string DebuggerDisplay => $"{Username}#{Discriminator} ({Id}{(IsBot ? ", Bot" : "")})"; internal string DebuggerDisplay => $"{Username}#{Discriminator} ({Id}{(IsBot ? ", Bot" : "")})";
//IUser //IUser
Task<IDMChannel> IUser.GetDMChannelAsync(CacheMode mode) Task<IDMChannel> IUser.GetDMChannelAsync(CacheMode mode, RequestOptions options)
=> Task.FromResult<IDMChannel>(null); => Task.FromResult<IDMChannel>(null);
async Task<IDMChannel> IUser.CreateDMChannelAsync() async Task<IDMChannel> IUser.CreateDMChannelAsync(RequestOptions options)
=> await CreateDMChannelAsync(); => await CreateDMChannelAsync(options);
} }
} }

40
src/Discord.Net.Rest/Entities/Users/UserHelper.cs
View File

@@ -1,53 +1,37 @@
using Discord.API.Rest; using Discord.API.Rest;
using System; using System;
using System.Threading.Tasks; using System.Threading.Tasks;
using MemberModel = Discord.API.GuildMember;
using Model = Discord.API.User;
namespace Discord.Rest namespace Discord.Rest
{ {
internal static class UserHelper internal static class UserHelper
{ {
public static async Task<Model> GetAsync(IUser user, BaseDiscordClient client) public static async Task ModifyAsync(ISelfUser user, BaseDiscordClient client, Action<ModifyCurrentUserParams> func,
RequestOptions options)
{ {
return await client.ApiClient.GetUserAsync(user.Id);
}
public static async Task<Model> GetAsync(ISelfUser user, BaseDiscordClient client)
{
var model = await client.ApiClient.GetMyUserAsync();
if (model.Id != user.Id)
throw new InvalidOperationException("Unable to update this object using a different token.");
return model;
}
public static async Task<MemberModel> GetAsync(IGuildUser user, BaseDiscordClient client)
{
return await client.ApiClient.GetGuildMemberAsync(user.GuildId, user.Id);
}
public static async Task ModifyAsync(ISelfUser user, BaseDiscordClient client, Action<ModifyCurrentUserParams> func)
{
if (user.Id != client.CurrentUser.Id)
throw new InvalidOperationException("Unable to modify this object using a different token.");
var args = new ModifyCurrentUserParams(); var args = new ModifyCurrentUserParams();
func(args); func(args);
await client.ApiClient.ModifySelfAsync(args); await client.ApiClient.ModifySelfAsync(args, options);
} }
public static async Task ModifyAsync(IGuildUser user, BaseDiscordClient client, Action<ModifyGuildMemberParams> func) public static async Task ModifyAsync(IGuildUser user, BaseDiscordClient client, Action<ModifyGuildMemberParams> func,
RequestOptions options)
{ {
var args = new ModifyGuildMemberParams(); var args = new ModifyGuildMemberParams();
func(args); func(args);
await client.ApiClient.ModifyGuildMemberAsync(user.GuildId, user.Id, args); await client.ApiClient.ModifyGuildMemberAsync(user.GuildId, user.Id, args, options);
} }
public static async Task KickAsync(IGuildUser user, BaseDiscordClient client) public static async Task KickAsync(IGuildUser user, BaseDiscordClient client,
RequestOptions options)
{ {
await client.ApiClient.RemoveGuildMemberAsync(user.GuildId, user.Id); await client.ApiClient.RemoveGuildMemberAsync(user.GuildId, user.Id, options);
} }
public static async Task<RestDMChannel> CreateDMChannelAsync(IUser user, BaseDiscordClient client) public static async Task<RestDMChannel> CreateDMChannelAsync(IUser user, BaseDiscordClient client,
RequestOptions options)
{ {
var args = new CreateDMChannelParams(user.Id); var args = new CreateDMChannelParams(user.Id);
return RestDMChannel.Create(client, await client.ApiClient.CreateDMChannelAsync(args)); return RestDMChannel.Create(client, await client.ApiClient.CreateDMChannelAsync(args, options));
} }
} }
} }

4
src/Discord.Net.Rest/Utils/TypingNotifier.cs
View File

@@ -9,12 +9,14 @@ namespace Discord.Rest
private readonly BaseDiscordClient _client; private readonly BaseDiscordClient _client;
private readonly CancellationTokenSource _cancelToken; private readonly CancellationTokenSource _cancelToken;
private readonly ulong _channelId; private readonly ulong _channelId;
private readonly RequestOptions _options;
public TypingNotifier(BaseDiscordClient discord, IChannel channel) public TypingNotifier(BaseDiscordClient discord, IChannel channel, RequestOptions options)
{ {
_client = discord; _client = discord;
_cancelToken = new CancellationTokenSource(); _cancelToken = new CancellationTokenSource();
_channelId = channel.Id; _channelId = channel.Id;
_options = options;
var _ = Run(); var _ = Run();
} }

8
src/Discord.Net.WebSocket/Entities/Channels/ISocketMessageChannel.cs
View File

@@ -11,11 +11,11 @@ namespace Discord.WebSocket
IReadOnlyCollection<SocketMessage> CachedMessages { get; } IReadOnlyCollection<SocketMessage> CachedMessages { get; }
/// <summary> Sends a message to this message channel. </summary> /// <summary> Sends a message to this message channel. </summary>
new Task<RestUserMessage> SendMessageAsync(string text, bool isTTS = false); new Task<RestUserMessage> SendMessageAsync(string text, bool isTTS = false, RequestOptions options = null);
/// <summary> Sends a file to this text channel, with an optional caption. </summary> /// <summary> Sends a file to this text channel, with an optional caption. </summary>
new Task<RestUserMessage> SendFileAsync(string filePath, string text = null, bool isTTS = false); new Task<RestUserMessage> SendFileAsync(string filePath, string text = null, bool isTTS = false, RequestOptions options = null);
/// <summary> Sends a file to this text channel, with an optional caption. </summary> /// <summary> Sends a file to this text channel, with an optional caption. </summary>
new Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text = null, bool isTTS = false); new Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text = null, bool isTTS = false, RequestOptions options = null);
SocketMessage GetCachedMessage(ulong id); SocketMessage GetCachedMessage(ulong id);
/// <summary> Gets the last N messages from this message channel. </summary> /// <summary> Gets the last N messages from this message channel. </summary>
@@ -25,6 +25,6 @@ namespace Discord.WebSocket
/// <summary> Gets a collection of messages in this channel. </summary> /// <summary> Gets a collection of messages in this channel. </summary>
IReadOnlyCollection<SocketMessage> GetCachedMessages(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch); IReadOnlyCollection<SocketMessage> GetCachedMessages(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch);
/// <summary> Gets a collection of pinned messages in this channel. </summary> /// <summary> Gets a collection of pinned messages in this channel. </summary>
new Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync(); new Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync(RequestOptions options = null);
} }
} }

4
src/Discord.Net.WebSocket/Entities/Channels/SocketChannel.cs
View File

@@ -39,9 +39,9 @@ namespace Discord.WebSocket
internal SocketChannel Clone() => MemberwiseClone() as SocketChannel; internal SocketChannel Clone() => MemberwiseClone() as SocketChannel;
//IChannel //IChannel
Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode) Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IUser>(null); //Overridden => Task.FromResult<IUser>(null); //Overridden
IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode, RequestOptions options)
=> AsyncEnumerable.Empty<IReadOnlyCollection<IUser>>(); //Overridden => AsyncEnumerable.Empty<IReadOnlyCollection<IUser>>(); //Overridden
} }
} }

4
src/Discord.Net.WebSocket/Entities/Channels/SocketChannelHelper.cs
View File

@@ -9,7 +9,7 @@ namespace Discord.WebSocket
internal static class SocketChannelHelper internal static class SocketChannelHelper
{ {
public static IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(SocketChannel channel, DiscordSocketClient discord, MessageCache messages, public static IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(SocketChannel channel, DiscordSocketClient discord, MessageCache messages,
ulong? fromMessageId, Direction dir, int limit, CacheMode mode) ulong? fromMessageId, Direction dir, int limit, CacheMode mode, RequestOptions options)
{ {
IReadOnlyCollection<SocketMessage> cachedMessages; IReadOnlyCollection<SocketMessage> cachedMessages;
IAsyncEnumerable<IReadOnlyCollection<IMessage>> result; IAsyncEnumerable<IReadOnlyCollection<IMessage>> result;
@@ -28,7 +28,7 @@ namespace Discord.WebSocket
fromMessageId = cachedMessages.Min(x => x.Id); fromMessageId = cachedMessages.Min(x => x.Id);
else else
fromMessageId = cachedMessages.Max(x => x.Id); fromMessageId = cachedMessages.Max(x => x.Id);
var downloadedMessages = ChannelHelper.GetMessagesAsync(channel, discord, fromMessageId, dir, limit); var downloadedMessages = ChannelHelper.GetMessagesAsync(channel, discord, fromMessageId, dir, limit, options);
return result.Concat(downloadedMessages); return result.Concat(downloadedMessages);
} }
public static IReadOnlyCollection<SocketMessage> GetCachedMessages(SocketChannel channel, DiscordSocketClient discord, MessageCache messages, public static IReadOnlyCollection<SocketMessage> GetCachedMessages(SocketChannel channel, DiscordSocketClient discord, MessageCache messages,

86
src/Discord.Net.WebSocket/Entities/Channels/SocketDMChannel.cs
View File

@@ -38,46 +38,46 @@ namespace Discord.WebSocket
Recipient.Update(state, model.Recipients.Value[0]); Recipient.Update(state, model.Recipients.Value[0]);
} }
public Task CloseAsync() public Task CloseAsync(RequestOptions options = null)
=> ChannelHelper.DeleteAsync(this, Discord); => ChannelHelper.DeleteAsync(this, Discord, options);
//Messages //Messages
public SocketMessage GetCachedMessage(ulong id) public SocketMessage GetCachedMessage(ulong id)
=> _messages?.Get(id); => _messages?.Get(id);
public async Task<IMessage> GetMessageAsync(ulong id) public async Task<IMessage> GetMessageAsync(ulong id, RequestOptions options = null)
{ {
IMessage msg = _messages?.Get(id); IMessage msg = _messages?.Get(id);
if (msg == null) if (msg == null)
msg = await ChannelHelper.GetMessageAsync(this, Discord, id); msg = await ChannelHelper.GetMessageAsync(this, Discord, id, options);
return msg; return msg;
} }
public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, null, Direction.Before, limit, CacheMode.AllowDownload); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, null, Direction.Before, limit, CacheMode.AllowDownload, options);
public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessageId, dir, limit, CacheMode.AllowDownload); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessageId, dir, limit, CacheMode.AllowDownload, options);
public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessage.Id, dir, limit, CacheMode.AllowDownload); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessage.Id, dir, limit, CacheMode.AllowDownload, options);
public IReadOnlyCollection<SocketMessage> GetCachedMessages(int limit = DiscordConfig.MaxMessagesPerBatch) public IReadOnlyCollection<SocketMessage> GetCachedMessages(int limit = DiscordConfig.MaxMessagesPerBatch)
=> SocketChannelHelper.GetCachedMessages(this, Discord, _messages, null, Direction.Before, limit); => SocketChannelHelper.GetCachedMessages(this, Discord, _messages, null, Direction.Before, limit);
public IReadOnlyCollection<SocketMessage> GetCachedMessages(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IReadOnlyCollection<SocketMessage> GetCachedMessages(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch)
=> SocketChannelHelper.GetCachedMessages(this, Discord, _messages, fromMessageId, dir, limit); => SocketChannelHelper.GetCachedMessages(this, Discord, _messages, fromMessageId, dir, limit);
public IReadOnlyCollection<SocketMessage> GetCachedMessages(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IReadOnlyCollection<SocketMessage> GetCachedMessages(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch)
=> SocketChannelHelper.GetCachedMessages(this, Discord, _messages, fromMessage.Id, dir, limit); => SocketChannelHelper.GetCachedMessages(this, Discord, _messages, fromMessage.Id, dir, limit);
public Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync() public Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync(RequestOptions options = null)
=> ChannelHelper.GetPinnedMessagesAsync(this, Discord); => ChannelHelper.GetPinnedMessagesAsync(this, Discord, options);
public Task<RestUserMessage> SendMessageAsync(string text, bool isTTS) public Task<RestUserMessage> SendMessageAsync(string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendMessageAsync(this, Discord, text, isTTS); => ChannelHelper.SendMessageAsync(this, Discord, text, isTTS, options);
public Task<RestUserMessage> SendFileAsync(string filePath, string text, bool isTTS) public Task<RestUserMessage> SendFileAsync(string filePath, string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendFileAsync(this, Discord, filePath, text, isTTS); => ChannelHelper.SendFileAsync(this, Discord, filePath, text, isTTS, options);
public Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text, bool isTTS) public Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendFileAsync(this, Discord, stream, filename, text, isTTS); => ChannelHelper.SendFileAsync(this, Discord, stream, filename, text, isTTS, options);
public Task DeleteMessagesAsync(IEnumerable<IMessage> messages) public Task DeleteMessagesAsync(IEnumerable<IMessage> messages, RequestOptions options = null)
=> ChannelHelper.DeleteMessagesAsync(this, Discord, messages); => ChannelHelper.DeleteMessagesAsync(this, Discord, messages, options);
public IDisposable EnterTypingState() public IDisposable EnterTypingState(RequestOptions options = null)
=> ChannelHelper.EnterTypingState(this, Discord); => ChannelHelper.EnterTypingState(this, Discord, options);
internal void AddMessage(SocketMessage msg) internal void AddMessage(SocketMessage msg)
=> _messages.Add(msg); => _messages.Add(msg);
@@ -111,36 +111,36 @@ namespace Discord.WebSocket
//IPrivateChannel //IPrivateChannel
IReadOnlyCollection<IUser> IPrivateChannel.Recipients => ImmutableArray.Create<IUser>(Recipient); IReadOnlyCollection<IUser> IPrivateChannel.Recipients => ImmutableArray.Create<IUser>(Recipient);
//IMessageChannel //IMessageChannel
async Task<IMessage> IMessageChannel.GetMessageAsync(ulong id, CacheMode mode) async Task<IMessage> IMessageChannel.GetMessageAsync(ulong id, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetMessageAsync(id); return await GetMessageAsync(id, options);
else else
return GetCachedMessage(id); return GetCachedMessage(id);
} }
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(int limit, CacheMode mode, RequestOptions options)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, null, Direction.Before, limit, mode); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, null, Direction.Before, limit, mode, options);
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(ulong fromMessageId, Direction dir, int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(ulong fromMessageId, Direction dir, int limit, CacheMode mode, RequestOptions options)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessageId, dir, limit, mode); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessageId, dir, limit, mode, options);
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(IMessage fromMessage, Direction dir, int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(IMessage fromMessage, Direction dir, int limit, CacheMode mode, RequestOptions options)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessage.Id, dir, limit, mode); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessage.Id, dir, limit, mode, options);
async Task<IReadOnlyCollection<IMessage>> IMessageChannel.GetPinnedMessagesAsync() async Task<IReadOnlyCollection<IMessage>> IMessageChannel.GetPinnedMessagesAsync(RequestOptions options)
=> await GetPinnedMessagesAsync().ConfigureAwait(false); => await GetPinnedMessagesAsync(options).ConfigureAwait(false);
async Task<IUserMessage> IMessageChannel.SendFileAsync(string filePath, string text, bool isTTS) async Task<IUserMessage> IMessageChannel.SendFileAsync(string filePath, string text, bool isTTS, RequestOptions options)
=> await SendFileAsync(filePath, text, isTTS); => await SendFileAsync(filePath, text, isTTS, options);
async Task<IUserMessage> IMessageChannel.SendFileAsync(Stream stream, string filename, string text, bool isTTS) async Task<IUserMessage> IMessageChannel.SendFileAsync(Stream stream, string filename, string text, bool isTTS, RequestOptions options)
=> await SendFileAsync(stream, filename, text, isTTS); => await SendFileAsync(stream, filename, text, isTTS, options);
async Task<IUserMessage> IMessageChannel.SendMessageAsync(string text, bool isTTS) async Task<IUserMessage> IMessageChannel.SendMessageAsync(string text, bool isTTS, RequestOptions options)
=> await SendMessageAsync(text, isTTS); => await SendMessageAsync(text, isTTS, options);
IDisposable IMessageChannel.EnterTypingState() IDisposable IMessageChannel.EnterTypingState(RequestOptions options)
=> EnterTypingState(); => EnterTypingState(options);
//IChannel //IChannel
Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode) Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IUser>(GetUser(id)); => Task.FromResult<IUser>(GetUser(id));
IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode, RequestOptions options)
=> ImmutableArray.Create<IReadOnlyCollection<IUser>>(Users).ToAsyncEnumerable(); => ImmutableArray.Create<IReadOnlyCollection<IUser>>(Users).ToAsyncEnumerable();
} }
} }

85
src/Discord.Net.WebSocket/Entities/Channels/SocketGroupChannel.cs
View File

@@ -61,46 +61,46 @@ namespace Discord.WebSocket
_users = users; _users = users;
} }
public Task LeaveAsync() public Task LeaveAsync(RequestOptions options = null)
=> ChannelHelper.DeleteAsync(this, Discord); => ChannelHelper.DeleteAsync(this, Discord, options);
//Messages //Messages
public SocketMessage GetCachedMessage(ulong id) public SocketMessage GetCachedMessage(ulong id)
=> _messages?.Get(id); => _messages?.Get(id);
public async Task<IMessage> GetMessageAsync(ulong id) public async Task<IMessage> GetMessageAsync(ulong id, RequestOptions options = null)
{ {
IMessage msg = _messages?.Get(id); IMessage msg = _messages?.Get(id);
if (msg == null) if (msg == null)
msg = await ChannelHelper.GetMessageAsync(this, Discord, id); msg = await ChannelHelper.GetMessageAsync(this, Discord, id, options);
return msg; return msg;
} }
public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, null, Direction.Before, limit, CacheMode.AllowDownload); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, null, Direction.Before, limit, CacheMode.AllowDownload, options);
public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessageId, dir, limit, CacheMode.AllowDownload); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessageId, dir, limit, CacheMode.AllowDownload, options);
public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessage.Id, dir, limit, CacheMode.AllowDownload); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessage.Id, dir, limit, CacheMode.AllowDownload, options);
public IReadOnlyCollection<SocketMessage> GetCachedMessages(int limit = DiscordConfig.MaxMessagesPerBatch) public IReadOnlyCollection<SocketMessage> GetCachedMessages(int limit = DiscordConfig.MaxMessagesPerBatch)
=> SocketChannelHelper.GetCachedMessages(this, Discord, _messages, null, Direction.Before, limit); => SocketChannelHelper.GetCachedMessages(this, Discord, _messages, null, Direction.Before, limit);
public IReadOnlyCollection<SocketMessage> GetCachedMessages(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IReadOnlyCollection<SocketMessage> GetCachedMessages(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch)
=> SocketChannelHelper.GetCachedMessages(this, Discord, _messages, fromMessageId, dir, limit); => SocketChannelHelper.GetCachedMessages(this, Discord, _messages, fromMessageId, dir, limit);
public IReadOnlyCollection<SocketMessage> GetCachedMessages(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IReadOnlyCollection<SocketMessage> GetCachedMessages(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch)
=> SocketChannelHelper.GetCachedMessages(this, Discord, _messages, fromMessage.Id, dir, limit); => SocketChannelHelper.GetCachedMessages(this, Discord, _messages, fromMessage.Id, dir, limit);
public Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync() public Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync(RequestOptions options = null)
=> ChannelHelper.GetPinnedMessagesAsync(this, Discord); => ChannelHelper.GetPinnedMessagesAsync(this, Discord, options);
public Task<RestUserMessage> SendMessageAsync(string text, bool isTTS) public Task<RestUserMessage> SendMessageAsync(string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendMessageAsync(this, Discord, text, isTTS); => ChannelHelper.SendMessageAsync(this, Discord, text, isTTS, options);
public Task<RestUserMessage> SendFileAsync(string filePath, string text, bool isTTS) public Task<RestUserMessage> SendFileAsync(string filePath, string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendFileAsync(this, Discord, filePath, text, isTTS); => ChannelHelper.SendFileAsync(this, Discord, filePath, text, isTTS, options);
public Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text, bool isTTS) public Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendFileAsync(this, Discord, stream, filename, text, isTTS); => ChannelHelper.SendFileAsync(this, Discord, stream, filename, text, isTTS, options);
public Task DeleteMessagesAsync(IEnumerable<IMessage> messages) public Task DeleteMessagesAsync(IEnumerable<IMessage> messages, RequestOptions options = null)
=> ChannelHelper.DeleteMessagesAsync(this, Discord, messages); => ChannelHelper.DeleteMessagesAsync(this, Discord, messages, options);
public IDisposable EnterTypingState() public IDisposable EnterTypingState(RequestOptions options = null)
=> ChannelHelper.EnterTypingState(this, Discord); => ChannelHelper.EnterTypingState(this, Discord, options);
internal void AddMessage(SocketMessage msg) internal void AddMessage(SocketMessage msg)
=> _messages.Add(msg); => _messages.Add(msg);
@@ -176,35 +176,34 @@ namespace Discord.WebSocket
IReadOnlyCollection<IUser> IPrivateChannel.Recipients => Recipients; IReadOnlyCollection<IUser> IPrivateChannel.Recipients => Recipients;
//IMessageChannel //IMessageChannel
async Task<IMessage> IMessageChannel.GetMessageAsync(ulong id, CacheMode mode) async Task<IMessage> IMessageChannel.GetMessageAsync(ulong id, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetMessageAsync(id); return await GetMessageAsync(id, options);
else else
return GetCachedMessage(id); return GetCachedMessage(id);
} }
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(int limit, CacheMode mode, RequestOptions options)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, null, Direction.Before, limit, mode); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, null, Direction.Before, limit, mode, options);
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(ulong fromMessageId, Direction dir, int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(ulong fromMessageId, Direction dir, int limit, CacheMode mode, RequestOptions options)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessageId, dir, limit, mode); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessageId, dir, limit, mode, options);
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(IMessage fromMessage, Direction dir, int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(IMessage fromMessage, Direction dir, int limit, CacheMode mode, RequestOptions options)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessage.Id, dir, limit, mode); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessage.Id, dir, limit, mode, options);
async Task<IReadOnlyCollection<IMessage>> IMessageChannel.GetPinnedMessagesAsync() async Task<IReadOnlyCollection<IMessage>> IMessageChannel.GetPinnedMessagesAsync(RequestOptions options)
=> await GetPinnedMessagesAsync(); => await GetPinnedMessagesAsync(options).ConfigureAwait(false);
async Task<IUserMessage> IMessageChannel.SendFileAsync(string filePath, string text, bool isTTS, RequestOptions options)
async Task<IUserMessage> IMessageChannel.SendFileAsync(string filePath, string text, bool isTTS) => await SendFileAsync(filePath, text, isTTS, options);
=> await SendFileAsync(filePath, text, isTTS); async Task<IUserMessage> IMessageChannel.SendFileAsync(Stream stream, string filename, string text, bool isTTS, RequestOptions options)
async Task<IUserMessage> IMessageChannel.SendFileAsync(Stream stream, string filename, string text, bool isTTS) => await SendFileAsync(stream, filename, text, isTTS, options);
=> await SendFileAsync(stream, filename, text, isTTS); async Task<IUserMessage> IMessageChannel.SendMessageAsync(string text, bool isTTS, RequestOptions options)
async Task<IUserMessage> IMessageChannel.SendMessageAsync(string text, bool isTTS) => await SendMessageAsync(text, isTTS, options);
=> await SendMessageAsync(text, isTTS); IDisposable IMessageChannel.EnterTypingState(RequestOptions options)
IDisposable IMessageChannel.EnterTypingState() => EnterTypingState(options);
=> EnterTypingState();
//IChannel //IChannel
Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode) Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IUser>(GetUser(id)); => Task.FromResult<IUser>(GetUser(id));
IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode, RequestOptions options)
=> ImmutableArray.Create<IReadOnlyCollection<IUser>>(Users).ToAsyncEnumerable(); => ImmutableArray.Create<IReadOnlyCollection<IUser>>(Users).ToAsyncEnumerable();
} }
} }

64
src/Discord.Net.WebSocket/Entities/Channels/SocketGuildChannel.cs
View File

@@ -51,10 +51,10 @@ namespace Discord.WebSocket
_overwrites = newOverwrites.ToImmutable(); _overwrites = newOverwrites.ToImmutable();
} }
public Task ModifyAsync(Action<ModifyGuildChannelParams> func) public Task ModifyAsync(Action<ModifyGuildChannelParams> func, RequestOptions options = null)
=> ChannelHelper.ModifyAsync(this, Discord, func); => ChannelHelper.ModifyAsync(this, Discord, func, options);
public Task DeleteAsync() public Task DeleteAsync(RequestOptions options = null)
=> ChannelHelper.DeleteAsync(this, Discord); => ChannelHelper.DeleteAsync(this, Discord, options);
public OverwritePermissions? GetPermissionOverwrite(IUser user) public OverwritePermissions? GetPermissionOverwrite(IUser user)
{ {
@@ -74,19 +74,19 @@ namespace Discord.WebSocket
} }
return null; return null;
} }
public async Task AddPermissionOverwriteAsync(IUser user, OverwritePermissions perms) public async Task AddPermissionOverwriteAsync(IUser user, OverwritePermissions perms, RequestOptions options = null)
{ {
await ChannelHelper.AddPermissionOverwriteAsync(this, Discord, user, perms).ConfigureAwait(false); await ChannelHelper.AddPermissionOverwriteAsync(this, Discord, user, perms, options).ConfigureAwait(false);
_overwrites = _overwrites.Add(new Overwrite(new API.Overwrite { Allow = perms.AllowValue, Deny = perms.DenyValue, TargetId = user.Id, TargetType = PermissionTarget.User })); _overwrites = _overwrites.Add(new Overwrite(new API.Overwrite { Allow = perms.AllowValue, Deny = perms.DenyValue, TargetId = user.Id, TargetType = PermissionTarget.User }));
} }
public async Task AddPermissionOverwriteAsync(IRole role, OverwritePermissions perms) public async Task AddPermissionOverwriteAsync(IRole role, OverwritePermissions perms, RequestOptions options = null)
{ {
await ChannelHelper.AddPermissionOverwriteAsync(this, Discord, role, perms).ConfigureAwait(false); await ChannelHelper.AddPermissionOverwriteAsync(this, Discord, role, perms, options).ConfigureAwait(false);
_overwrites.Add(new Overwrite(new API.Overwrite { Allow = perms.AllowValue, Deny = perms.DenyValue, TargetId = role.Id, TargetType = PermissionTarget.Role })); _overwrites.Add(new Overwrite(new API.Overwrite { Allow = perms.AllowValue, Deny = perms.DenyValue, TargetId = role.Id, TargetType = PermissionTarget.Role }));
} }
public async Task RemovePermissionOverwriteAsync(IUser user) public async Task RemovePermissionOverwriteAsync(IUser user, RequestOptions options = null)
{ {
await ChannelHelper.RemovePermissionOverwriteAsync(this, Discord, user).ConfigureAwait(false); await ChannelHelper.RemovePermissionOverwriteAsync(this, Discord, user, options).ConfigureAwait(false);
for (int i = 0; i < _overwrites.Length; i++) for (int i = 0; i < _overwrites.Length; i++)
{ {
@@ -97,9 +97,9 @@ namespace Discord.WebSocket
} }
} }
} }
public async Task RemovePermissionOverwriteAsync(IRole role) public async Task RemovePermissionOverwriteAsync(IRole role, RequestOptions options = null)
{ {
await ChannelHelper.RemovePermissionOverwriteAsync(this, Discord, role).ConfigureAwait(false); await ChannelHelper.RemovePermissionOverwriteAsync(this, Discord, role, options).ConfigureAwait(false);
for (int i = 0; i < _overwrites.Length; i++) for (int i = 0; i < _overwrites.Length; i++)
{ {
@@ -111,10 +111,10 @@ namespace Discord.WebSocket
} }
} }
public async Task<IReadOnlyCollection<RestInviteMetadata>> GetInvitesAsync() public async Task<IReadOnlyCollection<RestInviteMetadata>> GetInvitesAsync(RequestOptions options = null)
=> await ChannelHelper.GetInvitesAsync(this, Discord); => await ChannelHelper.GetInvitesAsync(this, Discord, options);
public async Task<RestInviteMetadata> CreateInviteAsync(int? maxAge = 3600, int? maxUses = null, bool isTemporary = true) public async Task<RestInviteMetadata> CreateInviteAsync(int? maxAge = 3600, int? maxUses = null, bool isTemporary = true, RequestOptions options = null)
=> await ChannelHelper.CreateInviteAsync(this, Discord, maxAge, maxUses, isTemporary); => await ChannelHelper.CreateInviteAsync(this, Discord, maxAge, maxUses, isTemporary, options);
public new abstract SocketGuildUser GetUser(ulong id); public new abstract SocketGuildUser GetUser(ulong id);
@@ -128,33 +128,33 @@ namespace Discord.WebSocket
//IGuildChannel //IGuildChannel
ulong IGuildChannel.GuildId => Guild.Id; ulong IGuildChannel.GuildId => Guild.Id;
async Task<IReadOnlyCollection<IInviteMetadata>> IGuildChannel.GetInvitesAsync() async Task<IReadOnlyCollection<IInviteMetadata>> IGuildChannel.GetInvitesAsync(RequestOptions options)
=> await GetInvitesAsync(); => await GetInvitesAsync(options);
async Task<IInviteMetadata> IGuildChannel.CreateInviteAsync(int? maxAge, int? maxUses, bool isTemporary) async Task<IInviteMetadata> IGuildChannel.CreateInviteAsync(int? maxAge, int? maxUses, bool isTemporary, RequestOptions options)
=> await CreateInviteAsync(maxAge, maxUses, isTemporary); => await CreateInviteAsync(maxAge, maxUses, isTemporary, options);
OverwritePermissions? IGuildChannel.GetPermissionOverwrite(IRole role) OverwritePermissions? IGuildChannel.GetPermissionOverwrite(IRole role)
=> GetPermissionOverwrite(role); => GetPermissionOverwrite(role);
OverwritePermissions? IGuildChannel.GetPermissionOverwrite(IUser user) OverwritePermissions? IGuildChannel.GetPermissionOverwrite(IUser user)
=> GetPermissionOverwrite(user); => GetPermissionOverwrite(user);
async Task IGuildChannel.AddPermissionOverwriteAsync(IRole role, OverwritePermissions permissions) async Task IGuildChannel.AddPermissionOverwriteAsync(IRole role, OverwritePermissions permissions, RequestOptions options)
=> await AddPermissionOverwriteAsync(role, permissions); => await AddPermissionOverwriteAsync(role, permissions, options);
async Task IGuildChannel.AddPermissionOverwriteAsync(IUser user, OverwritePermissions permissions) async Task IGuildChannel.AddPermissionOverwriteAsync(IUser user, OverwritePermissions permissions, RequestOptions options)
=> await AddPermissionOverwriteAsync(user, permissions); => await AddPermissionOverwriteAsync(user, permissions, options);
async Task IGuildChannel.RemovePermissionOverwriteAsync(IRole role) async Task IGuildChannel.RemovePermissionOverwriteAsync(IRole role, RequestOptions options)
=> await RemovePermissionOverwriteAsync(role); => await RemovePermissionOverwriteAsync(role, options);
async Task IGuildChannel.RemovePermissionOverwriteAsync(IUser user) async Task IGuildChannel.RemovePermissionOverwriteAsync(IUser user, RequestOptions options)
=> await RemovePermissionOverwriteAsync(user); => await RemovePermissionOverwriteAsync(user, options);
IAsyncEnumerable<IReadOnlyCollection<IGuildUser>> IGuildChannel.GetUsersAsync(CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IGuildUser>> IGuildChannel.GetUsersAsync(CacheMode mode, RequestOptions options)
=> ImmutableArray.Create<IReadOnlyCollection<IGuildUser>>(Users).ToAsyncEnumerable(); => ImmutableArray.Create<IReadOnlyCollection<IGuildUser>>(Users).ToAsyncEnumerable();
Task<IGuildUser> IGuildChannel.GetUserAsync(ulong id, CacheMode mode) Task<IGuildUser> IGuildChannel.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IGuildUser>(GetUser(id)); => Task.FromResult<IGuildUser>(GetUser(id));
//IChannel //IChannel
IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode, RequestOptions options)
=> ImmutableArray.Create<IReadOnlyCollection<IUser>>(Users).ToAsyncEnumerable(); //Overriden in Text/Voice //TODO: Does this actually override? => ImmutableArray.Create<IReadOnlyCollection<IUser>>(Users).ToAsyncEnumerable(); //Overriden in Text/Voice //TODO: Does this actually override?
Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode) Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IUser>(GetUser(id)); //Overriden in Text/Voice //TODO: Does this actually override? => Task.FromResult<IUser>(GetUser(id)); //Overriden in Text/Voice //TODO: Does this actually override?
} }
} }

84
src/Discord.Net.WebSocket/Entities/Channels/SocketTextChannel.cs
View File

@@ -44,46 +44,46 @@ namespace Discord.WebSocket
Topic = model.Topic.Value; Topic = model.Topic.Value;
} }
public Task ModifyAsync(Action<ModifyTextChannelParams> func) public Task ModifyAsync(Action<ModifyTextChannelParams> func, RequestOptions options = null)
=> ChannelHelper.ModifyAsync(this, Discord, func); => ChannelHelper.ModifyAsync(this, Discord, func, options);
//Messages //Messages
public SocketMessage GetCachedMessage(ulong id) public SocketMessage GetCachedMessage(ulong id)
=> _messages?.Get(id); => _messages?.Get(id);
public async Task<IMessage> GetMessageAsync(ulong id) public async Task<IMessage> GetMessageAsync(ulong id, RequestOptions options = null)
{ {
IMessage msg = _messages?.Get(id); IMessage msg = _messages?.Get(id);
if (msg == null) if (msg == null)
msg = await ChannelHelper.GetMessageAsync(this, Discord, id); msg = await ChannelHelper.GetMessageAsync(this, Discord, id, options);
return msg; return msg;
} }
public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, null, Direction.Before, limit, CacheMode.AllowDownload); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, null, Direction.Before, limit, CacheMode.AllowDownload, options);
public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessageId, dir, limit, CacheMode.AllowDownload); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessageId, dir, limit, CacheMode.AllowDownload, options);
public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IAsyncEnumerable<IReadOnlyCollection<IMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessage.Id, dir, limit, CacheMode.AllowDownload); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessage.Id, dir, limit, CacheMode.AllowDownload, options);
public IReadOnlyCollection<SocketMessage> GetCachedMessages(int limit = DiscordConfig.MaxMessagesPerBatch) public IReadOnlyCollection<SocketMessage> GetCachedMessages(int limit = DiscordConfig.MaxMessagesPerBatch)
=> SocketChannelHelper.GetCachedMessages(this, Discord, _messages, null, Direction.Before, limit); => SocketChannelHelper.GetCachedMessages(this, Discord, _messages, null, Direction.Before, limit);
public IReadOnlyCollection<SocketMessage> GetCachedMessages(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IReadOnlyCollection<SocketMessage> GetCachedMessages(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch)
=> SocketChannelHelper.GetCachedMessages(this, Discord, _messages, fromMessageId, dir, limit); => SocketChannelHelper.GetCachedMessages(this, Discord, _messages, fromMessageId, dir, limit);
public IReadOnlyCollection<SocketMessage> GetCachedMessages(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch) public IReadOnlyCollection<SocketMessage> GetCachedMessages(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch)
=> SocketChannelHelper.GetCachedMessages(this, Discord, _messages, fromMessage.Id, dir, limit); => SocketChannelHelper.GetCachedMessages(this, Discord, _messages, fromMessage.Id, dir, limit);
public Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync() public Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync(RequestOptions options = null)
=> ChannelHelper.GetPinnedMessagesAsync(this, Discord); => ChannelHelper.GetPinnedMessagesAsync(this, Discord, options);
public Task<RestUserMessage> SendMessageAsync(string text, bool isTTS) public Task<RestUserMessage> SendMessageAsync(string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendMessageAsync(this, Discord, text, isTTS); => ChannelHelper.SendMessageAsync(this, Discord, text, isTTS, options);
public Task<RestUserMessage> SendFileAsync(string filePath, string text, bool isTTS) public Task<RestUserMessage> SendFileAsync(string filePath, string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendFileAsync(this, Discord, filePath, text, isTTS); => ChannelHelper.SendFileAsync(this, Discord, filePath, text, isTTS, options);
public Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text, bool isTTS) public Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text, bool isTTS, RequestOptions options = null)
=> ChannelHelper.SendFileAsync(this, Discord, stream, filename, text, isTTS); => ChannelHelper.SendFileAsync(this, Discord, stream, filename, text, isTTS, options);
public Task DeleteMessagesAsync(IEnumerable<IMessage> messages) public Task DeleteMessagesAsync(IEnumerable<IMessage> messages, RequestOptions options = null)
=> ChannelHelper.DeleteMessagesAsync(this, Discord, messages); => ChannelHelper.DeleteMessagesAsync(this, Discord, messages, options);
public IDisposable EnterTypingState() public IDisposable EnterTypingState(RequestOptions options = null)
=> ChannelHelper.EnterTypingState(this, Discord); => ChannelHelper.EnterTypingState(this, Discord, options);
internal void AddMessage(SocketMessage msg) internal void AddMessage(SocketMessage msg)
=> _messages.Add(msg); => _messages.Add(msg);
@@ -108,34 +108,34 @@ namespace Discord.WebSocket
internal new SocketTextChannel Clone() => MemberwiseClone() as SocketTextChannel; internal new SocketTextChannel Clone() => MemberwiseClone() as SocketTextChannel;
//IGuildChannel //IGuildChannel
Task<IGuildUser> IGuildChannel.GetUserAsync(ulong id, CacheMode mode) Task<IGuildUser> IGuildChannel.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IGuildUser>(GetUser(id)); => Task.FromResult<IGuildUser>(GetUser(id));
IAsyncEnumerable<IReadOnlyCollection<IGuildUser>> IGuildChannel.GetUsersAsync(CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IGuildUser>> IGuildChannel.GetUsersAsync(CacheMode mode, RequestOptions options)
=> ImmutableArray.Create<IReadOnlyCollection<IGuildUser>>(Users).ToAsyncEnumerable(); => ImmutableArray.Create<IReadOnlyCollection<IGuildUser>>(Users).ToAsyncEnumerable();
//IMessageChannel //IMessageChannel
async Task<IMessage> IMessageChannel.GetMessageAsync(ulong id, CacheMode mode) async Task<IMessage> IMessageChannel.GetMessageAsync(ulong id, CacheMode mode, RequestOptions options)
{ {
if (mode == CacheMode.AllowDownload) if (mode == CacheMode.AllowDownload)
return await GetMessageAsync(id); return await GetMessageAsync(id, options);
else else
return GetCachedMessage(id); return GetCachedMessage(id);
} }
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(int limit, CacheMode mode, RequestOptions options)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, null, Direction.Before, limit, mode); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, null, Direction.Before, limit, mode, options);
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(ulong fromMessageId, Direction dir, int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(ulong fromMessageId, Direction dir, int limit, CacheMode mode, RequestOptions options)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessageId, dir, limit, mode); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessageId, dir, limit, mode, options);
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(IMessage fromMessage, Direction dir, int limit, CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(IMessage fromMessage, Direction dir, int limit, CacheMode mode, RequestOptions options)
=> SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessage.Id, dir, limit, mode); => SocketChannelHelper.GetMessagesAsync(this, Discord, _messages, fromMessage.Id, dir, limit, mode, options);
async Task<IReadOnlyCollection<IMessage>> IMessageChannel.GetPinnedMessagesAsync() async Task<IReadOnlyCollection<IMessage>> IMessageChannel.GetPinnedMessagesAsync(RequestOptions options)
=> await GetPinnedMessagesAsync().ConfigureAwait(false); => await GetPinnedMessagesAsync(options).ConfigureAwait(false);
async Task<IUserMessage> IMessageChannel.SendFileAsync(string filePath, string text, bool isTTS) async Task<IUserMessage> IMessageChannel.SendFileAsync(string filePath, string text, bool isTTS, RequestOptions options)
=> await SendFileAsync(filePath, text, isTTS); => await SendFileAsync(filePath, text, isTTS, options);
async Task<IUserMessage> IMessageChannel.SendFileAsync(Stream stream, string filename, string text, bool isTTS) async Task<IUserMessage> IMessageChannel.SendFileAsync(Stream stream, string filename, string text, bool isTTS, RequestOptions options)
=> await SendFileAsync(stream, filename, text, isTTS); => await SendFileAsync(stream, filename, text, isTTS, options);
async Task<IUserMessage> IMessageChannel.SendMessageAsync(string text, bool isTTS) async Task<IUserMessage> IMessageChannel.SendMessageAsync(string text, bool isTTS, RequestOptions options)
=> await SendMessageAsync(text, isTTS); => await SendMessageAsync(text, isTTS, options);
IDisposable IMessageChannel.EnterTypingState() IDisposable IMessageChannel.EnterTypingState(RequestOptions options)
=> EnterTypingState(); => EnterTypingState(options);
} }
} }

8
src/Discord.Net.WebSocket/Entities/Channels/SocketVoiceChannel.cs
View File

@@ -38,8 +38,8 @@ namespace Discord.WebSocket
UserLimit = model.UserLimit.Value; UserLimit = model.UserLimit.Value;
} }
public Task ModifyAsync(Action<ModifyVoiceChannelParams> func) public Task ModifyAsync(Action<ModifyVoiceChannelParams> func, RequestOptions options = null)
=> ChannelHelper.ModifyAsync(this, Discord, func); => ChannelHelper.ModifyAsync(this, Discord, func, options);
public override SocketGuildUser GetUser(ulong id) public override SocketGuildUser GetUser(ulong id)
{ {
@@ -56,9 +56,9 @@ namespace Discord.WebSocket
Task<IAudioClient> IVoiceChannel.ConnectAsync() { throw new NotSupportedException(); } Task<IAudioClient> IVoiceChannel.ConnectAsync() { throw new NotSupportedException(); }
//IGuildChannel //IGuildChannel
Task<IGuildUser> IGuildChannel.GetUserAsync(ulong id, CacheMode mode) Task<IGuildUser> IGuildChannel.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IGuildUser>(GetUser(id)); => Task.FromResult<IGuildUser>(GetUser(id));
IAsyncEnumerable<IReadOnlyCollection<IGuildUser>> IGuildChannel.GetUsersAsync(CacheMode mode) IAsyncEnumerable<IReadOnlyCollection<IGuildUser>> IGuildChannel.GetUsersAsync(CacheMode mode, RequestOptions options)
=> ImmutableArray.Create<IReadOnlyCollection<IGuildUser>>(Users).ToAsyncEnumerable(); => ImmutableArray.Create<IReadOnlyCollection<IGuildUser>>(Users).ToAsyncEnumerable();
} }
} }

111
src/Discord.Net.WebSocket/Entities/Guilds/SocketGuild.cs
View File

@@ -241,34 +241,34 @@ namespace Discord.WebSocket
} }
//General //General
public Task DeleteAsync() public Task DeleteAsync(RequestOptions options)
=> GuildHelper.DeleteAsync(this, Discord); => GuildHelper.DeleteAsync(this, Discord, options);
public Task ModifyAsync(Action<ModifyGuildParams> func) public Task ModifyAsync(Action<ModifyGuildParams> func, RequestOptions options = null)
=> GuildHelper.ModifyAsync(this, Discord, func); => GuildHelper.ModifyAsync(this, Discord, func, options);
public Task ModifyEmbedAsync(Action<ModifyGuildEmbedParams> func) public Task ModifyEmbedAsync(Action<ModifyGuildEmbedParams> func, RequestOptions options = null)
=> GuildHelper.ModifyEmbedAsync(this, Discord, func); => GuildHelper.ModifyEmbedAsync(this, Discord, func, options);
public Task ModifyChannelsAsync(IEnumerable<ModifyGuildChannelsParams> args) public Task ModifyChannelsAsync(IEnumerable<ModifyGuildChannelsParams> args, RequestOptions options = null)
=> GuildHelper.ModifyChannelsAsync(this, Discord, args); => GuildHelper.ModifyChannelsAsync(this, Discord, args, options);
public Task ModifyRolesAsync(IEnumerable<ModifyGuildRolesParams> args) public Task ModifyRolesAsync(IEnumerable<ModifyGuildRolesParams> args, RequestOptions options = null)
=> GuildHelper.ModifyRolesAsync(this, Discord, args); => GuildHelper.ModifyRolesAsync(this, Discord, args, options);
public Task LeaveAsync() public Task LeaveAsync(RequestOptions options = null)
=> GuildHelper.LeaveAsync(this, Discord); => GuildHelper.LeaveAsync(this, Discord, options);
//Bans //Bans
public Task<IReadOnlyCollection<RestBan>> GetBansAsync() public Task<IReadOnlyCollection<RestBan>> GetBansAsync(RequestOptions options = null)
=> GuildHelper.GetBansAsync(this, Discord); => GuildHelper.GetBansAsync(this, Discord, options);
public Task AddBanAsync(IUser user, int pruneDays = 0) public Task AddBanAsync(IUser user, int pruneDays = 0, RequestOptions options = null)
=> GuildHelper.AddBanAsync(this, Discord, user.Id, pruneDays); => GuildHelper.AddBanAsync(this, Discord, user.Id, pruneDays, options);
public Task AddBanAsync(ulong userId, int pruneDays = 0) public Task AddBanAsync(ulong userId, int pruneDays = 0, RequestOptions options = null)
=> GuildHelper.AddBanAsync(this, Discord, userId, pruneDays); => GuildHelper.AddBanAsync(this, Discord, userId, pruneDays, options);
public Task RemoveBanAsync(IUser user) public Task RemoveBanAsync(IUser user, RequestOptions options = null)
=> GuildHelper.RemoveBanAsync(this, Discord, user.Id); => GuildHelper.RemoveBanAsync(this, Discord, user.Id, options);
public Task RemoveBanAsync(ulong userId) public Task RemoveBanAsync(ulong userId, RequestOptions options = null)
=> GuildHelper.RemoveBanAsync(this, Discord, userId); => GuildHelper.RemoveBanAsync(this, Discord, userId, options);
//Channels //Channels
public SocketGuildChannel GetChannel(ulong id) public SocketGuildChannel GetChannel(ulong id)
@@ -278,10 +278,10 @@ namespace Discord.WebSocket
return channel; return channel;
return null; return null;
} }
public Task<RestTextChannel> CreateTextChannelAsync(string name) public Task<RestTextChannel> CreateTextChannelAsync(string name, RequestOptions options = null)
=> GuildHelper.CreateTextChannelAsync(this, Discord, name); => GuildHelper.CreateTextChannelAsync(this, Discord, name, options);
public Task<RestVoiceChannel> CreateVoiceChannelAsync(string name) public Task<RestVoiceChannel> CreateVoiceChannelAsync(string name, RequestOptions options = null)
=> GuildHelper.CreateVoiceChannelAsync(this, Discord, name); => GuildHelper.CreateVoiceChannelAsync(this, Discord, name, options);
internal SocketGuildChannel AddChannel(ClientState state, ChannelModel model) internal SocketGuildChannel AddChannel(ClientState state, ChannelModel model)
{ {
var channel = SocketGuildChannel.Create(this, state, model); var channel = SocketGuildChannel.Create(this, state, model);
@@ -297,14 +297,14 @@ namespace Discord.WebSocket
} }
//Integrations //Integrations
public Task<IReadOnlyCollection<RestGuildIntegration>> GetIntegrationsAsync() public Task<IReadOnlyCollection<RestGuildIntegration>> GetIntegrationsAsync(RequestOptions options = null)
=> GuildHelper.GetIntegrationsAsync(this, Discord); => GuildHelper.GetIntegrationsAsync(this, Discord, options);
public Task<RestGuildIntegration> CreateIntegrationAsync(ulong id, string type) public Task<RestGuildIntegration> CreateIntegrationAsync(ulong id, string type, RequestOptions options = null)
=> GuildHelper.CreateIntegrationAsync(this, Discord, id, type); => GuildHelper.CreateIntegrationAsync(this, Discord, id, type, options);
//Invites //Invites
public Task<IReadOnlyCollection<RestInviteMetadata>> GetInvitesAsync() public Task<IReadOnlyCollection<RestInviteMetadata>> GetInvitesAsync(RequestOptions options = null)
=> GuildHelper.GetInvitesAsync(this, Discord); => GuildHelper.GetInvitesAsync(this, Discord, options);
//Roles //Roles
public SocketRole GetRole(ulong id) public SocketRole GetRole(ulong id)
@@ -314,8 +314,9 @@ namespace Discord.WebSocket
return value; return value;
return null; return null;
} }
public Task<RestRole> CreateRoleAsync(string name, GuildPermissions? permissions = default(GuildPermissions?), Color? color = default(Color?), bool isHoisted = false) public Task<RestRole> CreateRoleAsync(string name, GuildPermissions? permissions = default(GuildPermissions?), Color? color = default(Color?),
=> GuildHelper.CreateRoleAsync(this, Discord, name, permissions, color, isHoisted); bool isHoisted = false, RequestOptions options = null)
=> GuildHelper.CreateRoleAsync(this, Discord, name, permissions, color, isHoisted, options);
internal SocketRole AddRole(RoleModel model) internal SocketRole AddRole(RoleModel model)
{ {
var role = SocketRole.Create(this, Discord.State, model); var role = SocketRole.Create(this, Discord.State, model);
@@ -345,8 +346,8 @@ namespace Discord.WebSocket
return member; return member;
return null; return null;
} }
public Task<int> PruneUsersAsync(int days = 30, bool simulate = false) public Task<int> PruneUsersAsync(int days = 30, bool simulate = false, RequestOptions options = null)
=> GuildHelper.PruneUsersAsync(this, Discord, days, simulate); => GuildHelper.PruneUsersAsync(this, Discord, days, simulate, options);
internal SocketGuildUser AddOrUpdateUser(MemberModel model) internal SocketGuildUser AddOrUpdateUser(MemberModel model)
{ {
@@ -532,36 +533,36 @@ namespace Discord.WebSocket
IRole IGuild.EveryoneRole => EveryoneRole; IRole IGuild.EveryoneRole => EveryoneRole;
IReadOnlyCollection<IRole> IGuild.Roles => Roles; IReadOnlyCollection<IRole> IGuild.Roles => Roles;
async Task<IReadOnlyCollection<IBan>> IGuild.GetBansAsync() async Task<IReadOnlyCollection<IBan>> IGuild.GetBansAsync(RequestOptions options)
=> await GetBansAsync(); => await GetBansAsync(options);
Task<IReadOnlyCollection<IGuildChannel>> IGuild.GetChannelsAsync(CacheMode mode) Task<IReadOnlyCollection<IGuildChannel>> IGuild.GetChannelsAsync(CacheMode mode, RequestOptions options)
=> Task.FromResult<IReadOnlyCollection<IGuildChannel>>(Channels); => Task.FromResult<IReadOnlyCollection<IGuildChannel>>(Channels);
Task<IGuildChannel> IGuild.GetChannelAsync(ulong id, CacheMode mode) Task<IGuildChannel> IGuild.GetChannelAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IGuildChannel>(GetChannel(id)); => Task.FromResult<IGuildChannel>(GetChannel(id));
async Task<ITextChannel> IGuild.CreateTextChannelAsync(string name) async Task<ITextChannel> IGuild.CreateTextChannelAsync(string name, RequestOptions options)
=> await CreateTextChannelAsync(name); => await CreateTextChannelAsync(name, options);
async Task<IVoiceChannel> IGuild.CreateVoiceChannelAsync(string name) async Task<IVoiceChannel> IGuild.CreateVoiceChannelAsync(string name, RequestOptions options)
=> await CreateVoiceChannelAsync(name); => await CreateVoiceChannelAsync(name, options);
async Task<IReadOnlyCollection<IGuildIntegration>> IGuild.GetIntegrationsAsync() async Task<IReadOnlyCollection<IGuildIntegration>> IGuild.GetIntegrationsAsync(RequestOptions options)
=> await GetIntegrationsAsync(); => await GetIntegrationsAsync(options);
async Task<IGuildIntegration> IGuild.CreateIntegrationAsync(ulong id, string type) async Task<IGuildIntegration> IGuild.CreateIntegrationAsync(ulong id, string type, RequestOptions options)
=> await CreateIntegrationAsync(id, type); => await CreateIntegrationAsync(id, type, options);
async Task<IReadOnlyCollection<IInviteMetadata>> IGuild.GetInvitesAsync() async Task<IReadOnlyCollection<IInviteMetadata>> IGuild.GetInvitesAsync(RequestOptions options)
=> await GetInvitesAsync(); => await GetInvitesAsync(options);
IRole IGuild.GetRole(ulong id) IRole IGuild.GetRole(ulong id)
=> GetRole(id); => GetRole(id);
async Task<IRole> IGuild.CreateRoleAsync(string name, GuildPermissions? permissions, Color? color, bool isHoisted) async Task<IRole> IGuild.CreateRoleAsync(string name, GuildPermissions? permissions, Color? color, bool isHoisted, RequestOptions options)
=> await CreateRoleAsync(name, permissions, color, isHoisted); => await CreateRoleAsync(name, permissions, color, isHoisted, options);
Task<IReadOnlyCollection<IGuildUser>> IGuild.GetUsersAsync(CacheMode mode) Task<IReadOnlyCollection<IGuildUser>> IGuild.GetUsersAsync(CacheMode mode, RequestOptions options)
=> Task.FromResult<IReadOnlyCollection<IGuildUser>>(Users); => Task.FromResult<IReadOnlyCollection<IGuildUser>>(Users);
Task<IGuildUser> IGuild.GetUserAsync(ulong id, CacheMode mode) Task<IGuildUser> IGuild.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
=> Task.FromResult<IGuildUser>(GetUser(id)); => Task.FromResult<IGuildUser>(GetUser(id));
Task<IGuildUser> IGuild.GetCurrentUserAsync(CacheMode mode) Task<IGuildUser> IGuild.GetCurrentUserAsync(CacheMode mode, RequestOptions options)
=> Task.FromResult<IGuildUser>(GetCurrentUser()); => Task.FromResult<IGuildUser>(GetCurrentUser());
Task IGuild.DownloadUsersAsync() { throw new NotSupportedException(); } Task IGuild.DownloadUsersAsync() { throw new NotSupportedException(); }
} }

16
src/Discord.Net.WebSocket/Entities/Messages/SocketUserMessage.cs
View File

@@ -112,15 +112,15 @@ namespace Discord.WebSocket
} }
} }
public Task ModifyAsync(Action<ModifyMessageParams> func) public Task ModifyAsync(Action<ModifyMessageParams> func, RequestOptions options = null)
=> MessageHelper.ModifyAsync(this, Discord, func); => MessageHelper.ModifyAsync(this, Discord, func, options);
public Task DeleteAsync() public Task DeleteAsync(RequestOptions options = null)
=> MessageHelper.DeleteAsync(this, Discord); => MessageHelper.DeleteAsync(this, Discord, options);
public Task PinAsync() public Task PinAsync(RequestOptions options = null)
=> MessageHelper.PinAsync(this, Discord); => MessageHelper.PinAsync(this, Discord, options);
public Task UnpinAsync() public Task UnpinAsync(RequestOptions options = null)
=> MessageHelper.UnpinAsync(this, Discord); => MessageHelper.UnpinAsync(this, Discord, options);
public string Resolve(UserMentionHandling userHandling = UserMentionHandling.Name, ChannelMentionHandling channelHandling = ChannelMentionHandling.Name, public string Resolve(UserMentionHandling userHandling = UserMentionHandling.Name, ChannelMentionHandling channelHandling = ChannelMentionHandling.Name,
RoleMentionHandling roleHandling = RoleMentionHandling.Name, EveryoneMentionHandling everyoneHandling = EveryoneMentionHandling.Ignore) RoleMentionHandling roleHandling = RoleMentionHandling.Name, EveryoneMentionHandling everyoneHandling = EveryoneMentionHandling.Ignore)

8
src/Discord.Net.WebSocket/Entities/Roles/SocketRole.cs
View File

@@ -43,10 +43,10 @@ namespace Discord.WebSocket
Permissions = new GuildPermissions(model.Permissions); Permissions = new GuildPermissions(model.Permissions);
} }
public Task ModifyAsync(Action<ModifyGuildRoleParams> func) public Task ModifyAsync(Action<ModifyGuildRoleParams> func, RequestOptions options)
=> RoleHelper.ModifyAsync(this, Discord, func); => RoleHelper.ModifyAsync(this, Discord, func, options);
public Task DeleteAsync() public Task DeleteAsync(RequestOptions options)
=> RoleHelper.DeleteAsync(this, Discord); => RoleHelper.DeleteAsync(this, Discord, options);
public override string ToString() => Name; public override string ToString() => Name;
private string DebuggerDisplay => $"{Name} ({Id})"; private string DebuggerDisplay => $"{Name} ({Id})";

10
src/Discord.Net.WebSocket/Entities/Users/SocketGuildUser.cs
View File

@@ -82,10 +82,10 @@ namespace Discord.WebSocket
_roleIds = roles.ToImmutable(); _roleIds = roles.ToImmutable();
} }
public Task ModifyAsync(Action<ModifyGuildMemberParams> func) public Task ModifyAsync(Action<ModifyGuildMemberParams> func, RequestOptions options = null)
=> UserHelper.ModifyAsync(this, Discord, func); => UserHelper.ModifyAsync(this, Discord, func, options);
public Task KickAsync() public Task KickAsync(RequestOptions options = null)
=> UserHelper.KickAsync(this, Discord); => UserHelper.KickAsync(this, Discord, options);
public ChannelPermissions GetPermissions(IGuildChannel channel) public ChannelPermissions GetPermissions(IGuildChannel channel)
=> new ChannelPermissions(Permissions.ResolveChannel(Guild, this, channel, GuildPermissions.RawValue)); => new ChannelPermissions(Permissions.ResolveChannel(Guild, this, channel, GuildPermissions.RawValue));
@@ -97,7 +97,7 @@ namespace Discord.WebSocket
IReadOnlyCollection<ulong> IGuildUser.RoleIds => RoleIds; IReadOnlyCollection<ulong> IGuildUser.RoleIds => RoleIds;
//IUser //IUser
Task<IDMChannel> IUser.GetDMChannelAsync(CacheMode mode) Task<IDMChannel> IUser.GetDMChannelAsync(CacheMode mode, RequestOptions options)
=> Task.FromResult<IDMChannel>(GlobalUser.DMChannel); => Task.FromResult<IDMChannel>(GlobalUser.DMChannel);
//IVoiceState //IVoiceState

8
src/Discord.Net.WebSocket/Entities/Users/SocketPresence.cs
View File

@@ -7,17 +7,17 @@ namespace Discord.WebSocket
[DebuggerDisplay(@"{DebuggerDisplay,nq}")] [DebuggerDisplay(@"{DebuggerDisplay,nq}")]
public struct SocketPresence : IPresence public struct SocketPresence : IPresence
{ {
public Game? Game { get; }
public UserStatus Status { get; } public UserStatus Status { get; }
public Game? Game { get; }
internal SocketPresence(Game? game, UserStatus status) internal SocketPresence(UserStatus status, Game? game)
{ {
Game = game;
Status = status; Status = status;
Game = game;
} }
internal static SocketPresence Create(Model model) internal static SocketPresence Create(Model model)
{ {
return new SocketPresence(model.Game != null ? Discord.Game.Create(model.Game) : (Game?)null, model.Status); return new SocketPresence(model.Status, model.Game != null ? Discord.Game.Create(model.Game) : (Game?)null);
} }
public override string ToString() => Status.ToString(); public override string ToString() => Status.ToString();

10
src/Discord.Net.WebSocket/Entities/Users/SocketUser.cs
View File

@@ -40,17 +40,17 @@ namespace Discord.WebSocket
Presence = SocketPresence.Create(model); Presence = SocketPresence.Create(model);
} }
public Task<RestDMChannel> CreateDMChannelAsync() public Task<RestDMChannel> CreateDMChannelAsync(RequestOptions options = null)
=> UserHelper.CreateDMChannelAsync(this, Discord); => UserHelper.CreateDMChannelAsync(this, Discord, options);
public override string ToString() => $"{Username}#{Discriminator}"; public override string ToString() => $"{Username}#{Discriminator}";
internal string DebuggerDisplay => $"{Username}#{Discriminator} ({Id}{(IsBot ? ", Bot" : "")})"; internal string DebuggerDisplay => $"{Username}#{Discriminator} ({Id}{(IsBot ? ", Bot" : "")})";
internal SocketUser Clone() => MemberwiseClone() as SocketUser; internal SocketUser Clone() => MemberwiseClone() as SocketUser;
//IUser //IUser
Task<IDMChannel> IUser.GetDMChannelAsync(CacheMode mode) Task<IDMChannel> IUser.GetDMChannelAsync(CacheMode mode, RequestOptions options)
=> Task.FromResult<IDMChannel>(GlobalUser.DMChannel); => Task.FromResult<IDMChannel>(GlobalUser.DMChannel);
async Task<IDMChannel> IUser.CreateDMChannelAsync() async Task<IDMChannel> IUser.CreateDMChannelAsync(RequestOptions options)
=> await CreateDMChannelAsync(); => await CreateDMChannelAsync(options);
} }
} }