private Task<LogOnInfo> Connect(JabbRClient client, JabbrCommand command)
{
if (string.IsNullOrWhiteSpace(command.UserId))
return client.Connect(command.Username, command.Password);
return client.Connect(command.UserId);
}
private void BroadCastToRooms(JabbrCommand command, Task<User> u, JabbRClient client)
{
var user = u.Result;
foreach (string room in command.Rooms)
SendMessagesToRoom(command, client, user, room);
}
public Bot2(string name, string password, string url)
{
Name = name;
_url = url;
_password = password;
client = new JabbRClient(_url);
}
public JabbrListenerWorker(LogOnInfo logOnInfo, JabbRClient client, string[] rooms, IRobot robo, string userName)
{
_robo = robo;
_rooms = rooms;
_client = client;
_logOnInfo = logOnInfo;
_userName = userName;
}
private void InitializeClient()
{
_client = new JabbRClient(_url);
_client.MessageReceived += (message, room) =>
{
ProcessMessage(message, room);
};
}
public AuthenticationService(
JabbRClient jabbrClient,
UserService userService,
RoomService roomService)
{
_client = jabbrClient;
_userService = userService;
_roomService = roomService;
}
public void Send(JabbrCommand command)
{
var client = new JabbRClient(command.Host);
var connect = Connect(client, command);
connect.ContinueWith(c =>
{
client.GetUserInfo()
.ContinueWith(u => BroadCastToRooms(command, u, client));
});
}
public UserService(ServiceLocator serviceLocator, JabbRClient client)
{
_serviceLocator = serviceLocator;
_client = client;
_users = new ConcurrentDictionary<string, UserViewModel>();
_client.UserActivityChanged += OnUserActivityChanged;
_client.NoteChanged += UserNoteChanged;
_client.UsersInactive += OnUsersInactive;
_client.GravatarChanged += OnGravatarChanged;
_client.UsernameChanged += OnUsernameChanged;
}
public MessageService(
ServiceLocator serviceLocator,
UserService userService,
JabbRClient client,
RoomService roomService)
{
_serviceLocator = serviceLocator;
_userService = userService;
_roomService = roomService;
_client = client;
_client.MessageReceived += OnMessageReceived;
}
private void InitializeClient()
{
client = new JabbRClient(_url, new LongPollingTransport());
client.MessageReceived += (message, room) =>
{
ProcessMessage(message, room);
};
client.UserJoined += (user, message) =>
{
};
}
public RoomService(JabbRClient client, ServiceLocator serviceLocator, UserService userService)
{
_client = client;
_serviceLocator = serviceLocator;
_userService = userService;
_client.Kicked += OnKicked;
_client.OwnerAdded += OnOwnerAdded;
_client.OwnerRemoved += OnOwnerRemoved;
_client.RoomCountChanged += OnRoomCountChanged;
_client.TopicChanged += OnTopicChanged;
_client.UserJoined += OnUserJoined;
_client.UserLeft += OnUserLeft;
_client.UserTyping += OnUserTyping;
}
public JabbrAdapter(ChatServer chatServerConfig)
{
serverConfig = chatServerConfig;
client = new JabbRClient(serverConfig.ServerAddress)
{
AutoReconnect = true
};
Messages = Observable.FromEvent<Action<Message, string>, ChatMessage>(handler =>
{
Action<Message, string> converter = (jabbrMessage, room) =>
{
try
{
if (client == null)
{
return;
}
// Don't relay our own messages
if (jabbrMessage.User.Name.Equals(serverConfig.UserName, StringComparison.OrdinalIgnoreCase))
{
return;
}
var chatMessage = new ChatMessage
{
ServerId = serverConfig.ServerId,
Room = room,
User = jabbrMessage.User.Name,
Text = jabbrMessage.Content,
TimeStamp = jabbrMessage.When
};
handler(chatMessage);
}
catch (Exception ex)
{
Console.WriteLine($"{serverConfig.ServerId}|EXCEPTION: {ex}");
}
};
return converter;
},
converter => client.MessageReceived += converter,
converter => client.MessageReceived -= converter
);
}
private void Send(JabbRClient client, string room, IList<string> messages, Action callback = null)
{
if (!messages.Any())
{
if (callback == null)
return;
callback();
return;
}
string message = messages[0];
messages.RemoveAt(0);
client.Send(message, room)
.ContinueWith(t => Send(client, room, messages, callback));
}
private void SendMessagesToRoom(JabbrCommand command, JabbRClient client, User user, string roomName)
{
client.GetRoomInfo(roomName).
ContinueWith(r =>
{
Room info = r.Result;
bool userInRoom = info.Users.Any(usr => usr.Name == user.Name);
if (userInRoom)
{
Send(client,roomName, command.GetMessages());
return;
}
Action leave = () => client.LeaveRoom(roomName);
client.JoinRoom(roomName)
.ContinueWith(j => Send(client, roomName, command.GetMessages(), leave));
});
}
public override async void Attach(IRobot robo, CancellationToken token)
{
// Connect JabbR Client
var client = new JabbRClient(Host.AbsoluteUri);
try
{
robo.Log.Trace("Connecting to JabbR");
var logOnInfo = await client.Connect(UserName, Password);
robo.Log.Trace("Connection Established");
robo.Log.Info("Jabbin in JabbR");
await new JabbrListenerWorker(logOnInfo, client, Rooms, robo, UserName).Run(token);
}
catch (SecurityException)
{
robo.Log.Error("Invalid User Name or Password");
}
catch (Exception ex)
{
robo.Log.Error(ex.Message);
}
}
public override void Connect ()
{
OnConnecting (EventArgs.Empty);
if (string.IsNullOrEmpty (Address)) {
OnConnectError (new ConnectionErrorEventArgs (this, new Exception ("Address is empty")));
return;
}
if (UseSocialLogin) {
if (string.IsNullOrEmpty (UserId)) {
OnConnectError (new ConnectionErrorEventArgs (this, new NotAuthenticatedException ("Not authenticated to this server")));
return;
}
} else if (string.IsNullOrEmpty (UserName) || string.IsNullOrEmpty (Password)) {
OnConnectError (new ConnectionErrorEventArgs (this, new NotAuthenticatedException ("Username or password are not specified")));
return;
}
ServicePointManager.FindServicePoint(new Uri(Address)).ConnectionLimit = 100;
Client = new jab.JabbRClient (Address);//, new ServerSentEventsTransport());//new LongPollingTransport ());
HookupEvents ();
if (UseSocialLogin) {
connect = Client.Connect (UserId);
} else {
connect = Client.Connect (UserName, Password);
}
connect.ContinueWith (connectTask => {
if (connectTask.IsFaulted) {
Debug.WriteLine ("Error: {0}", connectTask.Exception);
OnConnectError (new ConnectionErrorEventArgs(this, connectTask.Exception));
return;
}
var logOnInfo = connectTask.Result;
Client.GetUserInfo ().ContinueWith (userTask => {
if (userTask.Exception != null) {
OnConnectError (new ConnectionErrorEventArgs(this, connectTask.Exception));
Client.Disconnect ();
return;
}
this.CurrentUser = new JabbRUser (userTask.Result);
InitializeChannels (logOnInfo.Rooms.Select (r => new JabbRRoom (this, r)));
connect = null;
OnConnected (EventArgs.Empty);
});
});
}
public override async Task Connect()
{
OnConnecting(EventArgs.Empty);
if (string.IsNullOrEmpty(Address))
{
OnConnectError(new ConnectionErrorEventArgs(this, new Exception("Address is empty")));
return;
}
if (UseSocialLogin)
{
if (string.IsNullOrEmpty(UserId))
{
OnConnectError(new ConnectionErrorEventArgs(this, new NotAuthenticatedException("Not authenticated to this server")));
return;
}
}
else if (string.IsNullOrEmpty(UserName) || string.IsNullOrEmpty(Password))
{
OnConnectError(new ConnectionErrorEventArgs(this, new NotAuthenticatedException("Username or password are not specified")));
return;
}
//ServicePointManager.FindServicePoint (new Uri (Address)).ConnectionLimit = 100;
// force long polling on mono, until SSE works reliably
Func <IClientTransport> transport;
/*if (EtoEnvironment.Platform.IsMono)
* transport = () => new LongPollingTransport();
* else*/
transport = () => new AutoTransport(new DefaultHttpClient());
Client = new jab.JabbRClient(Address, transport);
#if DEBUG
var settings = Path.Combine(EtoEnvironment.GetFolderPath(EtoSpecialFolder.ApplicationSettings), "jabbr.log");
Client.TraceWriter = new TextWriterTraceListener(settings).Writer;
Client.TraceLevel = TraceLevels.All;
#endif
if (UseSocialLogin)
{
throw new NotSupportedException();
}
bool connected = false;
try
{
var logOnInfo = await Client.Connect(UserName, Password);
highlighRegex = null;
connected = true;
HookupEvents();
OnGlobalMessageReceived(new NotificationEventArgs(new NotificationMessage(string.Format("Using {0} transport", Client.Connection.Transport.Name))));
var userInfo = await Client.GetUserInfo();
CurrentUser = new JabbRUser(this, userInfo);
loadingRooms = logOnInfo.Rooms.Select(r => new JabbRRoom(this, r)).ToList();
InitializeChannels(loadingRooms);
if (EtoEnvironment.Platform.IsMono)
{
var keepAliveTime = TimeSpan.FromMinutes(5);
if (timer != null)
{
timer.Dispose();
}
timer = new Timer(state => Client.Send(new jm.ClientMessage
{
Id = Guid.NewGuid().ToString(),
Content = string.Format("/where {0}", CurrentUser.Name)
}), null, keepAliveTime, keepAliveTime);
}
OnConnected(EventArgs.Empty);
}
catch (Exception ex)
{
Debug.Print(string.Format("Error: {0}", ex.GetBaseException().Message));
OnConnectError(new ConnectionErrorEventArgs(this, ex));
if (connected)
{
Client.Disconnect();
}
}
// load all room initial channel info/history
while (true)
{
JabbRRoom room;
lock (loadingRooms)
{
if (loadingRooms.Count > 0)
{
room = loadingRooms[0];
loadingRooms.Remove(room);
}
else
{
break;
}
}
//Debug.WriteLine(string.Format("Loading messages for room {0}", room.Name));
await room.LoadRoomInfo();
}
}
private void InitializeClient()
{
_client = new JabbRClient(_url, new LongPollingTransport());
_client.MessageReceived += (message, room) =>
{
ProcessMessage(message, room);
};
}
public override async Task Connect()
{
OnConnecting(EventArgs.Empty);
if (string.IsNullOrEmpty(Address))
{
OnConnectError(new ConnectionErrorEventArgs(this, new Exception("Address is empty")));
return;
}
if (UseSocialLogin)
{
if (string.IsNullOrEmpty(UserId))
{
OnConnectError(new ConnectionErrorEventArgs(this, new NotAuthenticatedException("Not authenticated to this server")));
return;
}
}
else if (string.IsNullOrEmpty(UserName) || string.IsNullOrEmpty(Password))
{
OnConnectError(new ConnectionErrorEventArgs(this, new NotAuthenticatedException("Username or password are not specified")));
return;
}
//ServicePointManager.FindServicePoint (new Uri (Address)).ConnectionLimit = 100;
// force long polling on mono, until SSE works reliably
IClientTransport transport;
if (EtoEnvironment.Platform.IsMono)
transport = new LongPollingTransport();
else
transport = new AutoTransport(new DefaultHttpClient());
Client = new jab.JabbRClient(Address, null, transport);
if (UseSocialLogin)
{
throw new NotSupportedException();
}
bool connected = false;
try
{
var logOnInfo = await Client.Connect(UserName, Password);
#if DEBUG
var settings = Path.Combine(EtoEnvironment.GetFolderPath(EtoSpecialFolder.ApplicationSettings), "jabbreto.log");
Client.Connection.TraceWriter = new TextWriterTraceListener(settings).Writer;
Client.Connection.TraceLevel = TraceLevels.All;
#endif
highlighRegex = null;
connected = true;
HookupEvents();
this.OnGlobalMessageReceived (new NotificationEventArgs(new NotificationMessage (string.Format ("Using {0} transport", Client.Connection.Transport.Name))));
var userInfo = await Client.GetUserInfo();
this.CurrentUser = new JabbRUser(this, userInfo);
loadingRooms = logOnInfo.Rooms.Select(r => new JabbRRoom(this, r)).ToList();
InitializeChannels(loadingRooms);
OnConnected(EventArgs.Empty);
}
catch (Exception ex)
{
Debug.Print(string.Format("Error: {0}", ex.GetBaseException().Message));
OnConnectError(new ConnectionErrorEventArgs(this, ex));
if (connected)
Client.Disconnect();
}
// load all room initial channel info/history
while (true)
{
JabbRRoom room;
lock (loadingRooms)
{
if (loadingRooms.Count > 0)
{
room = loadingRooms[0];
loadingRooms.Remove(room);
}
else
break;
}
//Debug.WriteLine(string.Format("Loading messages for room {0}", room.Name));
await room.LoadRoomInfo();
}
}
public override void Connect(FrontendManager fm, ServerModel server)
{
Trace.Call(fm, server);
Server = server;
Username = server.Username;
var chatName = String.Format("{0} {1}", Protocol, NetworkID);
ProtocolChat = new ProtocolChatModel(NetworkID, chatName, this);
ProtocolChat.InitMessageBuffer(MessageBufferPersistencyType.Volatile);
Session.AddChat(Chat);
Session.SyncChat(Chat);
try {
string url;
if (server.Hostname.StartsWith("http://") ||
server.Hostname.StartsWith("https://")) {
url = server.Hostname;
} else {
if (server.UseEncryption && server.Port == 443) {
url = String.Format("https://{0}", server.Hostname);
} else if (server.UseEncryption) {
url = String.Format("https://{0}:{1}",
server.Hostname, server.Port);
} else if (!server.UseEncryption && server.Port == 80) {
url = String.Format("http://{0}", server.Hostname);
} else {
url = String.Format("http://{0}:{1}",
server.Hostname, server.Port);
}
}
// HACK: SignalR's ServerSentEventsTransport times out on Mono
// for some reason and then fallbacks to LongPollingTransport
// this takes 10 seconds though, so let's go LP directly
Func<IClientTransport> transport = null;
if (Type.GetType("Mono.Runtime") == null) {
transport = () => new AutoTransport(new DefaultHttpClient());
} else {
transport = () => new LongPollingTransport();
}
var authProvider = new DefaultAuthenticationProvider(url);
Client = new JabbRClient(url, authProvider, transport);
Client.AutoReconnect = true;
Client.MessageReceived += OnMessageReceived;
Client.MeMessageReceived += OnMeMessageReceived;
Client.UserLeft += OnUserLeft;
Client.UserJoined += OnUserJoined;
Client.JoinedRoom += OnJoinedRoom;
Client.PrivateMessage += OnPrivateMessage;
Me = CreatePerson(Username);
Me.IdentityNameColored.ForegroundColor = new TextColor(0, 0, 255);
Me.IdentityNameColored.BackgroundColor = TextColor.None;
Me.IdentityNameColored.Bold = true;
Connect();
} catch (Exception ex) {
#if LOG4NET
Logger.Error(ex);
#endif
var msg = CreateMessageBuilder().
AppendEventPrefix().
AppendErrorText(_("Connection failed! Reason: {0}"),
ex.Message).
ToMessage();
Session.AddMessageToChat(ProtocolChat, msg);
}
}
async void Connect()
{
_client = new JabbRClient (this.Account.Url);
_client.AddMessageContent += HandleAddMessageContent;
//client.Disconnected += HandleDisconnected;
_client.FlagChanged += HandleFlagChanged;
_client.JoinedRoom += HandleJoinedRoom;
_client.Kicked += HandleKicked;
_client.LoggedOut += HandleLoggedOut;
_client.MeMessageReceived += HandleMeMessageReceived;
_client.MessageReceived += HandleMessageReceived;
_client.NoteChanged += HandleNoteChanged;
_client.OwnerAdded += HandleOwnerAdded;
_client.OwnerRemoved += HandleOwnerRemoved;
_client.PrivateMessage += HandlePrivateMessage;
_client.RoomCountChanged += HandleRoomCountChanged;
//client.StateChanged += HandleStateChanged;
_client.TopicChanged += HandleTopicChanged;
_client.UserActivityChanged += HandleUserActivityChanged;
_client.UserJoined += HandleUserJoined;
_client.UserLeft += HandleUserLeft;
_client.UsernameChanged += HandleUsernameChanged;
_client.UsersInactive += HandleUsersInactive;
_client.UserTyping += HandleUserTyping;
LogOnInfo logonInfo = null;
try
{
logonInfo = await _client.Connect (Account.Username, Account.Password);
}
catch (Exception ex)
{
Log ("Connect Exception: " + ex);
}
if (logonInfo != null)
{
this.UserId = logonInfo.UserId;
//Add us into the result's Rooms
foreach (var r in logonInfo.Rooms)
{
Mvx.Trace("Rooms In: " + r.Name);
RoomsIn.Add (r);
}
Log ("Connected> " + this.UserId ?? "" + " -> Rooms: " + RoomsIn.Count);
_messenger.Publish (new JabbrConnectedMessage (this, this, this.UserId, RoomsIn));
}
}
