public MessageViewModel(JabbR.Client.Models.Message message)
{
Id = message.Id;
Content = message.Content;
When = message.When;
User = message.User;
}
public static User Create(JabbR.Client.Models.User jabbrUser)
{
return new User
{
IsActive = jabbrUser.Active,
Hash = jabbrUser.Hash,
IsAdmin = jabbrUser.IsAdmin,
IsAfk = jabbrUser.IsAfk,
LastActivity = jabbrUser.LastActivity,
Name = jabbrUser.Name,
Note = jabbrUser.Note
};
}
internal static Room Create(JabbR.Client.Models.Room jabbrRoom)
{
var room = new Room
{
Name = jabbrRoom.Name,
IsPrivate = jabbrRoom.Private,
};
foreach (var jabbrUser in jabbrRoom.Users)
{
room.AddUser(User.Create(jabbrUser));
}
return room;
}
/*void HandleStateChanged (Microsoft.StateChange obj)
{
}*/
void HandleRoomCountChanged (JabbR.Client.Models.Room room, int count)
{
Log ("RoomCountChanged> " + room.Name + " -> " + count);
_messenger.Publish(new JabbrRoomCountChangedMessage(this, this, room, count));
}
void HandleTopicChanged (JabbR.Client.Models.Room room)
{
Log ("TopicChanged> " + room.Name);
_messenger.Publish(new JabbrTopicChangedMessage(this, this, room));
}
void HandleUserActivityChanged (JabbR.Client.Models.User user)
{
//Log ("UserActivityChanged> " + user.Name);
//_messenger.Publish(new JabbrUserActivityChangedMessage(this, this, user));
}
void HandleUserJoined (JabbR.Client.Models.User user, string roomName, bool isOwner)
{
Log ("UserJoined> " + user.Name + " -> " + roomName + " -> " + isOwner);
_messenger.Publish(new JabbrUserJoinedMessage(this, this, user, roomName, isOwner));
}
public UserViewModel(JabbR.Client.Models.User user)
: base()
{
User = user;
}
private void NewMessageAdded(JabbR.Client.Models.Message message, string room)
{
if (_model == null) return;
if (room.Equals(_model.Name, StringComparison.OrdinalIgnoreCase))
{
Dispatcher.BeginInvoke(() => _model.Messages.Add(new MessageViewModel(message)));
ScrollToLastMessage();
}
}
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));
}
void HandleFlagChanged (JabbR.Client.Models.User user, string flag)
{
Log ("FlagChanged> " + user.Name + " -> " + flag);
_messenger.Publish (new JabbrFlagChangedMessage (this, this, user, flag));
}
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());
}
});
}
public MessageViewModel(JabbR.Client.Models.Message message)
: base()
{
Message = message;
}
void HandleOwnerAdded (JabbR.Client.Models.User user, string roomName)
{
Log ("OwnerAdded> " + user.Name + " -> " + roomName);
_messenger.Publish(new JabbrOwnerAddedMessage(this, this, user, roomName));
}
void HandleUserTyping (JabbR.Client.Models.User user, string roomName)
{
_messenger.Publish (new JabbrUserTypingMessage (this, this, user, roomName));
}
void HandleNoteChanged (JabbR.Client.Models.User user, string note)
{
Log ("NoteChanged> " + user.Name + " -> " + note);
_messenger.Publish(new JabbrNoteChangedMessage(this, this, user, note));
}
void HandleUsernameChanged (string oldUsername, JabbR.Client.Models.User user, string roomName)
{
Log ("UsernameChanged> " + oldUsername + " -> " + user.Name + " -> " + roomName);
_messenger.Publish(new JabbrUsernameChangedMessage(this, this, oldUsername, user, roomName));
}
void HandleJoinedRoom (JabbR.Client.Models.Room room)
{
Log ("JoinedRoom> " + room.Name);
_messenger.Publish(new JabbrJoinedRoomMessage(this, this, room));
}
void HandleUserLeft (JabbR.Client.Models.User user, string roomName)
{
Log ("UserLeft> " + user.Name + " -> " + roomName);
_messenger.Publish(new JabbrUserLeftMessage(this, this, user, roomName));
}
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)
{
#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();
}
});
}
