public void HandleGetAccountsResponse(JamPacket packet)
{
if (packet.Header.DataType != GetAccountsResponse.DATA_TYPE)
{
return;
}
App.Current.Dispatcher.Invoke(() =>
{
MainWindow main = App.Current.MainWindow as MainWindow;
GetAccountsResponse response = new GetAccountsResponse(packet.Data, main.Client.Serializer);
foreach (Tuple <Account, bool> tuple in response.Accounts)
{
Account account = tuple.Item1;
bool online = tuple.Item2;
if (account.AccountID != LoggedInAccount.Account.AccountID)
{
DisplayableAccount displayableAccount = new DisplayableAccount(account, online);
Accounts.Add(displayableAccount);
}
}
});
}
private void Register(object sender, RoutedEventArgs e)
{
SaveLoginSettings();
LoginMessageText = string.Empty;
AwaitingLoginResponse = true;
Cursor = Cursors.Wait;
MainWindow main = App.Current.MainWindow as MainWindow;
Task.Run(() =>
{
main.Client.Connect(address, port, CONNECT_TIMEOUT);
if (!main.Client.IsConnected)
{
App.Current.Dispatcher.Invoke(() =>
{
main.Client.Dispose();
loginMessageText = SERVER_UNREACHABLE;
AwaitingLoginResponse = false;
if (!WorkInProgress)
{
Cursor = Cursors.Arrow;
}
});
return;
}
RegisterAccountRequest request = new RegisterAccountRequest(username, PasswordBox.Password, main.Client.Serializer);
JamPacket requestPacket = new JamPacket(Guid.Empty, Guid.Empty, RegisterAccountRequest.DATA_TYPE, request.GetBytes());
main.Client.Send(requestPacket);
});
}
private static void RegisterAccount(JamServerConnection serverConnection, JamPacket packet)
{
RegisterAccountRequest register = new RegisterAccountRequest(packet.Data, serverConnection.Serializer);
RegisterAccountResponse response;
try
{
Account createdAccount = AccountFactory.Generate(register.Username, register.Password, Program.Server.HashFactory, true);
response = new RegisterAccountResponse(RegisterAccountResponse.AccountRegistrationResult.Good, createdAccount, serverConnection.Serializer);
Console.WriteLine("Registered new Account: {0} - {1}", createdAccount.AccountID, createdAccount.Username);
}
catch (DbUpdateException)
{
response = new RegisterAccountResponse(RegisterAccountResponse.AccountRegistrationResult.Bad, null, serverConnection.Serializer);
}
catch (EntityException)
{
serverConnection.Server.Dispose();
return;
}
JamPacket responsePacket = new JamPacket(Guid.Empty, Guid.Empty, RegisterAccountResponse.DATA_TYPE, response.GetBytes());
serverConnection.Send(responsePacket);
}
public void ReceiveMessage(JamPacket packet)
{
if (packet.Header.DataType != SendMessageImperative.DATA_TYPE)
{
return;
}
App.Current.Dispatcher.Invoke(() =>
{
MainWindow main = App.Current.MainWindow as MainWindow;
SendMessageImperative imperative = new SendMessageImperative(packet.Data, main.Client.Serializer);
Guid senderID = packet.Header.Sender;
DateTime sendTimeUtc = packet.Header.SendTimeUtc;
DisplayableAccount senderAccount = Accounts.SingleOrDefault(x => x.Account.AccountID == senderID);
if (senderAccount == null)
{
return;
}
DisplayableMessage receivedMessage = new DisplayableMessage(DisplayableMessage.MessageType.Remote, senderAccount, sendTimeUtc, imperative.Message);
if (SelectedAccount != null && SelectedAccount.Account.AccountID == senderID)
{
receivedMessage.Seen = true;
}
senderAccount.AddMessage(receivedMessage);
NotifyPropertyChanged(nameof(UnseenMessages));
});
}
public void HandleRegistrationResponse(JamPacket packet)
{
if (packet.Header.DataType != RegisterAccountResponse.DATA_TYPE)
{
return;
}
App.Current.Dispatcher.Invoke(() =>
{
MainWindow main = App.Current.MainWindow as MainWindow;
RegisterAccountResponse response = new RegisterAccountResponse(packet.Data, main.Client.Serializer);
if (response.Result == RegisterAccountResponse.AccountRegistrationResult.Good)
{
main.Client.Dispose();
Login(null, null);
return;
}
else
{
main.Client.Dispose();
LoginMessageText = USERNAME_IN_USE;
ClearPassword();
}
AwaitingLoginResponse = false;
if (!WorkInProgress)
{
Cursor = Cursors.Arrow;
}
});
}
internal static void Route(JamServerConnection serverConnection, JamPacket packet)
{
JamServer server = serverConnection.Server;
Guid recipient = packet.Header.Receipient;
if (recipient == Guid.Empty)
{
InternalServerInterpreter.Interpret(serverConnection, packet);
return;
}
JamServerConnection recipientConnection = server.GetConnection(recipient);
if (recipientConnection == null)
{
server.OnUndelieveredMessageReceived(new JamServer.MessageReceivedEventArgs()
{
ServerConnection = serverConnection, Packet = packet
});
}
else
{
recipientConnection.Send(packet);
}
}
public void Login(string username, string password)
{
LoginRequest loginRequest = new LoginRequest(AppSigniture, username, password, Serializer);
JamPacket packet = new JamPacket(Guid.Empty, Guid.Empty, LoginRequest.DATA_TYPE, loginRequest.GetBytes());
Send(packet);
}
public void GetAccounts()
{
MainWindow main = App.Current.MainWindow as MainWindow;
GetAccountsRequest request = new GetAccountsRequest(main.Client.Serializer);
JamPacket requestPacket = new JamPacket(Guid.Empty, Guid.Empty, GetAccountsRequest.DATA_TYPE, request.GetBytes());
main.Client.Send(requestPacket);
}
private async void PollConnection(int pollFrequency)
{
while (Alive)
{
await Task.Delay(pollFrequency);
PingRequest pingRequest = new PingRequest(DateTime.UtcNow);
JamPacket pingPacket = new JamPacket(PingRequest.DATA_TYPE, pingRequest.GetBytes());
Send(pingPacket);
}
}
private static void HandleAccountRegistrationResponse(JamPacket packet)
{
App.Current.Dispatcher.Invoke(() =>
{
MainWindow main = App.Current.MainWindow as MainWindow;
if (main.ViewFrame.Content is LoginPage page)
{
Task.Run(() => page.HandleRegistrationResponse(packet));
}
});
}
private static void HandleGetAccountsResponse(JamPacket packet)
{
App.Current.Dispatcher.Invoke(() =>
{
MainWindow main = App.Current.MainWindow as MainWindow;
if (main.ViewFrame.Content is MessagePage page)
{
Task.Run(() => page.HandleGetAccountsResponse(packet));
}
});
}
private static void HandleOnlineStatusChangedImperative(JamPacket packet)
{
App.Current.Dispatcher.Invoke(() =>
{
MainWindow main = App.Current.MainWindow as MainWindow;
if (main.ViewFrame.Content is MessagePage page)
{
Task.Run(() => page.HandleAccountOnlineStatusChangedImperative(packet));
}
});
}
private static void HandleSendMessageImperative(JamPacket packet)
{
App.Current.Dispatcher.Invoke(() =>
{
MainWindow main = App.Current.MainWindow as MainWindow;
if (main.ViewFrame.Content is MessagePage page)
{
Task.Run(() => page.ReceiveMessage(packet));
}
});
}
private void PollConnection(int pollFrequency)
{
while (alive)
{
Thread.Sleep(pollFrequency);
PingRequest pingRequest = new PingRequest(DateTime.UtcNow, Serializer);
JamPacket pingPacket = new JamPacket(Guid.Empty, Guid.Empty, PingRequest.DATA_TYPE, pingRequest.GetBytes());
Send(pingPacket);
}
}
internal static void OnClientIdentified(object sender, JamServer.IdentifiedConnectionEventArgs e)
{
Console.WriteLine("Client: {0} identified as: {1} - {2}.", e.RemoteEndPoint, e.Account.AccountID, e.Account.Username);
AccountOnlineStatusChangedImperative imperative = new AccountOnlineStatusChangedImperative(e.Account, true, e.ServerConnection.Serializer);
JamPacket imperativePacket = new JamPacket(Guid.Empty, Guid.Empty, AccountOnlineStatusChangedImperative.DATA_TYPE, imperative.GetBytes());
foreach (JamServerConnection connection in e.ServerConnection.Server.GetAllConnections())
{
connection.Send(imperativePacket);
}
}
internal static void Interpret(JamServerConnection serverConnection, JamPacket packet)
{
switch (packet.Header.DataType)
{
case RegisterAccountRequest.DATA_TYPE:
RegisterAccount(serverConnection, packet);
break;
case GetAccountsRequest.DATA_TYPE:
GetRegisteredAccounts(serverConnection);
break;
}
}
public void RespondToPing(JamPacket pingPacket)
{
if (pingPacket.Header.DataType != PingRequest.DATA_TYPE)
{
return;
}
PingRequest request = new PingRequest(pingPacket.Data);
PingResponse response = new PingResponse(request.PingTimeUtc, DateTime.UtcNow);
JamPacket responsePacket = new JamPacket(PingResponse.DATA_TYPE, response.GetBytes());
Send(responsePacket);
}
private void Listen()
{
while (alive)
{
JamPacket packet = JamPacket.Receive(stream);
if (packet == null)
{
Dispose();
return;
}
InternalClientInterpreter.Interpret(this, packet);
}
}
private void Listen()
{
while (alive)
{
JamPacket packet = JamPacket.Receive(stream);
if (packet == null)
{
Dispose();
return;
}
JamPacketRouter.Route(this, packet);
}
}
internal static void Interpret(JamClient client, JamPacket packet)
{
switch (packet.Header.DataType)
{
case LoginResponse.DATA_TYPE:
client.HandleLoginResponse(packet);
break;
case PingRequest.DATA_TYPE:
client.RespondToPing(packet);
break;
default:
client.OnMessageReceived(new JamClient.MessageReceivedEventArgs()
{
Packet = packet
});
break;
}
}
internal static void Interpret(JamServerConnection serverConnection, JamPacket packet)
{
switch (packet.Header.DataType)
{
case LoginRequest.DATA_TYPE:
serverConnection.RespondToLogin(packet);
break;
case PingRequest.DATA_TYPE:
serverConnection.RespondToPing(packet);
break;
default:
serverConnection.Server.OnMessageReceived(new JamServer.MessageReceivedEventArgs()
{
ServerConnection = serverConnection, Packet = packet
});
break;
}
}
internal static void Interpret(JamPacket packet)
{
switch (packet.Header.DataType)
{
case RegisterAccountResponse.DATA_TYPE:
HandleAccountRegistrationResponse(packet);
break;
case GetAccountsResponse.DATA_TYPE:
HandleGetAccountsResponse(packet);
break;
case AccountOnlineStatusChangedImperative.DATA_TYPE:
HandleOnlineStatusChangedImperative(packet);
break;
case SendMessageImperative.DATA_TYPE:
HandleSendMessageImperative(packet);
break;
}
}
public void RespondToPing(JamPacket pingPacket)
{
if (pingPacket.Header.DataType != PingRequest.DATA_TYPE)
{
return;
}
PingRequest request = new PingRequest(pingPacket.Data, Serializer);
PingResponse response = new PingResponse(request.PingTimeUtc, DateTime.UtcNow, Serializer);
Guid accountID = Guid.Empty;
if (Account != null)
{
accountID = Account.AccountID;
}
JamPacket responsePacket = new JamPacket(pingPacket.Header.Sender, accountID, PingResponse.DATA_TYPE, response.GetBytes());
Send(responsePacket);
}
private void SendMessage(object sender, System.Windows.Input.KeyEventArgs e)
{
if (e.Key == System.Windows.Input.Key.Enter)
{
e.Handled = true;
MainWindow main = App.Current.MainWindow as MainWindow;
TextBox messageBox = sender as TextBox;
string message = messageBox.Text;
messageBox.Clear();
if (message != string.Empty)
{
SendMessageImperative sendMessage = new SendMessageImperative(message, main.Client.Serializer);
JamPacket packet = new JamPacket(SelectedAccount.Account.AccountID, loggedInAccount.Account.AccountID, SendMessageImperative.DATA_TYPE, sendMessage.GetBytes());
main.Client.Send(packet);
DisplayableMessage sentMessage = new DisplayableMessage(DisplayableMessage.MessageType.Local, LoggedInAccount, packet.Header.SendTimeUtc, message);
SelectedAccount.AddMessage(sentMessage);
}
}
}
public void HandleAccountOnlineStatusChangedImperative(JamPacket packet)
{
if (packet.Header.DataType != AccountOnlineStatusChangedImperative.DATA_TYPE)
{
return;
}
App.Current.Dispatcher.Invoke(() =>
{
MainWindow main = App.Current.MainWindow as MainWindow;
AccountOnlineStatusChangedImperative imperative = new AccountOnlineStatusChangedImperative(packet.Data, main.Client.Serializer);
if (imperative.Account == null)
{
return;
}
Guid selectedAccountID = Guid.Empty;
if (selectedAccount != null)
{
selectedAccountID = SelectedAccount.Account.AccountID;
DisplayableAccount account = Accounts.Single(x => x.Account.AccountID == imperative.Account.AccountID);
Accounts.Remove(account);
account.Online = imperative.Online;
Accounts.Add(account);
if (selectedAccountID == account.Account.AccountID)
{
SelectedAccount = account;
}
NotifyPropertyChanged(nameof(CanSendMessage));
}
});
}
private static void GetRegisteredAccounts(JamServerConnection serverConnection)
{
List <Tuple <Account, bool> > accounts = new List <Tuple <Account, bool> >();
try
{
foreach (Account account in AccountFactory.Accounts)
{
bool online = serverConnection.Server.GetConnection(account.AccountID) != null;
accounts.Add(new Tuple <Account, bool>(account, online));
}
}
catch (EntityException)
{
serverConnection.Server.Dispose();
return;
}
GetAccountsResponse response = new GetAccountsResponse(accounts, serverConnection.Serializer);
JamPacket responsePacket = new JamPacket(Guid.Empty, Guid.Empty, GetAccountsResponse.DATA_TYPE, response.GetBytes());
serverConnection.Send(responsePacket);
}
public void HandleLoginResponse(JamPacket loginResponsePacket)
{
if (loginResponsePacket.Header.DataType != LoginResponse.DATA_TYPE)
{
return;
}
LoginResponse response = new LoginResponse(loginResponsePacket.Data, Serializer);
LoginResultEventArgs resultArgs = new LoginResultEventArgs()
{
Result = response.Result
};
if (response.Result == LoginResponse.LoginResult.Good)
{
Account = response.Account;
OnLoginResult(resultArgs);
}
else
{
OnLoginResult(resultArgs);
Dispose();
}
}
private void Listen()
{
while (Alive)
{
JamPacket packet = JamPacket.Receive(stream);
if (packet == null)
{
Dispose();
return;
}
if (packet.Header.DataType == PingRequest.DATA_TYPE)
{
RespondToPing(packet);
}
else
{
OnMessageReceived(new MessageReceivedEventArgs()
{
Packet = packet
});
}
}
}
private void Listen()
{
while (Alive)
{
JamPacket packet = JamPacket.Receive(stream);
if (packet == null)
{
Dispose();
return;
}
if (packet.Header.DataType == PingRequest.DATA_TYPE)
{
RespondToPing(packet);
}
else if (packet.Header.DataType != PingResponse.DATA_TYPE)
{
server.OnMessageReceived(new JamServer.MessageReceivedEventArgs()
{
ServerConnection = this, Packet = packet
});
}
}
}
public void Send(JamPacket packet)
{
packetSendQueue.Enqueue(packet);
}
