public bool IsEventSupported(DiscordEventType eventType)
{
if (eventType != DiscordEventType.MessageRecieved || eventType != DiscordEventType.PrivateMessageRecieved)
{
return(true);
}
return(false);
}
public bool RegisterEvent <T>(IDiscordRule rule, DiscordEventType eventType, Action <Dictionary <string, object>, T> eventMethod)
{
if (rule.IsEventSupported(eventType))
{
DiscordEvent discordEvent = new DiscordEvent();
discordEvent.Rule = rule;
discordEvent.Type = eventType;
discordEvent.Event = eventMethod;
AddDiscordEvent(discordEvent);
return(true);
}
return(false);
}
public bool RegisterAdminEvent <T>(DiscordAdmin type, IDiscordRule rule, DiscordEventType eventType, Action <Dictionary <string, object>, T> eventMethod)
{
if ((type == DiscordAdmin.DM && m_guild == null) || type == DiscordAdmin.Global)
{
if (rule.IsEventSupported(eventType))
{
DiscordEvent discordEvent = new DiscordEvent();
discordEvent.Rule = rule;
discordEvent.Type = eventType;
discordEvent.Event = eventMethod;
AddDiscordEvent(discordEvent);
return(true);
}
}
return(false);
}
/// <summary>
/// Wraps the actual event handler callbacks with a task.run
/// </summary>
/// <param name="eventType">The event being handled.</param>
/// <param name="args">The event arguments.</param>
/// <returns></returns>
private Task HandleEvent(DiscordEventType eventType, params object[] args)
{
var discordEvent = new DiscordEvent
{
EventType = eventType,
Args = args,
};
if (eventType == DiscordEventType.UserVoiceStateUpdated)
{
this.voiceEventQueue.Add(discordEvent);
}
else
{
this.eventQueue.Add(discordEvent);
}
return(Task.CompletedTask);
}
private Task InvokeEvent <T>(DiscordEventType eventType, object e)
{
T discordEventArgs = default(T);
if (e.TryCast <T>(out discordEventArgs))
{
if (m_discordEvents.ContainsKey(eventType))
{
foreach (var eventObject in m_discordEvents[eventType])
{
if (eventObject.Type == eventType &&
eventObject.Rule.IsEventSupported(eventObject.Type) &&
eventObject.Rule.Validate(e))
{
Dictionary <string, object> parameters = eventObject.Rule.BuildParameters(e);
Logging.LogInfo(LogType.Bot, $"Running guild {m_guild?.Name} event {eventObject.Rule} with arg {e}");
Task invokedEvent = new Task(sender =>
{
Thread.CurrentThread.Name = $"Running guild {m_guild?.Name} event {eventObject.Rule} with arg {e}";
try
{
((Action <Dictionary <string, object>, T>)eventObject.Event)?.Invoke((Dictionary <string, object>)sender, discordEventArgs);
}
catch (Exception ex)
{
Logging.LogException(LogType.Script, ex, "Failed to run script command");
}
}, parameters);
invokedEvent.Start();
return(Task.CompletedTask);
}
}
}
}
return(Task.CompletedTask);
}
private void AddDiscordEvent(DiscordEvent eventAction)
{
DiscordEventType type = eventAction.Type;
if (m_discordEvents.ContainsKey(type))
{
if (m_discordEvents[type] == null)
{
m_discordEvents[type] = new List <DiscordEvent>();
m_discordEvents[type].Add(eventAction);
}
else
{
m_discordEvents[type].Add(eventAction);
}
}
else
{
m_discordEvents.Add(type, new List <DiscordEvent>());
m_discordEvents[type].Add(eventAction);
}
}
public AsyncEventListenerAttribute(DiscordEventType targetType)
{
this.Target = targetType;
}
public bool IsEventSupported(DiscordEventType eventType)
{
return(eventType == DiscordEventType.PrivateMessageRecieved);
}
public LocalizedEmbedBuilder WithLocalizedTitle(DiscordEventType type, string title, object?desc, params object?[]?titleArgs)
{
this.WithLocalizedTitle(type, title, titleArgs);
if (desc is { })
public LocalizedEmbedBuilder WithLocalizedTitle(DiscordEventType type, string title, params object?[]?args)
{
this.WithColor(type.ToDiscordColor());
return(this.WithLocalizedTitle(title, args));
}
public AsyncEventListenerAttribute(DiscordEventType eventType)
{
this.EventType = eventType;
}
/// <summary>
/// Wraps the actual event handler callbacks with a task.run
/// </summary>
/// <param name="eventType">The event being handled.</param>
/// <param name="args">The event arguments.</param>
/// <returns></returns>
private Task HandleEvent(DiscordEventType eventType, params object[] args)
{
Task.Run(async() =>
{
try
{
switch (eventType)
{
case DiscordEventType.Disconnected:
await this.HandleDisconnected(args[0] as Exception);
break;
case DiscordEventType.JoinedGuild:
await this.HandleJoinedGuildAsync((SocketGuild)args[0]);
break;
case DiscordEventType.LeftGuild:
await this.HandleLeftGuildAsync((SocketGuild)args[0]);
break;
case DiscordEventType.UserJoined:
await this.HandleUserJoinedAsync((SocketGuildUser)args[0]);
break;
case DiscordEventType.UserLeft:
await this.HandleUserLeftAsync((SocketGuildUser)args[0]);
break;
case DiscordEventType.UserVoiceStateUpdated:
await this.HandleUserVoiceStateUpdatedAsync((SocketUser)args[0], (SocketVoiceState)args[1], (SocketVoiceState)args[2]);
break;
case DiscordEventType.GuildMemberUpdated:
await this.HandleGuildMemberUpdated(args[0] as SocketGuildUser, args[1] as SocketGuildUser);
break;
case DiscordEventType.UserBanned:
await this.HandleUserBanned(args[0] as SocketGuildUser, (SocketGuild)args[1]);
break;
case DiscordEventType.MessageReceived:
await this.HandleMessageReceivedAsync((SocketMessage)args[0]);
break;
case DiscordEventType.MessageUpdated:
await this.HandleMessageUpdated((Cacheable <IMessage, ulong>)args[0], (SocketMessage)args[1], (ISocketMessageChannel)args[2]);
break;
case DiscordEventType.MessageDeleted:
await this.HandleMessageDeleted((Cacheable <IMessage, ulong>)args[0], (ISocketMessageChannel)args[1]);
break;
case DiscordEventType.ReactionAdded:
await this.HandleReactionAdded((Cacheable <IUserMessage, ulong>)args[0], (ISocketMessageChannel)args[1], (SocketReaction)args[2]);
break;
default:
throw new ArgumentException("Unrecognized event type");
}
}
catch (Exception ex)
{
this.Logger.Log(LogType.Warn, $"Error in {eventType} handler: {ex}");
this.AppInsights?.TrackException(ex);
}
}).Forget();
return(Task.CompletedTask);
}
public static DiscordColor ToDiscordColor(this DiscordEventType type)
{
switch (type)
{
#region Channels
case DiscordEventType.ChannelCreated:
case DiscordEventType.ChannelDeleted:
case DiscordEventType.ChannelPinsUpdated:
case DiscordEventType.ChannelUpdated:
return(DiscordColor.Aquamarine);
#endregion
#region Errors and serious events
case DiscordEventType.ClientErrored:
case DiscordEventType.CommandErrored:
case DiscordEventType.GuildBanAdded:
case DiscordEventType.GuildDeleted:
case DiscordEventType.GuildUnavailable:
return(DiscordColor.Red);
#endregion
#region Availability
case DiscordEventType.DmChannelCreated:
case DiscordEventType.DmChannelDeleted:
case DiscordEventType.GuildAvailable:
case DiscordEventType.GuildCreated:
case DiscordEventType.GuildBanRemoved:
return(DiscordColor.Green);
#endregion
#region Successful execution
case DiscordEventType.CommandExecuted:
case DiscordEventType.GuildDownloadCompleted:
return(DiscordColor.SpringGreen);
#endregion
#region Emojis
case DiscordEventType.GuildEmojisUpdated:
return(DiscordColor.Yellow);
#endregion
#region Members and Users
case DiscordEventType.GuildMemberUpdated:
case DiscordEventType.PresenceUpdated:
case DiscordEventType.TypingStarted:
case DiscordEventType.UserSettingsUpdated:
case DiscordEventType.UserUpdated:
return(DiscordColor.DarkGreen);
case DiscordEventType.GuildMemberAdded:
case DiscordEventType.GuildMembersChunked:
return(DiscordColor.Turquoise);
case DiscordEventType.GuildMemberRemoved:
return(DiscordColor.DarkRed);
#endregion
#region Roles
case DiscordEventType.GuildRoleCreated:
case DiscordEventType.GuildRoleDeleted:
case DiscordEventType.GuildRoleUpdated:
return(DiscordColor.Orange);
#endregion
#region Guild
case DiscordEventType.GuildIntegrationsUpdated:
case DiscordEventType.GuildUpdated:
case DiscordEventType.InviteCreated:
case DiscordEventType.InviteDeleted:
case DiscordEventType.VoiceServerUpdated:
case DiscordEventType.VoiceStateUpdated:
case DiscordEventType.WebhooksUpdated:
return(DiscordColor.SapGreen);
#endregion
#region Messages
case DiscordEventType.MessageAcknowledged:
case DiscordEventType.MessageCreated:
case DiscordEventType.MessageDeleted:
case DiscordEventType.MessageReactionAdded:
case DiscordEventType.MessageReactionRemoved:
case DiscordEventType.MessageReactionRemovedEmoji:
case DiscordEventType.MessageReactionsCleared:
case DiscordEventType.MessageUpdated:
case DiscordEventType.MessagesBulkDeleted:
return(DiscordColor.CornflowerBlue);
#endregion
#region Application
case DiscordEventType.Heartbeated:
case DiscordEventType.Ready:
case DiscordEventType.Resumed:
case DiscordEventType.SocketClosed:
case DiscordEventType.SocketErrored:
case DiscordEventType.SocketOpened:
return(DiscordColor.White);
#endregion
#region Unknown and default
case DiscordEventType.UnknownEvent:
default:
return(DiscordColor.Black);
#endregion
}
}
