public async Task <ulong?> SendAsync(IPendingMessage message)
{
var webHook = await GetWebHookClientAsync(message.Channel);
var messageId = await webHook.SendMessageAsync(message.Content, username : message.BridgeAuthor.Username,
avatarUrl : message.BridgeAuthor.Avatar);
return(messageId);
}
public async Task DeleteAsync(IPendingMessage message)
{
if (message.MessageId == null)
{
throw new ArgumentNullException(nameof(message.MessageId));
}
var webHook = await GetWebHookClientAsync(message.Channel);
await webHook.DeleteMessageAsync(message.MessageId.Value);
}
public async Task UpdateAsync(IPendingMessage message)
{
if (message.MessageId == null)
{
throw new ArgumentNullException(nameof(message.MessageId));
}
var webHook = await GetWebHookClientAsync(message.Channel);
await webHook.ModifyMessageAsync(message.MessageId.Value, props => props.Content = message.Content);
}
/// <summary>
/// Try to fire actions for a message
/// </summary>
public void TryHandle(IPendingMessage<object> pendingMessage)
{
var messageObject = pendingMessage.Message;
// ReSharper disable InvokeAsExtensionMethod
var type = TypeExtensions.DirectlyImplementedInterfaces(messageObject.GetType()).Single();
// ReSharper restore InvokeAsExtensionMethod
var matchingHandlers = GetMatchingHandlers(type).ToList();
if (!matchingHandlers.Any())
{
pendingMessage.Finish();
Log.Warning("Ignoring message of type " + type + " because there are no handlers");
return;
}
HandleMessageWithInstancesOfHandlers(pendingMessage, matchingHandlers, messageObject);
}
void HandleMessageWithInstancesOfHandlers(IPendingMessage<object> pendingMessage,
IEnumerable<Type> matchingHandlers, object messageObject)
{
foreach (var handler in matchingHandlers)
{
var hooks = ObjectFactory.GetAllInstances<IEventHook>();
try
{
var instance = ObjectFactory.GetInstance(handler);
handler.GetMethod("Handle", new[] { messageObject.GetType() }).Invoke(instance, new[] { messageObject });
FireHandledOkHooks((IMessage)messageObject, hooks);
_sleeper.Reset();
}
catch (Exception ex)
{
if (ex is TargetInvocationException)
{
ex = ex.InnerException;
}
try
{
if (ShouldRetry(ex.GetType(), handler))
{
RetryFailedMessage(pendingMessage);
}
else pendingMessage.Finish();
FireHandlerFailedHooks((IMessage)messageObject, hooks, ex, handler);
}
catch (Exception exinner)
{
Log.Warning("Firing handler failed hooks didn't succeed: " + exinner.Message);
}
return;
}
}
pendingMessage.Finish();
}
/// <summary>
/// Not currently implemented. Will throw an exception.
/// </summary>
/// <remarks>This might be useful at some point to inject test messages?</remarks>
public void Enqueue(IPendingMessage<object> work)
{
throw new InvalidOperationException("This queue self populates and doesn't currently support direct injection.");
}
void RetryFailedMessage(IPendingMessage<object> pendingMessage)
{
pendingMessage.Cancel();
_sleeper.SleepMore();
}
