void connectUserToATC(User user, Connection connection)
{
string atcID = connection.destinationNumber[0].ToString() + connection.destinationNumber[1].ToString();
ATC atc = connectedATCs.Find(x => x.id == atcID);
if (atc == null)
{
log($"User {user.id} requested ATC {ATCNameService.GetName(atcID)} ({atcID}) that is not connected to the ATC.");
foreach (ATC anotherATC in connectedATCs)
{
log($"Requested ATC {anotherATC.name} to connect user {user.id} to ATC {ATCNameService.GetName(atcID)} ({atcID}).");
anotherATC.connectUserToATC(user, connection);
}
}
else
{
string existingConnectionID = ATC.FindExistingConnectionID(this.id, connection, atc, this.id);
if (existingConnectionID != null)
{
atc.handleIncomingConnection(existingConnectionID, this, getUserId(connection.destinationNumber), connection.id, user.GlobalID);
log($"Connected User {user.id} to ATC {ATCNameService.GetName(atcID)} ({atcID}). Connection ID: {connection.id}");
}
else
{
string connectionID = atc.handleIncomingConnection(this, getUserId(connection.destinationNumber), connection.id, user.GlobalID);
connection.ConnectATC(atc, connectionID);
log($"Connected User {user.id} to ATC {ATCNameService.GetName(atcID)} ({atcID}). Connection ID: {connection.id}");
}
}
}
public void connect(ATC atc)
{
if (!connectedATCs.Exists(a => a.id == atc.id))
{
connectedATCs.Add(atc);
}
log($"{atc.name} ATC connected to ATC.");
}
public void handleIncomingConnection(string existingConnectionID, ATC atc, string destinationNumber, string connectionID, string callerID)
{
Connection connection = connections.Find(c => c.id == existingConnectionID);
connection.destinationNumber = destinationNumber;
connectionsChanged();
connectUserWithIncommingCaller(connection, atc, callerID, true);
log($"Handled incoming connection from ATC {atc.name}. Destination number: {destinationNumber}. Caller ID: {callerID}. This connection between these ATCs has existed before.");
}
public WelcomeScreen(ATC atc)
{
InitializeComponent();
nameLbl.Text = atc.name.ToUpper();
this.Text = atc.name;
this.atc = atc;
settingsScreen = new ATCSettingsScreen(atc);
ATCService.shared.connect(atc);
this.FormClosing += WelcomeScreen_FormClosing;
}
public void disconnect(ATC atc)
{
for (int i = 0; i < connections.Count; i++)
{
if (connections[i].connectedATCs.ContainsKey(atc))
{
handleCancel(new Signal((Transmitter)atc, SignalType.cancel, atc.id), connections[i], this.id);
}
}
connectedATCs.Remove(atc);
}
public string handleIncomingConnection(ATC atc, string destinationNumber, string connectionID, string callerID)
{
Connection connection = new Connection(getConnectionID());
connection.ConnectATC(atc, connectionID);
connection.destinationNumber = destinationNumber;
connections.Add(connection);
connectionsChanged();
connectUserWithIncommingCaller(connection, atc, callerID, false);
log($"Handled incoming connection from ATC {atc.name}. Destination number: {destinationNumber}. Caller ID: {callerID}.");
return(connection.id);
}
public ATCSettingsScreen(ATC atc)
{
InitializeComponent();
ConfigureUI();
this.atc = atc;
atc.logEvent += AddLog;
ATCService.shared.stateUpdated += UpdateOnlineATCList;
atc.connectionsChanged += UpdateConnectionsList;
this.UpdateConnectionsList();
this.UpdateOnlineATCList();
this.UpdateOnlineUsersList();
}
static User connectUser(string id, ATC atc)
{
User user = new User(id, atc);
if (atc.connect(user))
{
return(user);
}
else
{
return(null);
}
}
public void connect(ATC atc)
{
foreach (ATC a in onlineATCs)
{
if (atc.id != a.id)
{
a.connect(atc);
atc.connect(a);
}
}
onlineATCs.Add(atc);
atc.connectionsChanged += stateUpdated;
stateUpdated();
}
public static LoginResult login(string id, string password, ATC atc)
{
try
{
int idINT = Convert.ToInt32(id);
if (idINT > 999 || idINT < 0)
{
return(new LoginResult(false, "Unacceptable id.", null));
}
Dictionary <string, string> db = DatabaseService.Load(atc.id);
if (db == null)
{
return(LoginService.signUp(atc, id, password));
}
if (!db.ContainsKey(id) || db[id] == null)
{
return(LoginService.signUp(atc, id, password));
}
string passwordHash = db[id];
if (HashService.VerifySHA256Hash(password, passwordHash))
{
User user = connectUser(id, atc);
if (user != null)
{
return(new LoginResult(true, null, user));
}
else
{
return(new LoginResult(false, "User is already connected.", null));
}
}
else
{
return(new LoginResult(false, "Incorrect password.", null));
}
}
catch (Exception err)
{
Console.WriteLine(err.Message);
return(new LoginResult(false, "Error occured while processing your input. Try again.", null));
}
}
void handleIncomingBusyOffline(Signal signal, Connection connection, string atcID)
{
string sourceAtcID = getATCid(signal.sender.id);
ATC atcToRemove = connection.connectedATCs.Keys.ToList().Find(a => a.id == sourceAtcID);
if (atcToRemove != null)
{
connection.connectedATCs.Remove(atcToRemove);
log($"Removed ATC {atcToRemove.name} from connection {connection.id}.");
}
Signal busyOfflineSignal = new Signal((Transmitter)this, signal.type, $"{ATCNameService.GetName(sourceAtcID)} ({sourceAtcID})");
Signal cancelSignal = new Signal((Transmitter)this, SignalType.cancel, $"{ATCNameService.GetName(sourceAtcID)} ({sourceAtcID})");
foreach (User user in connection.users)
{
user.handle(busyOfflineSignal);
user.handle(cancelSignal);
log($"Sended User {user.id} a cancel signal. Connection ID: {connection.id}.");
}
foreach (ATC connectedATC in connection.connectedATCs.Keys)
{
connectedATC.handleSignalFromATC(signal, this.id, connection.connectedATCs[connectedATC]);
log($"Sended ATC {connectedATC.name} a cancel signal. Connection ID: {connection.id}.");
}
if (connection.users.Count + connection.connectedATCs.Keys.Count == 1)
{
Signal connectionClosedSignal = new Signal((Transmitter)this, SignalType.tone, "Connection closed.");
if (connection.users.Count == 1)
{
User lastUser = connection.users.First();
lastUser.handle(connectionClosedSignal);
log($"Sended User {lastUser.id} a tone signal. Connection ID: {connection.id}. Connection Closed.");
}
else
{
ATC lastATC = connection.connectedATCs.Keys.First();
lastATC.handleSignalFromATC(connectionClosedSignal, this.id, connection.connectedATCs[lastATC]);
log($"Sended ATC {lastATC.name} a tone signal. Connection ID: {connection.id}. Connection Closed.");
}
connections.Remove(connection);
connectionsChanged();
}
}
static LoginResult signUp(ATC atc, string id, string password)
{
if (DatabaseService.Save(atc.id, id, HashService.GetSHA256Hash(password)))
{
User user = connectUser(id, atc);
if (user != null)
{
return(new LoginResult(true, null, user));
}
else
{
return(new LoginResult(false, "User is already connected.", null));
}
}
else
{
return(new LoginResult(false, "Error occured while signing up.", null));
}
}
static string FindExistingConnectionID(string connectionATCid, Connection connection, ATC desiredATC, string sourceATC)
{
foreach (ATC atc in connection.connectedATCs.Keys)
{
if (atc.id != sourceATC)
{
if (atc.id == desiredATC.id)
{
return(connection.connectedATCs[atc]);
}
else
{
Connection lowerConnection = atc.connections.Find(c => c.id == connection.connectedATCs[atc]);
if (lowerConnection != null)
{
return(ATC.FindExistingConnectionID(atc.id, lowerConnection, desiredATC, connectionATCid));
}
}
}
}
return(null);
}
public void disconnect(ATC atc)
{
onlineATCs.Remove(atc);
stateUpdated();
}
public ATCLoginResult(bool isSuccessfull, string error, ATC atc)
{
this.error = error;
this.isSuccessfull = isSuccessfull;
this.atc = atc;
}
public void ConnectATC(ATC atc, string connectionID)
{
connectedATCs[atc] = connectionID;
}
public User(string id, ATC atc) : base(id)
{
currentATC = atc;
sendSignal += logOutgoingSignal;
}
public LoginScreen(ATC atc)
{
InitializeComponent();
this.atc = atc;
}
void handleCancel(Signal signal, Connection connection, string atcID)
{
if (connection.status == ConnectionStatus.TryingToAddAnotherUser && signal.sender is User)
{
connection.status = ConnectionStatus.TryingToAddAnotherUser;
connection.destinationNumber = "";
(signal.sender as User).handle(new Signal((Transmitter)this, SignalType.tone, $"Destination number cleared."));
if (isGoingToMakeOutgoingCall.ContainsKey(signal.sender.id))
{
isGoingToMakeOutgoingCall.Remove(signal.sender.id);
}
return;
}
string sourceAtcID = "";
if (signal.sender is User)
{
sourceAtcID = getATCid((signal.sender as User).GlobalID);
}
else
{
sourceAtcID = signal.sender.id;
}
bool isSignalLocal = sourceAtcID == this.id;
if (isSignalLocal)
{
connection.users.Remove(signal.sender as User);
log($"Removed User {signal.sender.id} from connection {connection.id}.");
}
else
{
ATC atcToRemove = connection.connectedATCs.Keys.ToList().Find(a => a.id == sourceAtcID);
if (atcToRemove != null)
{
connection.connectedATCs.Remove(atcToRemove);
log($"Removed ATC {atcToRemove.name} from connection {connection.id}.");
}
}
Signal cancelSignal = new Signal((Transmitter)this, SignalType.cancel, isSignalLocal ? signal.sender.id : $"{ATCNameService.GetName(sourceAtcID)} ({sourceAtcID})");
foreach (User user in connection.users)
{
user.handle(cancelSignal);
log($"Sended User {user.id} a cancel signal. Connection ID: {connection.id}.");
}
foreach (ATC connectedATC in connection.connectedATCs.Keys)
{
if (connectedATC.id != atcID)
{
connectedATC.handleSignalFromATC(signal, this.id, connection.connectedATCs[connectedATC]);
log($"Sended ATC {connectedATC.name} a cancel signal. Connection ID: {connection.id}.");
}
}
if (connection.users.Count + connection.connectedATCs.Keys.Count == 1)
{
Signal connectionClosedSignal = new Signal((Transmitter)this, SignalType.tone, "Connection closed.");
if (connection.users.Count == 1)
{
User lastUser = connection.users.First();
lastUser.handle(connectionClosedSignal);
log($"Sended User {lastUser.id} a tone signal. Connection ID: {connection.id}. Connection Closed.");
}
else
{
ATC lastATC = connection.connectedATCs.Keys.First();
if (lastATC.id != atcID)
{
lastATC.handleSignalFromATC(connectionClosedSignal, this.id, connection.connectedATCs[lastATC]);
log($"Sended ATC {lastATC.name} a tone signal. Connection ID: {connection.id}. Connection Closed.");
}
}
connections.Remove(connection);
connectionsChanged();
}
}
void connectUserWithIncommingCaller(Connection connection, ATC atc, string callerID, bool existingConnection)
{
connection.status = ConnectionStatus.DestinationSelected;
User user = connectedUsers.Find(x => x.id == connection.destinationNumber);
if (user == null)
{
Signal offlineSignal = new Signal((Transmitter)this, SignalType.offline);
log($"Sended ATC {atc.name} a signal. Requested User {connection.destinationNumber} is offline.");
if (existingConnection)
{
foreach (User u in connection.users)
{
u.handle(offlineSignal);
log($"User {u.id} received response. User {connection.destinationNumber} is offline.");
}
foreach (ATC a in connection.connectedATCs.Keys)
{
a.handleSignalFromATC(offlineSignal, this.id, connection.connectedATCs[a]);
log($"ATC {a.id} received response. User {connection.destinationNumber} is offline.");
}
}
else
{
atc.handleSignalFromATC(new Signal((Transmitter)this, SignalType.offline), this.id, connection.connectedATCs[atc]);
log($"ATC {atc.id} received response. User {connection.destinationNumber} is offline.");
connections.Remove(connection);
connectionsChanged();
}
}
else
{
if (connections.Exists(c => c.users.Exists(x => x.id == connection.destinationNumber)))
{
Signal busySignal = new Signal((Transmitter)this, SignalType.busy);
if (existingConnection)
{
foreach (User u in connection.users)
{
u.handle(busySignal);
log($"User {u.id} received response. User {connection.destinationNumber} is busy.");
}
foreach (ATC a in connection.connectedATCs.Keys)
{
a.handleSignalFromATC(busySignal, this.id, connection.connectedATCs[a]);
log($"ATC {a.id} received response. User {connection.destinationNumber} is busy.");
}
}
else
{
log($"Sended ATC {atc.name} a signal. Requested User {connection.destinationNumber} is busy.");
atc.handleSignalFromATC(busySignal, this.id, connection.connectedATCs[atc]);
connections.Remove(connection);
connectionsChanged();
}
}
else
{
Signal callSignal = new Signal((Transmitter)this, SignalType.call, user.id);
if (!existingConnection)
{
atc.handleSignalFromATC(callSignal, this.id, connection.connectedATCs[atc]);
}
user.handle(callSignal);
waitingForTheResponceFrom.Add(user);
log($"Sended ATC {atc.name} a call signal. Waiting for the responce from User {user.id}.");
}
}
}
