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

Removed old bucket system, cleaned up api calls. Fixed compile errors.

Browse Source
This commit is contained in:
RogueException
2016-09-29 05:10:40 -03:00
parent dd86f03306
commit e038475ab4
59 changed files with 464 additions and 570 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/Discord.Net.Rest/DiscordClient.cs → src/Discord.Net.Rest/BaseDiscordClient.cs
View File

@@ -8,7 +8,7 @@ using System.Collections.Immutable;
namespace Discord.Rest
{
public abstract class DiscordClient : IDiscordClient
public abstract class BaseDiscordClient : IDiscordClient
{
public event Func<LogMessage, Task> Log { add { _logEvent.Add(value); } remove { _logEvent.Remove(value); } }
private readonly AsyncEvent<Func<LogMessage, Task>> _logEvent = new AsyncEvent<Func<LogMessage, Task>>();
@@ -29,7 +29,7 @@ namespace Discord.Rest
public ISelfUser CurrentUser { get; protected set; }
/// <summary> Creates a new REST-only discord client. </summary>
internal DiscordClient(DiscordRestConfig config, API.DiscordRestApiClient client)
internal BaseDiscordClient(DiscordRestConfig config, API.DiscordRestApiClient client)
{
ApiClient = client;
LogManager = new LogManager(config.LogLevel);
@@ -73,6 +73,7 @@ namespace Discord.Rest
try
{
await ApiClient.LoginAsync(tokenType, token).ConfigureAwait(false);
await OnLoginAsync(tokenType, token).ConfigureAwait(false);
LoginState = LoginState.LoggedIn;
}

28
src/Discord.Net.Rest/ClientHelper.cs
View File

@@ -10,13 +10,13 @@ namespace Discord.Rest
internal static class ClientHelper
{
//Applications
public static async Task<RestApplication> GetApplicationInfoAsync(DiscordClient client)
public static async Task<RestApplication> GetApplicationInfoAsync(BaseDiscordClient client)
{
var model = await client.ApiClient.GetMyApplicationAsync().ConfigureAwait(false);
return RestApplication.Create(client, model);
}
public static async Task<RestChannel> GetChannelAsync(DiscordClient client,
public static async Task<RestChannel> GetChannelAsync(BaseDiscordClient client,
ulong id)
{
var model = await client.ApiClient.GetChannelAsync(id).ConfigureAwait(false);
@@ -24,19 +24,19 @@ namespace Discord.Rest
return RestChannel.Create(client, model);
return null;
}
public static async Task<IReadOnlyCollection<IPrivateChannel>> GetPrivateChannelsAsync(DiscordClient client)
public static async Task<IReadOnlyCollection<IPrivateChannel>> GetPrivateChannelsAsync(BaseDiscordClient client)
{
var models = await client.ApiClient.GetMyPrivateChannelsAsync().ConfigureAwait(false);
return models.Select(x => RestDMChannel.Create(client, x)).ToImmutableArray();
}
public static async Task<IReadOnlyCollection<RestConnection>> GetConnectionsAsync(DiscordClient client)
public static async Task<IReadOnlyCollection<RestConnection>> GetConnectionsAsync(BaseDiscordClient client)
{
var models = await client.ApiClient.GetMyConnectionsAsync().ConfigureAwait(false);
return models.Select(x => RestConnection.Create(x)).ToImmutableArray();
}
public static async Task<RestInvite> GetInviteAsync(DiscordClient client,
public static async Task<RestInvite> GetInviteAsync(BaseDiscordClient client,
string inviteId)
{
var model = await client.ApiClient.GetInviteAsync(inviteId).ConfigureAwait(false);
@@ -45,7 +45,7 @@ namespace Discord.Rest
return null;
}
public static async Task<RestGuild> GetGuildAsync(DiscordClient client,
public static async Task<RestGuild> GetGuildAsync(BaseDiscordClient client,
ulong id)
{
var model = await client.ApiClient.GetGuildAsync(id).ConfigureAwait(false);
@@ -53,7 +53,7 @@ namespace Discord.Rest
return RestGuild.Create(client, model);
return null;
}
public static async Task<RestGuildEmbed?> GetGuildEmbedAsync(DiscordClient client,
public static async Task<RestGuildEmbed?> GetGuildEmbedAsync(BaseDiscordClient client,
ulong id)
{
var model = await client.ApiClient.GetGuildEmbedAsync(id).ConfigureAwait(false);
@@ -61,12 +61,12 @@ namespace Discord.Rest
return RestGuildEmbed.Create(model);
return null;
}
public static async Task<IReadOnlyCollection<RestUserGuild>> GetGuildSummariesAsync(DiscordClient client)
public static async Task<IReadOnlyCollection<RestUserGuild>> GetGuildSummariesAsync(BaseDiscordClient client)
{
var models = await client.ApiClient.GetMyGuildsAsync().ConfigureAwait(false);
return models.Select(x => RestUserGuild.Create(client, x)).ToImmutableArray();
}
public static async Task<IReadOnlyCollection<RestGuild>> GetGuildsAsync(DiscordClient client)
public static async Task<IReadOnlyCollection<RestGuild>> GetGuildsAsync(BaseDiscordClient client)
{
var summaryModels = await client.ApiClient.GetMyGuildsAsync().ConfigureAwait(false);
var guilds = ImmutableArray.CreateBuilder<RestGuild>(summaryModels.Count);
@@ -78,7 +78,7 @@ namespace Discord.Rest
}
return guilds.ToImmutable();
}
public static async Task<RestGuild> CreateGuildAsync(DiscordClient client,
public static async Task<RestGuild> CreateGuildAsync(BaseDiscordClient client,
string name, IVoiceRegion region, Stream jpegIcon = null)
{
var args = new CreateGuildParams(name, region.Id);
@@ -86,7 +86,7 @@ namespace Discord.Rest
return RestGuild.Create(client, model);
}
public static async Task<RestUser> GetUserAsync(DiscordClient client,
public static async Task<RestUser> GetUserAsync(BaseDiscordClient client,
ulong id)
{
var model = await client.ApiClient.GetUserAsync(id).ConfigureAwait(false);
@@ -94,7 +94,7 @@ namespace Discord.Rest
return RestUser.Create(client, model);
return null;
}
public static async Task<RestUser> GetUserAsync(DiscordClient client,
public static async Task<RestUser> GetUserAsync(BaseDiscordClient client,
string username, string discriminator)
{
var model = await client.ApiClient.GetUserAsync(username, discriminator).ConfigureAwait(false);
@@ -103,12 +103,12 @@ namespace Discord.Rest
return null;
}
public static async Task<IReadOnlyCollection<RestVoiceRegion>> GetVoiceRegionsAsync(DiscordClient client)
public static async Task<IReadOnlyCollection<RestVoiceRegion>> GetVoiceRegionsAsync(BaseDiscordClient client)
{
var models = await client.ApiClient.GetVoiceRegionsAsync().ConfigureAwait(false);
return models.Select(x => RestVoiceRegion.Create(client, x)).ToImmutableArray();
}
public static async Task<RestVoiceRegion> GetVoiceRegionAsync(DiscordClient client,
public static async Task<RestVoiceRegion> GetVoiceRegionAsync(BaseDiscordClient client,
string id)
{
var models = await client.ApiClient.GetVoiceRegionsAsync().ConfigureAwait(false);

6
src/Discord.Net.Rest/DiscordRestClient.cs
View File

@@ -5,7 +5,7 @@ using System.Threading.Tasks;
namespace Discord.Rest
{
public class DiscordRestClient : DiscordClient, IDiscordClient
public class DiscordRestClient : BaseDiscordClient, IDiscordClient
{
public new RestSelfUser CurrentUser => base.CurrentUser as RestSelfUser;
@@ -15,10 +15,10 @@ namespace Discord.Rest
private static API.DiscordRestApiClient CreateApiClient(DiscordRestConfig config)
=> new API.DiscordRestApiClient(config.RestClientProvider, DiscordRestConfig.UserAgent, requestQueue: new RequestQueue());
protected override async Task OnLoginAsync(TokenType tokenType, string token)
protected override Task OnLoginAsync(TokenType tokenType, string token)
{
await ApiClient.LoginAsync(tokenType, token).ConfigureAwait(false);
base.CurrentUser = RestSelfUser.Create(this, ApiClient.CurrentUser);
return Task.CompletedTask;
}
/// <inheritdoc />

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

@@ -12,33 +12,33 @@ namespace Discord.Rest
internal static class ChannelHelper
{
//General
public static async Task<Model> GetAsync(IGuildChannel channel, DiscordClient client)
public static async Task<Model> GetAsync(IGuildChannel channel, BaseDiscordClient client)
{
return await client.ApiClient.GetChannelAsync(channel.GuildId, channel.Id).ConfigureAwait(false);
}
public static async Task<Model> GetAsync(IPrivateChannel channel, DiscordClient client)
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, DiscordClient client)
public static async Task DeleteAsync(IChannel channel, BaseDiscordClient client)
{
await client.ApiClient.DeleteChannelAsync(channel.Id).ConfigureAwait(false);
}
public static async Task ModifyAsync(IGuildChannel channel, DiscordClient client,
public static async Task ModifyAsync(IGuildChannel channel, BaseDiscordClient client,
Action<ModifyGuildChannelParams> func)
{
var args = new ModifyGuildChannelParams();
func(args);
await client.ApiClient.ModifyGuildChannelAsync(channel.Id, args);
}
public static async Task ModifyAsync(ITextChannel channel, DiscordClient client,
public static async Task ModifyAsync(ITextChannel channel, BaseDiscordClient client,
Action<ModifyTextChannelParams> func)
{
var args = new ModifyTextChannelParams();
func(args);
await client.ApiClient.ModifyGuildChannelAsync(channel.Id, args);
}
public static async Task ModifyAsync(IVoiceChannel channel, DiscordClient client,
public static async Task ModifyAsync(IVoiceChannel channel, BaseDiscordClient client,
Action<ModifyVoiceChannelParams> func)
{
var args = new ModifyVoiceChannelParams();
@@ -47,12 +47,12 @@ namespace Discord.Rest
}
//Invites
public static async Task<IReadOnlyCollection<RestInviteMetadata>> GetInvitesAsync(IChannel channel, DiscordClient client)
public static async Task<IReadOnlyCollection<RestInviteMetadata>> GetInvitesAsync(IChannel channel, BaseDiscordClient client)
{
var models = await client.ApiClient.GetChannelInvitesAsync(channel.Id);
return models.Select(x => RestInviteMetadata.Create(client, x)).ToImmutableArray();
}
public static async Task<RestInviteMetadata> CreateInviteAsync(IChannel channel, DiscordClient client,
public static async Task<RestInviteMetadata> CreateInviteAsync(IChannel channel, BaseDiscordClient client,
int? maxAge, int? maxUses, bool isTemporary)
{
var args = new CreateChannelInviteParams { IsTemporary = isTemporary };
@@ -65,13 +65,13 @@ namespace Discord.Rest
}
//Messages
public static async Task<RestMessage> GetMessageAsync(IChannel channel, DiscordClient client,
public static async Task<RestMessage> GetMessageAsync(IChannel channel, BaseDiscordClient client,
ulong id)
{
var model = await client.ApiClient.GetChannelMessageAsync(channel.Id, id).ConfigureAwait(false);
return RestMessage.Create(client, model);
}
public static IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(IChannel channel, DiscordClient client,
public static IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(IChannel channel, BaseDiscordClient client,
ulong? fromMessageId = null, Direction dir = Direction.Before, int limit = DiscordConfig.MaxMessagesPerBatch)
{
//TODO: Test this with Around direction
@@ -102,13 +102,13 @@ namespace Discord.Rest
count: (uint)limit
);
}
public static async Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync(IChannel channel, DiscordClient client)
public static async Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync(IChannel channel, BaseDiscordClient client)
{
var models = await client.ApiClient.GetPinsAsync(channel.Id).ConfigureAwait(false);
return models.Select(x => RestMessage.Create(client, x)).ToImmutableArray();
}
public static async Task<RestUserMessage> SendMessageAsync(IChannel channel, DiscordClient client,
public static async Task<RestUserMessage> SendMessageAsync(IChannel channel, BaseDiscordClient client,
string text, bool isTTS)
{
var args = new CreateMessageParams(text) { IsTTS = isTTS };
@@ -116,14 +116,14 @@ namespace Discord.Rest
return RestUserMessage.Create(client, model);
}
public static Task<RestUserMessage> SendFileAsync(IChannel channel, DiscordClient client,
public static Task<RestUserMessage> SendFileAsync(IChannel channel, BaseDiscordClient client,
string filePath, string text, bool isTTS)
{
string filename = Path.GetFileName(filePath);
using (var file = File.OpenRead(filePath))
return SendFileAsync(channel, client, file, filename, text, isTTS);
}
public static async Task<RestUserMessage> SendFileAsync(IChannel channel, DiscordClient client,
public static async Task<RestUserMessage> SendFileAsync(IChannel channel, BaseDiscordClient client,
Stream stream, string filename, string text, bool isTTS)
{
var args = new UploadFileParams(stream) { Filename = filename, Content = text, IsTTS = isTTS };
@@ -131,7 +131,7 @@ namespace Discord.Rest
return RestUserMessage.Create(client, model);
}
public static async Task DeleteMessagesAsync(IChannel channel, DiscordClient client,
public static async Task DeleteMessagesAsync(IChannel channel, BaseDiscordClient client,
IEnumerable<IMessage> messages)
{
var args = new DeleteMessagesParams(messages.Select(x => x.Id).ToArray());
@@ -139,31 +139,31 @@ namespace Discord.Rest
}
//Permission Overwrites
public static async Task AddPermissionOverwriteAsync(IGuildChannel channel, DiscordClient client,
public static async Task AddPermissionOverwriteAsync(IGuildChannel channel, BaseDiscordClient client,
IUser user, OverwritePermissions perms)
{
var args = new ModifyChannelPermissionsParams("member", perms.AllowValue, perms.DenyValue);
await client.ApiClient.ModifyChannelPermissionsAsync(channel.Id, user.Id, args).ConfigureAwait(false);
}
public static async Task AddPermissionOverwriteAsync(IGuildChannel channel, DiscordClient client,
public static async Task AddPermissionOverwriteAsync(IGuildChannel channel, BaseDiscordClient client,
IRole role, OverwritePermissions perms)
{
var args = new ModifyChannelPermissionsParams("role", perms.AllowValue, perms.DenyValue);
await client.ApiClient.ModifyChannelPermissionsAsync(channel.Id, role.Id, args).ConfigureAwait(false);
}
public static async Task RemovePermissionOverwriteAsync(IGuildChannel channel, DiscordClient client,
public static async Task RemovePermissionOverwriteAsync(IGuildChannel channel, BaseDiscordClient client,
IUser user)
{
await client.ApiClient.DeleteChannelPermissionAsync(channel.Id, user.Id).ConfigureAwait(false);
}
public static async Task RemovePermissionOverwriteAsync(IGuildChannel channel, DiscordClient client,
public static async Task RemovePermissionOverwriteAsync(IGuildChannel channel, BaseDiscordClient client,
IRole role)
{
await client.ApiClient.DeleteChannelPermissionAsync(channel.Id, role.Id).ConfigureAwait(false);
}
//Users
public static async Task<RestGuildUser> GetUserAsync(IGuildChannel channel, DiscordClient client,
public static async Task<RestGuildUser> GetUserAsync(IGuildChannel channel, BaseDiscordClient client,
ulong id)
{
var model = await client.ApiClient.GetGuildMemberAsync(channel.GuildId, id);
@@ -175,7 +175,7 @@ namespace Discord.Rest
return user;
}
public static IAsyncEnumerable<IReadOnlyCollection<RestGuildUser>> GetUsersAsync(IGuildChannel channel, DiscordClient client,
public static IAsyncEnumerable<IReadOnlyCollection<RestGuildUser>> GetUsersAsync(IGuildChannel channel, BaseDiscordClient client,
ulong? froUserId = null, uint? limit = DiscordConfig.MaxUsersPerBatch)
{
return new PagedAsyncEnumerable<RestGuildUser>(
@@ -203,7 +203,7 @@ namespace Discord.Rest
}
//Typing
public static IDisposable EnterTypingState(IChannel channel, DiscordClient client)
public static IDisposable EnterTypingState(IChannel channel, BaseDiscordClient client)
{
throw new NotImplementedException(); //TODO: Impl
}

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

@@ -11,11 +11,11 @@ namespace Discord.Rest
[DebuggerDisplay(@"{DebuggerDisplay,nq}")]
public abstract class RestChannel : RestEntity<ulong>, IChannel, IUpdateable
{
internal RestChannel(DiscordClient discord, ulong id)
internal RestChannel(BaseDiscordClient discord, ulong id)
: base(discord, id)
{
}
internal static RestChannel Create(DiscordClient discord, Model model)
internal static RestChannel Create(BaseDiscordClient discord, Model model)
{
switch (model.Type)
{

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

@@ -17,13 +17,13 @@ namespace Discord.Rest
public IReadOnlyCollection<RestUser> Users => ImmutableArray.Create(CurrentUser, Recipient);
internal RestDMChannel(DiscordClient discord, ulong id, ulong recipientId)
internal RestDMChannel(BaseDiscordClient discord, ulong id, ulong recipientId)
: base(discord, id)
{
Recipient = new RestUser(Discord, recipientId);
CurrentUser = new RestUser(Discord, discord.CurrentUser.Id);
}
internal new static RestDMChannel Create(DiscordClient discord, Model model)
internal new static RestDMChannel Create(BaseDiscordClient discord, Model model)
{
var entity = new RestDMChannel(discord, model.Id, model.Recipients.Value[0].Id);
entity.Update(model);

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

@@ -21,11 +21,11 @@ namespace Discord.Rest
public IReadOnlyCollection<RestGroupUser> Recipients
=> _users.Select(x => x.Value).Where(x => x.Id != Discord.CurrentUser.Id).ToReadOnlyCollection(() => _users.Count - 1);
internal RestGroupChannel(DiscordClient discord, ulong id)
internal RestGroupChannel(BaseDiscordClient discord, ulong id)
: base(discord, id)
{
}
internal new static RestGroupChannel Create(DiscordClient discord, Model model)
internal new static RestGroupChannel Create(BaseDiscordClient discord, Model model)
{
var entity = new RestGroupChannel(discord, model.Id);
entity.Update(model);

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

@@ -21,12 +21,12 @@ namespace Discord.Rest
public string Name { get; private set; }
public int Position { get; private set; }
internal RestGuildChannel(DiscordClient discord, ulong id, ulong guildId)
internal RestGuildChannel(BaseDiscordClient discord, ulong id, ulong guildId)
: base(discord, id)
{
GuildId = guildId;
}
internal new static RestGuildChannel Create(DiscordClient discord, Model model)
internal new static RestGuildChannel Create(BaseDiscordClient discord, Model model)
{
switch (model.Type)
{

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

@@ -16,11 +16,11 @@ namespace Discord.Rest
public string Mention => MentionUtils.MentionChannel(Id);
internal RestTextChannel(DiscordClient discord, ulong id, ulong guildId)
internal RestTextChannel(BaseDiscordClient discord, ulong id, ulong guildId)
: base(discord, id, guildId)
{
}
internal new static RestTextChannel Create(DiscordClient discord, Model model)
internal new static RestTextChannel Create(BaseDiscordClient discord, Model model)
{
var entity = new RestTextChannel(discord, model.Id, model.GuildId.Value);
entity.Update(model);

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

@@ -16,11 +16,11 @@ namespace Discord.Rest
public int Bitrate { get; private set; }
public int UserLimit { get; private set; }
internal RestVoiceChannel(DiscordClient discord, ulong id, ulong guildId)
internal RestVoiceChannel(BaseDiscordClient discord, ulong id, ulong guildId)
: base(discord, id, guildId)
{
}
internal new static RestVoiceChannel Create(DiscordClient discord, Model model)
internal new static RestVoiceChannel Create(BaseDiscordClient discord, Model model)
{
var entity = new RestVoiceChannel(discord, model.Id, model.GuildId.Value);
entity.Update(model);

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

@@ -13,7 +13,7 @@ namespace Discord.Rest
internal static class GuildHelper
{
//General
public static async Task<Model> ModifyAsync(IGuild guild, DiscordClient client,
public static async Task<Model> ModifyAsync(IGuild guild, BaseDiscordClient client,
Action<ModifyGuildParams> func)
{
if (func == null) throw new NullReferenceException(nameof(func));
@@ -28,7 +28,7 @@ namespace Discord.Rest
return await client.ApiClient.ModifyGuildAsync(guild.Id, args).ConfigureAwait(false);
}
public static async Task<EmbedModel> ModifyEmbedAsync(IGuild guild, DiscordClient client,
public static async Task<EmbedModel> ModifyEmbedAsync(IGuild guild, BaseDiscordClient client,
Action<ModifyGuildEmbedParams> func)
{
if (func == null) throw new NullReferenceException(nameof(func));
@@ -37,46 +37,46 @@ namespace Discord.Rest
func(args);
return await client.ApiClient.ModifyGuildEmbedAsync(guild.Id, args).ConfigureAwait(false);
}
public static async Task ModifyChannelsAsync(IGuild guild, DiscordClient client,
public static async Task ModifyChannelsAsync(IGuild guild, BaseDiscordClient client,
IEnumerable<ModifyGuildChannelsParams> args)
{
await client.ApiClient.ModifyGuildChannelsAsync(guild.Id, args).ConfigureAwait(false);
}
public static async Task<IReadOnlyCollection<RoleModel>> ModifyRolesAsync(IGuild guild, DiscordClient client,
public static async Task<IReadOnlyCollection<RoleModel>> ModifyRolesAsync(IGuild guild, BaseDiscordClient client,
IEnumerable<ModifyGuildRolesParams> args)
{
return await client.ApiClient.ModifyGuildRolesAsync(guild.Id, args).ConfigureAwait(false);
}
public static async Task LeaveAsync(IGuild guild, DiscordClient client)
public static async Task LeaveAsync(IGuild guild, BaseDiscordClient client)
{
await client.ApiClient.LeaveGuildAsync(guild.Id).ConfigureAwait(false);
}
public static async Task DeleteAsync(IGuild guild, DiscordClient client)
public static async Task DeleteAsync(IGuild guild, BaseDiscordClient client)
{
await client.ApiClient.DeleteGuildAsync(guild.Id).ConfigureAwait(false);
}
//Bans
public static async Task<IReadOnlyCollection<RestBan>> GetBansAsync(IGuild guild, DiscordClient client)
public static async Task<IReadOnlyCollection<RestBan>> GetBansAsync(IGuild guild, BaseDiscordClient client)
{
var models = await client.ApiClient.GetGuildBansAsync(guild.Id);
return models.Select(x => RestBan.Create(client, x)).ToImmutableArray();
}
public static async Task AddBanAsync(IGuild guild, DiscordClient client,
public static async Task AddBanAsync(IGuild guild, BaseDiscordClient client,
ulong userId, int pruneDays)
{
var args = new CreateGuildBanParams { DeleteMessageDays = pruneDays };
await client.ApiClient.CreateGuildBanAsync(guild.Id, userId, args);
}
public static async Task RemoveBanAsync(IGuild guild, DiscordClient client,
public static async Task RemoveBanAsync(IGuild guild, BaseDiscordClient client,
ulong userId)
{
await client.ApiClient.RemoveGuildBanAsync(guild.Id, userId);
}
//Channels
public static async Task<RestGuildChannel> GetChannelAsync(IGuild guild, DiscordClient client,
public static async Task<RestGuildChannel> GetChannelAsync(IGuild guild, BaseDiscordClient client,
ulong id)
{
var model = await client.ApiClient.GetChannelAsync(guild.Id, id).ConfigureAwait(false);
@@ -84,12 +84,12 @@ namespace Discord.Rest
return RestGuildChannel.Create(client, model);
return null;
}
public static async Task<IReadOnlyCollection<RestGuildChannel>> GetChannelsAsync(IGuild guild, DiscordClient client)
public static async Task<IReadOnlyCollection<RestGuildChannel>> GetChannelsAsync(IGuild guild, BaseDiscordClient client)
{
var models = await client.ApiClient.GetGuildChannelsAsync(guild.Id).ConfigureAwait(false);
return models.Select(x => RestGuildChannel.Create(client, x)).ToImmutableArray();
}
public static async Task<RestTextChannel> CreateTextChannelAsync(IGuild guild, DiscordClient client,
public static async Task<RestTextChannel> CreateTextChannelAsync(IGuild guild, BaseDiscordClient client,
string name)
{
if (name == null) throw new ArgumentNullException(nameof(name));
@@ -98,7 +98,7 @@ namespace Discord.Rest
var model = await client.ApiClient.CreateGuildChannelAsync(guild.Id, args).ConfigureAwait(false);
return RestTextChannel.Create(client, model);
}
public static async Task<RestVoiceChannel> CreateVoiceChannelAsync(IGuild guild, DiscordClient client,
public static async Task<RestVoiceChannel> CreateVoiceChannelAsync(IGuild guild, BaseDiscordClient client,
string name)
{
if (name == null) throw new ArgumentNullException(nameof(name));
@@ -109,12 +109,12 @@ namespace Discord.Rest
}
//Integrations
public static async Task<IReadOnlyCollection<RestGuildIntegration>> GetIntegrationsAsync(IGuild guild, DiscordClient client)
public static async Task<IReadOnlyCollection<RestGuildIntegration>> GetIntegrationsAsync(IGuild guild, BaseDiscordClient client)
{
var models = await client.ApiClient.GetGuildIntegrationsAsync(guild.Id).ConfigureAwait(false);
return models.Select(x => RestGuildIntegration.Create(client, x)).ToImmutableArray();
}
public static async Task<RestGuildIntegration> CreateIntegrationAsync(IGuild guild, DiscordClient client,
public static async Task<RestGuildIntegration> CreateIntegrationAsync(IGuild guild, BaseDiscordClient client,
ulong id, string type)
{
var args = new CreateGuildIntegrationParams(id, type);
@@ -123,14 +123,14 @@ namespace Discord.Rest
}
//Invites
public static async Task<IReadOnlyCollection<RestInviteMetadata>> GetInvitesAsync(IGuild guild, DiscordClient client)
public static async Task<IReadOnlyCollection<RestInviteMetadata>> GetInvitesAsync(IGuild guild, BaseDiscordClient client)
{
var models = await client.ApiClient.GetGuildInvitesAsync(guild.Id).ConfigureAwait(false);
return models.Select(x => RestInviteMetadata.Create(client, x)).ToImmutableArray();
}
//Roles
public static async Task<RestRole> CreateRoleAsync(IGuild guild, DiscordClient client,
public static async Task<RestRole> CreateRoleAsync(IGuild guild, BaseDiscordClient client,
string name, GuildPermissions? permissions = null, Color? color = null, bool isHoisted = false)
{
if (name == null) throw new ArgumentNullException(nameof(name));
@@ -150,7 +150,7 @@ namespace Discord.Rest
}
//Users
public static async Task<RestGuildUser> GetUserAsync(IGuild guild, DiscordClient client,
public static async Task<RestGuildUser> GetUserAsync(IGuild guild, BaseDiscordClient client,
ulong id)
{
var model = await client.ApiClient.GetGuildMemberAsync(guild.Id, id).ConfigureAwait(false);
@@ -158,17 +158,17 @@ namespace Discord.Rest
return RestGuildUser.Create(client, model);
return null;
}
public static async Task<RestGuildUser> GetCurrentUserAsync(IGuild guild, DiscordClient client)
public static async Task<RestGuildUser> GetCurrentUserAsync(IGuild guild, BaseDiscordClient client)
{
return await GetUserAsync(guild, client, client.CurrentUser.Id).ConfigureAwait(false);
}
public static async Task<IReadOnlyCollection<RestGuildUser>> GetUsersAsync(IGuild guild, DiscordClient client)
public static async Task<IReadOnlyCollection<RestGuildUser>> GetUsersAsync(IGuild guild, BaseDiscordClient client)
{
var args = new GetGuildMembersParams();
var models = await client.ApiClient.GetGuildMembersAsync(guild.Id, args).ConfigureAwait(false);
return models.Select(x => RestGuildUser.Create(client, x)).ToImmutableArray();
}
public static async Task<int> PruneUsersAsync(IGuild guild, DiscordClient client,
public static async Task<int> PruneUsersAsync(IGuild guild, BaseDiscordClient client,
int days = 30, bool simulate = false)
{
var args = new GuildPruneParams(days);

2
src/Discord.Net.Rest/Entities/Guilds/RestBan.cs
View File

@@ -14,7 +14,7 @@ namespace Discord.Rest
User = user;
Reason = reason;
}
internal static RestBan Create(DiscordClient client, Model model)
internal static RestBan Create(BaseDiscordClient client, Model model)
{
return new RestBan(RestUser.Create(client, model.User), model.Reason);
}

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

@@ -39,11 +39,11 @@ namespace Discord.Rest
public IReadOnlyCollection<Emoji> Emojis => _emojis;
public IReadOnlyCollection<string> Features => _features;
internal RestGuild(DiscordClient client, ulong id)
internal RestGuild(BaseDiscordClient client, ulong id)
: base(client, id)
{
}
internal static RestGuild Create(DiscordClient discord, Model model)
internal static RestGuild Create(BaseDiscordClient discord, Model model)
{
var entity = new RestGuild(discord, model.Id);
entity.Update(model);

4
src/Discord.Net.Rest/Entities/Guilds/RestGuildIntegration.cs
View File

@@ -25,11 +25,11 @@ namespace Discord.Rest
public DateTimeOffset SyncedAt => DateTimeUtils.FromTicks(_syncedAtTicks);
internal RestGuildIntegration(DiscordClient discord, ulong id)
internal RestGuildIntegration(BaseDiscordClient discord, ulong id)
: base(discord, id)
{
}
internal static RestGuildIntegration Create(DiscordClient discord, Model model)
internal static RestGuildIntegration Create(BaseDiscordClient discord, Model model)
{
var entity = new RestGuildIntegration(discord, model.Id);
entity.Update(model);

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

@@ -15,11 +15,11 @@ namespace Discord.Rest
public string IconUrl => API.CDN.GetGuildIconUrl(Id, _iconId);
internal RestUserGuild(DiscordClient discord, ulong id)
internal RestUserGuild(BaseDiscordClient discord, ulong id)
: base(discord, id)
{
}
internal static RestUserGuild Create(DiscordClient discord, Model model)
internal static RestUserGuild Create(BaseDiscordClient discord, Model model)
{
var entity = new RestUserGuild(discord, model.Id);
entity.Update(model);

4
src/Discord.Net.Rest/Entities/Guilds/RestVoiceRegion.cs
View File

@@ -13,11 +13,11 @@ namespace Discord
public string SampleHostname { get; private set; }
public int SamplePort { get; private set; }
internal RestVoiceRegion(DiscordClient client, string id)
internal RestVoiceRegion(BaseDiscordClient client, string id)
: base(client, id)
{
}
internal static RestVoiceRegion Create(DiscordClient client, Model model)
internal static RestVoiceRegion Create(BaseDiscordClient client, Model model)
{
var entity = new RestVoiceRegion(client, model.Id);
entity.Update(model);

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

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

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

@@ -16,11 +16,11 @@ namespace Discord.Rest
public string Code => Id;
public string Url => $"{DiscordConfig.InviteUrl}/{Code}";
internal RestInvite(DiscordClient discord, string id)
internal RestInvite(BaseDiscordClient discord, string id)
: base(discord, id)
{
}
internal static RestInvite Create(DiscordClient discord, Model model)
internal static RestInvite Create(BaseDiscordClient discord, Model model)
{
var entity = new RestInvite(discord, model.Code);
entity.Update(model);

4
src/Discord.Net.Rest/Entities/Invites/RestInviteMetadata.cs
View File

@@ -18,11 +18,11 @@ namespace Discord.Rest
public DateTimeOffset CreatedAt => DateTimeUtils.FromTicks(_createdAtTicks);
internal RestInviteMetadata(DiscordClient discord, string id)
internal RestInviteMetadata(BaseDiscordClient discord, string id)
: base(discord, id)
{
}
internal static RestInviteMetadata Create(DiscordClient discord, Model model)
internal static RestInviteMetadata Create(BaseDiscordClient discord, Model model)
{
var entity = new RestInviteMetadata(discord, model.Code);
entity.Update(model);

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

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

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

@@ -29,12 +29,12 @@ namespace Discord.Rest
public DateTimeOffset Timestamp => DateTimeUtils.FromTicks(_timestampTicks);
internal RestMessage(DiscordClient discord, ulong id, ulong channelId)
internal RestMessage(BaseDiscordClient discord, ulong id, ulong channelId)
: base(discord, id)
{
ChannelId = channelId;
}
internal static RestMessage Create(DiscordClient discord, Model model)
internal static RestMessage Create(BaseDiscordClient discord, Model model)
{
if (model.Type == MessageType.Default)
return RestUserMessage.Create(discord, model);

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

@@ -8,11 +8,11 @@ namespace Discord.Rest
{
public MessageType Type { get; private set; }
internal RestSystemMessage(DiscordClient discord, ulong id, ulong channelId)
internal RestSystemMessage(BaseDiscordClient discord, ulong id, ulong channelId)
: base(discord, id, channelId)
{
}
internal new static RestSystemMessage Create(DiscordClient discord, Model model)
internal new static RestSystemMessage Create(BaseDiscordClient discord, Model model)
{
var entity = new RestSystemMessage(discord, model.Id, model.ChannelId);
entity.Update(model);

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

@@ -30,11 +30,11 @@ namespace Discord.Rest
public override IReadOnlyCollection<IRole> MentionedRoles => _mentionedRoles;
public override IReadOnlyCollection<IUser> MentionedUsers => _mentionedUsers;
internal RestUserMessage(DiscordClient discord, ulong id, ulong channelId)
internal RestUserMessage(BaseDiscordClient discord, ulong id, ulong channelId)
: base(discord, id, channelId)
{
}
internal new static RestUserMessage Create(DiscordClient discord, Model model)
internal new static RestUserMessage Create(BaseDiscordClient discord, Model model)
{
var entity = new RestUserMessage(discord, model.Id, model.ChannelId);
entity.Update(model);

4
src/Discord.Net.Rest/Entities/RestApplication.cs
View File

@@ -17,11 +17,11 @@ namespace Discord.Rest
public string IconUrl => API.CDN.GetApplicationIconUrl(Id, _iconId);
internal RestApplication(DiscordClient discord, ulong id)
internal RestApplication(BaseDiscordClient discord, ulong id)
: base(discord, id)
{
}
internal static RestApplication Create(DiscordClient discord, Model model)
internal static RestApplication Create(BaseDiscordClient discord, Model model)
{
var entity = new RestApplication(discord, model.Id);
entity.Update(model);

4
src/Discord.Net.Rest/Entities/RestEntity.cs
View File

@@ -5,10 +5,10 @@ namespace Discord.Rest
public abstract class RestEntity<T> : IEntity<T>
where T : IEquatable<T>
{
public DiscordClient Discord { get; }
public BaseDiscordClient Discord { get; }
public T Id { get; }
internal RestEntity(DiscordClient discord, T id)
internal RestEntity(BaseDiscordClient discord, T id)
{
Discord = discord;
Id = id;

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

@@ -21,11 +21,11 @@ namespace Discord.Rest
public bool IsEveryone => Id == Guild.Id;
public string Mention => MentionUtils.MentionRole(Id);
internal RestRole(DiscordClient discord, ulong id)
internal RestRole(BaseDiscordClient discord, ulong id)
: base(discord, id)
{
}
internal static RestRole Create(DiscordClient discord, Model model)
internal static RestRole Create(BaseDiscordClient discord, Model model)
{
var entity = new RestRole(discord, model.Id);
entity.Update(model);

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

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

4
src/Discord.Net.Rest/Entities/Users/RestGroupUser.cs
View File

@@ -6,11 +6,11 @@ namespace Discord.Rest
[DebuggerDisplay(@"{DebuggerDisplay,nq}")]
public class RestGroupUser : RestUser, IGroupUser
{
internal RestGroupUser(DiscordClient discord, ulong id)
internal RestGroupUser(BaseDiscordClient discord, ulong id)
: base(discord, id)
{
}
internal new static RestGroupUser Create(DiscordClient discord, Model model)
internal new static RestGroupUser Create(BaseDiscordClient discord, Model model)
{
var entity = new RestGroupUser(discord, model.Id);
entity.Update(model);

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

@@ -21,11 +21,11 @@ namespace Discord.Rest
public DateTimeOffset? JoinedAt => DateTimeUtils.FromTicks(_joinedAtTicks);
internal RestGuildUser(DiscordClient discord, ulong id)
internal RestGuildUser(BaseDiscordClient discord, ulong id)
: base(discord, id)
{
}
internal static RestGuildUser Create(DiscordClient discord, Model model)
internal static RestGuildUser Create(BaseDiscordClient discord, Model model)
{
var entity = new RestGuildUser(discord, model.User.Id);
entity.Update(model);

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

@@ -13,11 +13,11 @@ namespace Discord.Rest
public bool IsVerified { get; private set; }
public bool IsMfaEnabled { get; private set; }
internal RestSelfUser(DiscordClient discord, ulong id)
internal RestSelfUser(BaseDiscordClient discord, ulong id)
: base(discord, id)
{
}
internal new static RestSelfUser Create(DiscordClient discord, Model model)
internal new static RestSelfUser Create(BaseDiscordClient discord, Model model)
{
var entity = new RestSelfUser(discord, model.Id);
entity.Update(model);

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

@@ -18,11 +18,11 @@ namespace Discord.Rest
public virtual Game? Game => null;
public virtual UserStatus Status => UserStatus.Unknown;
internal RestUser(DiscordClient discord, ulong id)
internal RestUser(BaseDiscordClient discord, ulong id)
: base(discord, id)
{
}
internal static RestUser Create(DiscordClient discord, Model model)
internal static RestUser Create(BaseDiscordClient discord, Model model)
{
var entity = new RestUser(discord, model.Id);
entity.Update(model);

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

@@ -8,22 +8,22 @@ namespace Discord.Rest
{
internal static class UserHelper
{
public static async Task<Model> GetAsync(IUser user, DiscordClient client)
public static async Task<Model> GetAsync(IUser user, BaseDiscordClient client)
{
return await client.ApiClient.GetUserAsync(user.Id);
}
public static async Task<Model> GetAsync(ISelfUser user, DiscordClient client)
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, DiscordClient client)
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, DiscordClient client, Action<ModifyCurrentUserParams> func)
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.");
@@ -32,19 +32,19 @@ namespace Discord.Rest
func(args);
await client.ApiClient.ModifySelfAsync(args);
}
public static async Task ModifyAsync(IGuildUser user, DiscordClient client, Action<ModifyGuildMemberParams> func)
public static async Task ModifyAsync(IGuildUser user, BaseDiscordClient client, Action<ModifyGuildMemberParams> func)
{
var args = new ModifyGuildMemberParams();
func(args);
await client.ApiClient.ModifyGuildMemberAsync(user.GuildId, user.Id, args);
}
public static async Task KickAsync(IGuildUser user, DiscordClient client)
public static async Task KickAsync(IGuildUser user, BaseDiscordClient client)
{
await client.ApiClient.RemoveGuildMemberAsync(user.GuildId, user.Id);
}
public static async Task<IDMChannel> CreateDMChannelAsync(IUser user, DiscordClient client)
public static async Task<IDMChannel> CreateDMChannelAsync(IUser user, BaseDiscordClient client)
{
var args = new CreateDMChannelParams(user.Id);
return RestDMChannel.Create(client, await client.ApiClient.CreateDMChannelAsync(args));