126 lines
6.6 KiB
C#
126 lines
6.6 KiB
C#
using Discord.Rest;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Immutable;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using Model = Discord.API.Rpc.Channel;
|
|
|
|
namespace Discord.Rpc
|
|
{
|
|
[DebuggerDisplay(@"{DebuggerDisplay,nq}")]
|
|
public class RpcDMChannel : RpcChannel, IRpcMessageChannel, IRpcPrivateChannel, IDMChannel
|
|
{
|
|
public IReadOnlyCollection<RpcMessage> CachedMessages { get; private set; }
|
|
|
|
internal RpcDMChannel(DiscordRpcClient discord, ulong id)
|
|
: base(discord, id)
|
|
{
|
|
}
|
|
internal static new RpcDMChannel Create(DiscordRpcClient discord, Model model)
|
|
{
|
|
var entity = new RpcDMChannel(discord, model.Id);
|
|
entity.Update(model);
|
|
return entity;
|
|
}
|
|
internal override void Update(Model model)
|
|
{
|
|
base.Update(model);
|
|
CachedMessages = model.Messages.Select(x => RpcMessage.Create(Discord, Id, x)).ToImmutableArray();
|
|
}
|
|
|
|
public Task CloseAsync(RequestOptions options = null)
|
|
=> ChannelHelper.DeleteAsync(this, Discord, options);
|
|
|
|
//TODO: Use RPC cache
|
|
public Task<RestMessage> GetMessageAsync(ulong id, RequestOptions options = null)
|
|
=> ChannelHelper.GetMessageAsync(this, Discord, id, options);
|
|
public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
|
|
=> ChannelHelper.GetMessagesAsync(this, Discord, null, Direction.Before, limit, options);
|
|
public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(ulong fromMessageId, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
|
|
=> ChannelHelper.GetMessagesAsync(this, Discord, fromMessageId, dir, limit, options);
|
|
public IAsyncEnumerable<IReadOnlyCollection<RestMessage>> GetMessagesAsync(IMessage fromMessage, Direction dir, int limit = DiscordConfig.MaxMessagesPerBatch, RequestOptions options = null)
|
|
=> ChannelHelper.GetMessagesAsync(this, Discord, fromMessage.Id, dir, limit, options);
|
|
public Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync(RequestOptions options = null)
|
|
=> ChannelHelper.GetPinnedMessagesAsync(this, Discord, options);
|
|
|
|
public Task<RestUserMessage> SendMessageAsync(string text, bool isTTS = false, Embed embed = null, RequestOptions options = null)
|
|
=> ChannelHelper.SendMessageAsync(this, Discord, text, isTTS, embed, options);
|
|
#if FILESYSTEM
|
|
public Task<RestUserMessage> SendFileAsync(string filePath, string text, bool isTTS = false, RequestOptions options = null)
|
|
=> ChannelHelper.SendFileAsync(this, Discord, filePath, text, isTTS, options);
|
|
#endif
|
|
public Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text, bool isTTS = false, RequestOptions options = null)
|
|
=> ChannelHelper.SendFileAsync(this, Discord, stream, filename, text, isTTS, options);
|
|
|
|
public Task TriggerTypingAsync(RequestOptions options = null)
|
|
=> ChannelHelper.TriggerTypingAsync(this, Discord, options);
|
|
public IDisposable EnterTypingState(RequestOptions options = null)
|
|
=> ChannelHelper.EnterTypingState(this, Discord, options);
|
|
|
|
public override string ToString() => Id.ToString();
|
|
private string DebuggerDisplay => $"({Id}, DM)";
|
|
|
|
//IDMChannel
|
|
IUser IDMChannel.Recipient { get { throw new NotSupportedException(); } }
|
|
|
|
//IPrivateChannel
|
|
IReadOnlyCollection<IUser> IPrivateChannel.Recipients { get { throw new NotSupportedException(); } }
|
|
|
|
//IMessageChannel
|
|
async Task<IMessage> IMessageChannel.GetMessageAsync(ulong id, CacheMode mode, RequestOptions options)
|
|
{
|
|
if (mode == CacheMode.AllowDownload)
|
|
return await GetMessageAsync(id, options).ConfigureAwait(false);
|
|
else
|
|
return null;
|
|
}
|
|
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(int limit, CacheMode mode, RequestOptions options)
|
|
{
|
|
if (mode == CacheMode.AllowDownload)
|
|
return GetMessagesAsync(limit, options);
|
|
else
|
|
return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>();
|
|
}
|
|
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(ulong fromMessageId, Direction dir, int limit, CacheMode mode, RequestOptions options)
|
|
{
|
|
if (mode == CacheMode.AllowDownload)
|
|
return GetMessagesAsync(fromMessageId, dir, limit, options);
|
|
else
|
|
return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>();
|
|
}
|
|
IAsyncEnumerable<IReadOnlyCollection<IMessage>> IMessageChannel.GetMessagesAsync(IMessage fromMessage, Direction dir, int limit, CacheMode mode, RequestOptions options)
|
|
{
|
|
if (mode == CacheMode.AllowDownload)
|
|
return GetMessagesAsync(fromMessage, dir, limit, options);
|
|
else
|
|
return AsyncEnumerable.Empty<IReadOnlyCollection<IMessage>>();
|
|
}
|
|
async Task<IReadOnlyCollection<IMessage>> IMessageChannel.GetPinnedMessagesAsync(RequestOptions options)
|
|
=> await GetPinnedMessagesAsync(options).ConfigureAwait(false);
|
|
|
|
#if FILESYSTEM
|
|
async Task<IUserMessage> IMessageChannel.SendFileAsync(string filePath, string text, bool isTTS, RequestOptions options)
|
|
=> await SendFileAsync(filePath, text, isTTS, options).ConfigureAwait(false);
|
|
#endif
|
|
async Task<IUserMessage> IMessageChannel.SendFileAsync(Stream stream, string filename, string text, bool isTTS, RequestOptions options)
|
|
=> await SendFileAsync(stream, filename, text, isTTS, options).ConfigureAwait(false);
|
|
async Task<IUserMessage> IMessageChannel.SendMessageAsync(string text, bool isTTS, Embed embed, RequestOptions options)
|
|
=> await SendMessageAsync(text, isTTS, embed, options).ConfigureAwait(false);
|
|
IDisposable IMessageChannel.EnterTypingState(RequestOptions options)
|
|
=> EnterTypingState(options);
|
|
|
|
//IChannel
|
|
string IChannel.Name { get { throw new NotSupportedException(); } }
|
|
|
|
Task<IUser> IChannel.GetUserAsync(ulong id, CacheMode mode, RequestOptions options)
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
IAsyncEnumerable<IReadOnlyCollection<IUser>> IChannel.GetUsersAsync(CacheMode mode, RequestOptions options)
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
}
|
|
}
|