void _client_MessageReceived(Message message, string room)
{
_robo.Bus.Send(new RawChatMessage(
message.User.Name,
room,
message.When,
message.Id,
message.Content,
String.Equals(message.User.Name, _userName, StringComparison.OrdinalIgnoreCase),
new[] { _userName }));
}
public Task ProcessMessageAsync(string room, Message message)
{
var task = new Task<ChatMessageViewModel>(() =>
{
ChatMessageViewModel msgVm = CreateMessageViewModel(message);
return msgVm;
});
task.ContinueWith(completedTask => OnMessageProcessed(completedTask.Result, room),
TaskContinuationOptions.OnlyOnRanToCompletion);
task.ContinueWith(ProcessTaskExceptions, TaskContinuationOptions.OnlyOnFaulted);
task.Start();
return task;
}
private void ProcessMessage(JabbR.Client.Models.Message message, string room)
{
#if DEBUG
Console.WriteLine("{0} {1} {2}", room, message.Content, message.User.Name);
if (message.User.Name != Name)
{
Send("Received " + message.Content + " from " + message.User.Name + " in " + room, room);
}
#endif
Task.Factory.StartNew(() =>
{
string content = message.Content;
string name = message.User.Name;
// Ignore replies from self
if (name.Equals(Name, StringComparison.OrdinalIgnoreCase))
{
return;
}
if (MessageReceived != null)
{
MessageReceived(message, room);
}
ChatMessage chatMessage = new ChatMessage(message.Content, message.User.Name, room);
bool handled = false;
handled = HandleMessageWithSprockets(chatMessage, handled);
if (!handled)
{
ProcessUnhandledMessage(chatMessage);
}
})
.ContinueWith(task =>
{
// Just write to debug output if it failed
if (task.IsFaulted)
{
Debug.WriteLine("JABBOT: Failed to process messages. {0}", task.Exception.GetBaseException());
Send("JABBOT: Failed to process messages:" + task.Exception.GetBaseException().ToString(), room);
new LogEvent(task.Exception.GetBaseException().ToString()).Raise();
}
});
}
private ChatMessageViewModel CreateMessageViewModel(Message message)
{
string content = ProcessEmoji(message.Content);
var msgVm = _serviceLocator.GetViewModel<ChatMessageViewModel>();
UserViewModel userVm = _userService.GetUserViewModel(message.User);
msgVm.IsNotifying = false;
msgVm.RawContent = message.Content;
msgVm.MessageDateTime = message.When.LocalDateTime;
msgVm.MessageId = message.Id;
msgVm.RichContent = ConvertToXaml(content);
msgVm.User = userVm;
msgVm.IsNotifying = true;
return msgVm;
}
public ChatMessageViewModel ProcessMessage(Message message)
{
return CreateMessageViewModel(message);
}
private void OnMessageReceived(Message message, string room)
{
ProcessMessageAsync(room, message);
}
public void ProcessMessage(Message message, string room)
{
// Run this on another thread since the signalr client doesn't like it
// when we spend a long time processing messages synchronously
Task.Factory.StartNew(() =>
{
string content = message.Content;
string name = message.User.Name;
// Ignore replies from self
if (name.Equals(Name, StringComparison.OrdinalIgnoreCase))
{
return;
}
// We're going to process commands for the bot here
var chatMessage = new ChatMessage(WebUtility.HtmlDecode(content), name, room);
if (MessageReceived != null)
{
MessageReceived(chatMessage);
}
bool handled = false;
// Loop over the registered sprockets
foreach (var handler in _sprockets)
{
// Stop at the first one that handled the message
if (handler.Handle(chatMessage, this))
{
handled = true;
break;
}
}
if (!handled)
{
// Loop over the unhandled message sprockets
foreach (var handler in _unhandledMessageSprockets)
{
// Stop at the first one that handled the message
if (handler.Handle(chatMessage, this))
{
break;
}
}
}
})
.ContinueWith(task =>
{
// Just write to debug output if it failed
if (task.IsFaulted)
{
Debug.WriteLine("JABBOT: Failed to process messages. {0}", task.Exception.GetBaseException());
}
});
}
void OnMessageReceived(Message message, string room)
{
Trace.Call(message, room);
var chat = GetChat(room, ChatType.Group) ?? ProtocolChat;
AddMessage(chat, message);
}
void AddMessage(ChatModel chat, Message msg)
{
if (chat == null) {
throw new ArgumentNullException("chat");
}
if (msg == null) {
throw new ArgumentNullException("msg");
}
string content = msg.Content;
string name = msg.User.Name;
var builder = CreateMessageBuilder<JabbrMessageBuilder>();
if (msg.When != default(DateTimeOffset)) {
builder.TimeStamp = msg.When.UtcDateTime;
}
var sender = name == Username ? Me : CreatePerson(name);
builder.AppendSenderPrefix(sender);
builder.AppendMessage(content);
if (sender != Me) {
builder.MarkHighlights();
}
var message = builder.ToMessage();
Session.AddMessageToChat(chat, message);
if (sender == Me) {
// server echos our sent messages for us
OnMessageSent(
new MessageEventArgs(chat, message, null, chat.ID)
);
} else {
OnMessageReceived(
new MessageEventArgs(chat, message, name, chat.ID)
);
}
}
void AddMessage(ChatModel chat, Message msg)
{
if (chat == null) {
throw new ArgumentNullException("chat");
}
if (msg == null) {
throw new ArgumentNullException("msg");
}
string content = msg.Content;
string name = msg.User.Name;
var builder = CreateMessageBuilder<JabbrMessageBuilder>();
if (msg.When != default(DateTimeOffset)) {
builder.TimeStamp = msg.When.UtcDateTime;
}
var sender = name == Username ? Me : CreatePerson(name);
builder.AppendSenderPrefix(sender);
builder.AppendMessage(content);
if (sender != Me) {
builder.MarkHighlights();
}
Session.AddMessageToChat(chat, builder.ToMessage());
}
public JabbrMessageReceivedMessage(object sender, JabbrConnection jabbr, JabbR.Client.Models.Message message, string roomName)
: base(sender, jabbr)
{
this.Message = message;
this.RoomName = roomName;
}
private void ProcessMessage(JabbR.Client.Models.Message message, string room)
{
// Ignore replies from self
if (message.User.Name.Equals(Name, StringComparison.OrdinalIgnoreCase))
{
return;
}
if (message.Content.Equals("enabledebug"))
{
_debugMode = true;
}
if (message.Content.Equals("disabledebug"))
{
_debugMode = false;
}
WriteDebugInfo(string.Format("{0} {1} {2}", room, message.Content, message.User.Name));
if (message.User.Name != Name)
{
WriteDebugInfo("Received " + message.Content + " from " + message.User.Name + " in " + room);
}
Task.Factory.StartNew(() =>
{
WriteDebugInfo("Message Processing Task Started");
string content = message.Content;
string name = message.User.Name;
WriteDebugInfo("Content: " + content + " from " + name);
if (MessageReceived != null)
{
MessageReceived(message, room);
}
ChatMessage chatMessage = new ChatMessage(message.Content, message.User.Name, room);
bool handled = false;
WriteDebugInfo("Handling Message with Sprockets");
handled = HandleMessageWithSprockets(chatMessage, handled);
WriteDebugInfo("Handling complete: " + handled);
if (!handled)
{
WriteDebugInfo("Unhandled Message Handling");
ProcessUnhandledMessage(chatMessage);
WriteDebugInfo("Unhandled Complete");
}
})
.ContinueWith(task =>
{
// Just write to debug output if it failed
if (task.IsFaulted)
{
Debug.WriteLine("JABBOT: Failed to process messages. {0}", task.Exception.GetBaseException());
Send("JABBOT: Failed to process messages:" + task.Exception.GetBaseException().ToString(), room);
WriteDebugInfo(task.Exception.GetBaseException().ToString());
}
});
}
void HandleMessageReceived(JabbR.Client.Models.Message message, string roomName)
{
Log("MessageReceived> " + message.User.Name + ": " + message.Content + " -> " + roomName);
_messenger.Publish(new JabbrMessageReceivedMessage(this, this, message, roomName));
}
private void ClientOnMessageReceived(Message message, string room)
{
// we never want to respond to ourself...
if (string.Equals(message.User.Name, Name, StringComparison.OrdinalIgnoreCase))
{
return;
}
Console.WriteLine("message received");
var match = Regex.Match(message.Content, string.Format(@"^(?<name>@?{0}\b)\s+(?<message>\b.*\b)", Name), DefaultRegexOptions);
ISession session = new Session(message, Name);
Dictionary<string, MessageHandler> handlers;
string messageBody;
if (match.Success)
{
handlers = _responderHandlers;
messageBody = match.ValueFor("message");
}
else
{
handlers = _listenerHandlers;
messageBody = message.Content;
}
foreach (var handler in handlers)
{
var result = HandleCommand(session, messageBody, room, handler.Key, handler.Value);
if (result)
{
break;
}
}
}
public MessageViewModel(JabbR.Client.Models.Message message) : base()
{
Message = message;
}
public Session(Message message, string botName)
{
Message = message;
BotName = botName;
}
