public Task<ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
switch (message.Type)
{
case EventType.ChannelArchive:
ChannelArchive(message as ChannelArchive); break;
case EventType.ChannelCreated:
ChannelCreated(message as ChannelCreated); break;
case EventType.ChannelDeleted:
ChannelDeleted(message as ChannelDeleted); break;
case EventType.ChannelJoined:
ChannelJoined(message as ChannelJoined); break;
case EventType.ChannelLeft:
ChannelLeft(message as ChannelLeft); break;
case EventType.ChannelMarked:
ChannelMarked(message as ChannelMarked); break;
case EventType.ChannelRename:
ChannelRename(message as ChannelRename); break;
case EventType.ChannelUnarchive:
ChannelUnarchive(message as ChannelUnarchive); break;
}
return Task.FromResult(ProcessingChainResult.Continue);
}
public bool CanHandle(EventMessageBase message)
{
return message.IsOneOf(EventType.GroupArchive,
EventType.GroupJoined,
EventType.GroupLeft,
EventType.GroupMarked,
EventType.GroupRename,
EventType.GroupUnarchive);
}
public bool CanHandle(EventMessageBase message)
{
return message.IsOneOf(EventType.PrefChange,
EventType.UserChange,
EventType.TeamJoin,
EventType.TeamPrefChange,
EventType.TeamRename,
EventType.TeamDomainChange,
EventType.EmailDomainChanged);
}
public bool CanHandle(EventMessageBase message)
{
return message.IsOneOf(EventType.ChannelArchive,
EventType.ChannelCreated,
EventType.ChannelDeleted,
EventType.ChannelJoined,
EventType.ChannelLeft,
EventType.ChannelMarked,
EventType.ChannelRename,
EventType.ChannelUnarchive);
}
public Task<ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
var presenceMessage = message.CastTo<PresenceChange>();
var user = base.BotState.Users.FirstOrDefault(u => u.Id == presenceMessage.User);
if (user != null)
user.Presence = presenceMessage.Presence;
return Task.FromResult(ProcessingChainResult.Continue);
}
public Task<ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
var messageBase = message.CastTo<MessageBase>();
var response = "pong";
if (!message.IsIm(base.BotState))
response = $"<@{messageBase.User}>: {response}";
base.BotServices.SendMessage(messageBase.Channel, response);
return Task.FromResult(ProcessingChainResult.Continue);
}
public Task<ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
var botModel = (message as BotAdded)?.Bot ?? (message as BotChanged)?.Bot;
if (botModel != null)
{
var existingBotIndex = base.BotState.Bots.FindIndex(b => b.Id == botModel.Id);
if (existingBotIndex >= 0)
base.BotState.Bots.RemoveAt(existingBotIndex);
base.BotState.Bots.Add(botModel);
}
return Task.FromResult(ProcessingChainResult.Continue);
}
public Task<ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
var rtmStartResponse = message.CastTo<RtmStartResponse>();
base.BotState.Bots = rtmStartResponse.Bots;
base.BotState.CacheVersion = rtmStartResponse.CacheVersion;
base.BotState.Channels = rtmStartResponse.Channels;
base.BotState.Groups = rtmStartResponse.Groups;
base.BotState.Ims = rtmStartResponse.Ims;
base.BotState.LatestEventTs = rtmStartResponse.LatestEventTs;
base.BotState.Self = rtmStartResponse.Self;
base.BotState.Team = rtmStartResponse.Team;
base.BotState.Users = rtmStartResponse.Users;
return Task.FromResult(ProcessingChainResult.Continue);
}
public Task<ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
switch (message.Type)
{
case EventType.GroupArchive:
GroupArchive(message as GroupArchive); break;
case EventType.GroupJoined:
GroupJoined(message as GroupJoined); break;
case EventType.GroupLeft:
GroupLeft(message as GroupLeft); break;
case EventType.GroupMarked:
GroupMarked(message as GroupMarked); break;
case EventType.GroupRename:
GroupRename(message as GroupRename); break;
case EventType.GroupUnarchive:
GroupUnarchive(message as GroupUnarchive); break;
}
return Task.FromResult(ProcessingChainResult.Continue);
}
public Task<ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
switch (message.Type)
{
case EventType.PrefChange:
PrefChange(message as PrefChange); break;
case EventType.UserChange:
UserChange(message as UserChange); break;
case EventType.TeamJoin:
TeamJoin(message as TeamJoin); break;
case EventType.TeamPrefChange:
TeamPrefChange(message as TeamPrefChange); break;
case EventType.TeamDomainChange:
TeamDomainChange(message as TeamDomainChange); break;
case EventType.TeamRename:
TeamRename(message as TeamRename); break;
case EventType.EmailDomainChanged:
EmailDomainChanged(message as EmailDomainChanged); break;
}
return Task.FromResult(ProcessingChainResult.Continue);
}
public bool CanHandle(EventMessageBase message)
{
ResetTimer();
return message.Type == EventType.Pong;
}
public bool CanHandle(EventMessageBase message)
{
throw new NotImplementedException();
}
public bool CanHandle(EventMessageBase message)
{
return message.IsToMe(base.BotState)
&& message.MatchesText(@"\bping\b");
}
public bool CanHandle(EventMessageBase message)
{
// TODO: EventType.ManualPresenceChange ?
return message.IsOneOf(EventType.PresenceChange);
}
private bool SafelyHandles(IMessageHandler handler, EventMessageBase message, string originalMessage)
{
var handles = false;
try
{
handles = handler.CanHandle(message);
}
catch (Exception ex)
{
this.Logger.Error($"{handler.GetType().Name} threw exception in CanHandle() with message: {originalMessage}", ex);
}
return handles;
}
private async void OfferMessageToHandlersAsync(EventMessageBase message, string originalMessage)
{
if (message == null)
throw new ArgumentNullException(nameof(message));
if (this.MessageHandlers == null)
return;
var interestedHandlers = this.MessageHandlers.Where(h => SafelyHandles(h, message, originalMessage));
foreach (var handler in interestedHandlers)
{
try
{
this.Logger.Debug($"{handler.GetType().Name} handling: {message.Type}");
var result = await handler.HandleMessageAsync(message);
if (result == ProcessingChainResult.Stop)
break;
}
catch (Exception ex)
{
this.Logger.Error($"{handler.GetType().Name} threw exception when handling message: {originalMessage}", ex);
}
}
}
public Task<ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
throw new NotImplementedException();
}
private async void RunHandler(EventMessageBase message, Mock<IBotState> mockState)
{
var handler = new ChannelHandler();
handler.BotState = mockState.Object;
var result = await handler.HandleMessageAsync(message);
mockState.Verify();
}
public Task<ProcessingChainResult> HandleMessageAsync(EventMessageBase message)
{
// do something? check latency maybe?
return Task.FromResult(ProcessingChainResult.Continue);
}
public bool CanHandle(EventMessageBase message)
{
return message.IsOneOf(EventType.RtmStart);
}
public bool CanHandle(EventMessageBase message)
{
return message.IsOneOf(EventType.BotAdded, EventType.BotChanged);
}
