private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
if (firstClose)
{
this.Visibility = System.Windows.Visibility.Hidden;
firstClose = false;
e.Cancel = true;
TrueMessage trueMessageToServer = new TrueMessage {
Command = Command.Disconnect, Login = login
};
byte[] dataDisconnectRequest;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToServer);
dataDisconnectRequest = stream.ToArray();
}
IAsyncResult asyncResult = networkStream.BeginWrite(dataDisconnectRequest, 0, dataDisconnectRequest.Length, new AsyncCallback(DisconnectRequest), null);
asyncResult.AsyncWaitHandle.WaitOne();
Environment.Exit(0);
}
}
private void AddButton_Click(object sender, RoutedEventArgs e)
{
AddTestWindow addTestWindow = new AddTestWindow();
addTestWindow.ShowDialog();
if (addTestWindow.Test == null)
{
return;
}
Test test = addTestWindow.Test;
TrueMessage trueMessageToServer = new TrueMessage {
Command = Command.AddTest, Login = login, Message = test
};
byte[] dataAddTestRequest;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToServer);
dataAddTestRequest = stream.ToArray();
}
networkStream.BeginWrite(dataAddTestRequest, 0, dataAddTestRequest.Length, new AsyncCallback(AddTestRequest), null);
}
private void DeleteButton_Click(object sender, RoutedEventArgs e)
{
int idx = UsersListView.SelectedIndex;
if (idx == -1)
{
return;
}
string userLoginToDelete = UserList[idx].Login;
UserList.Remove(UserList[idx]);
DeleteButton.IsEnabled = false;
TrueMessage trueMessageToServer = new TrueMessage {
Command = Command.DeleteUser, Login = login, Message = userLoginToDelete
};
byte[] dataDeleteUserRequest;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToServer);
dataDeleteUserRequest = stream.ToArray();
}
networkStream.BeginWrite(dataDeleteUserRequest, 0, dataDeleteUserRequest.Length, new AsyncCallback(DeleteUserRequest), null);
}
private void ConnectAnswer(IAsyncResult ar)
{
networkStream.EndRead(ar);
byte[] dataConnectAnswer = (byte[])ar.AsyncState;
IFormatter formatter = new BinaryFormatter();
TrueMessage trueMessageFromServer = new TrueMessage();
using (MemoryStream memoryStream = new MemoryStream(dataConnectAnswer))
{
trueMessageFromServer = (TrueMessage)formatter.Deserialize(memoryStream);
}
if (trueMessageFromServer.Command == Command.Approve)
{
Array array = (Array)trueMessageFromServer.Message;
UserList = new ObservableCollection <UserLW>((IEnumerable <UserLW>)array);
this.Dispatcher.Invoke(() =>
{
UsersListView.ItemsSource = UserList;
});
}
else if (trueMessageFromServer.Command == Command.Reject)
{
}
else
{
MessageBox.Show("Received message from server is incorrect.", "Error");
}
}
private void AddButton_Click(object sender, RoutedEventArgs e)
{
UserAddWindow userAddWindow = new UserAddWindow();
Application.Current.Dispatcher.Invoke((Action) delegate
{
userAddWindow.ShowDialog();
if (userAddWindow.UserLW != null)
{
UserList.Add(userAddWindow.UserLW);
}
lastAddedUser = userAddWindow.UserLW;
});
TrueMessage trueMessageToServer = new TrueMessage {
Command = Command.AddUser, Login = login, Message = userAddWindow.UserLW
};
byte[] dataAddUserRequest;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToServer);
dataAddUserRequest = stream.ToArray();
}
networkStream.BeginWrite(dataAddUserRequest, 0, dataAddUserRequest.Length, new AsyncCallback(AddUserRequest), null);
}
private void AddUserAnswer(IAsyncResult ar)
{
networkStream.EndRead(ar);
byte[] dataAddUserAnswer = (byte[])ar.AsyncState;
IFormatter formatter = new BinaryFormatter();
TrueMessage trueMessageFromServer = new TrueMessage();
using (MemoryStream memoryStream = new MemoryStream(dataAddUserAnswer))
{
trueMessageFromServer = (TrueMessage)formatter.Deserialize(memoryStream);
}
if (trueMessageFromServer.Command == Command.Approve)
{
MessageBox.Show("User successfully added");
}
else if (trueMessageFromServer.Command == Command.Reject)
{
Application.Current.Dispatcher.Invoke((Action) delegate
{
UserList.Remove(lastAddedUser);
});
MessageBox.Show($"User cannot be added: {trueMessageFromServer.Message}");
}
else
{
MessageBox.Show("Received message from server is incorrect.", "Error");
}
}
private void ConnectFunction(IAsyncResult ar)
{
client.EndConnect(ar);
networkStream = client.GetStream();
string login = null;
string password = null;
this.Dispatcher.Invoke(() =>
{
login = UsernameTextBox.Text;
password = PasswordTextBox.Password;
});
TrueMessage trueMessageToServer = new TrueMessage {
Command = Command.LogIn, Login = login, Message = password
};
byte[] dataLogInRequest;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToServer);
dataLogInRequest = stream.ToArray();
}
networkStream.BeginWrite(dataLogInRequest, 0, dataLogInRequest.Length, new AsyncCallback(LogInRequest), null);
}
private void SendMarkAnswer(IAsyncResult ar)
{
networkStream.EndRead(ar);
byte[] dataSendMarkAnswer = (byte[])ar.AsyncState;
IFormatter formatter = new BinaryFormatter();
TrueMessage trueMessageFromServer = new TrueMessage();
using (MemoryStream memoryStream = new MemoryStream(dataSendMarkAnswer))
{
trueMessageFromServer = (TrueMessage)formatter.Deserialize(memoryStream);
}
if (trueMessageFromServer.Command == Command.Approve)
{
MessageBox.Show("Test ended");
}
else if (trueMessageFromServer.Command == Command.Reject)
{
}
else
{
MessageBox.Show("Received message from server is incorrect.", "Error");
}
}
private void DeleteTestAnswer(IAsyncResult ar)
{
networkStream.EndRead(ar);
byte[] dataDeleteTestAnswer = (byte[])ar.AsyncState;
IFormatter formatter = new BinaryFormatter();
TrueMessage trueMessageFromServer = new TrueMessage();
using (MemoryStream memoryStream = new MemoryStream(dataDeleteTestAnswer))
{
trueMessageFromServer = (TrueMessage)formatter.Deserialize(memoryStream);
}
if (trueMessageFromServer.Command == Command.Approve)
{
this.Dispatcher.Invoke(() =>
{
TestNames.Remove((string)trueMessageFromServer.Message);
});
MessageBox.Show("Test successfully deleted");
}
else if (trueMessageFromServer.Command == Command.Reject)
{
MessageBox.Show("Test was not deleted");
}
else
{
MessageBox.Show("Received message from server is incorrect.", "Error");
}
}
private void DeleteButton_Click(object sender, RoutedEventArgs e)
{
int idx = TestListView.SelectedIndex;
if (idx == -1)
{
return;
}
string testToDelete = TestNames[idx];
TrueMessage trueMessageToServer = new TrueMessage {
Command = Command.DeleteTest, Login = login, Message = testToDelete
};
byte[] dataDeleteTestRequest;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToServer);
dataDeleteTestRequest = stream.ToArray();
}
networkStream.BeginWrite(dataDeleteTestRequest, 0, dataDeleteTestRequest.Length, new AsyncCallback(DeleteTestRequest), null);
}
private void EndTest()
{
QuestionNumberTextBlock.Visibility = Visibility.Hidden;
QuestionFrame.Visibility = Visibility.Hidden;
double baseScore = 0;
double modifierSum = 0;
double totalScore = 0;
int totalAnswered = 0;
foreach (Question question in Test.Questions)
{
question.IsAnsweredCorrectly = true;
foreach (Answer answer in question.Answers)
{
if (answer.IsChecked != answer.IsRight)
{
question.IsAnsweredCorrectly = false;
break;
}
}
modifierSum += question.ScoreModifier;
}
baseScore = 100 / modifierSum;
foreach (Question question in Test.Questions)
{
if (question.IsAnsweredCorrectly)
{
totalScore += baseScore * question.ScoreModifier;
totalAnswered++;
}
}
totalScore = Math.Round(totalScore, 0, MidpointRounding.AwayFromZero);
ScoreTextBlock.Text = $"{totalScore}";
QuestionsAnsweredTextBlock.Text = $"{totalAnswered}";
TestEndedGrid.Visibility = Visibility.Visible;
KeyValuePair <string, int> markPair = new KeyValuePair <string, int>(Test.Name, (int)totalScore);
TrueMessage trueMessageToServer = new TrueMessage {
Command = Command.SendMark, Login = login, Message = markPair
};
byte[] dataSendMarkRequest;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToServer);
dataSendMarkRequest = stream.ToArray();
}
networkStream.BeginWrite(dataSendMarkRequest, 0, dataSendMarkRequest.Length, new AsyncCallback(SendMarkRequest), null);
}
private void StudentConnect(TcpClient tcpClient, TrueMessage trueMessage)
{
string login = trueMessage.Login;
IPEndPoint clientEP = (IPEndPoint)tcpClient.Client.RemoteEndPoint;
clients.Add(login, clientEP);
Console.WriteLine($"Student {login} connected");
SqlConnection sqlConnection = new SqlConnection(connectionString);
try
{
if (sqlConnection.State == ConnectionState.Closed)
{
sqlConnection.Open();
}
TrueMessage trueMessageToClient = new TrueMessage();
if (currentTest == null)
{
trueMessageToClient.Command = Command.Reject;
}
else
{
trueMessageToClient.Command = Command.Approve;
KeyValuePair <TestDLL.Test, string> testPair = new KeyValuePair <TestDLL.Test, string>(currentTest, testTime);
trueMessageToClient.Message = testPair;
}
byte[] dataStudentConnectAnswer;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToClient);
dataStudentConnectAnswer = stream.ToArray();
}
NetworkStream networkStream = tcpClient.GetStream();
networkStream.BeginWrite(dataStudentConnectAnswer, 0, dataStudentConnectAnswer.Length, new AsyncCallback(StudentConnectAnswer), tcpClient);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
if (sqlConnection.State != ConnectionState.Closed)
{
sqlConnection.Close();
}
}
}
private void DeleteUser(TcpClient tcpClient, TrueMessage trueMessage)
{
Console.WriteLine("DeleteUser");
SqlConnection sqlConnection = new SqlConnection(connectionString);
try
{
if (sqlConnection.State == ConnectionState.Closed)
{
sqlConnection.Open();
}
string userLoginToDelete = (string)trueMessage.Message;
SqlCommand sqlCommand = new SqlCommand("Proc_DeleteUser", sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@Login", userLoginToDelete);
int count = sqlCommand.ExecuteNonQuery();
TrueMessage trueMessageToClient = new TrueMessage();
if (count == 0)
{
trueMessageToClient.Command = Command.Reject;
}
else
{
trueMessageToClient.Command = Command.Approve;
}
byte[] dataDeleteUserAnswer;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToClient);
dataDeleteUserAnswer = stream.ToArray();
}
NetworkStream networkStream = tcpClient.GetStream();
networkStream.BeginWrite(dataDeleteUserAnswer, 0, dataDeleteUserAnswer.Length, new AsyncCallback(DeleteUserAnswer), tcpClient);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
if (sqlConnection.State != ConnectionState.Closed)
{
sqlConnection.Close();
}
}
}
private void LoadCurrentTestAnswer(IAsyncResult ar)
{
networkStream.EndRead(ar);
byte[] dataLoadCurrentTestAnswer = (byte[])ar.AsyncState;
IFormatter formatter = new BinaryFormatter();
TrueMessage trueMessageFromServer = new TrueMessage();
using (MemoryStream memoryStream = new MemoryStream(dataLoadCurrentTestAnswer))
{
trueMessageFromServer = (TrueMessage)formatter.Deserialize(memoryStream);
}
if (trueMessageFromServer.Command == Command.Approve)
{
if (trueMessageFromServer.Message == null)
{
MessageBox.Show("Message was null");
return;
}
KeyValuePair <Test, string> testPair = (KeyValuePair <Test, string>)trueMessageFromServer.Message;
if (testPair.Key != null)
{
this.Dispatcher.Invoke(() =>
{
RetryLoadButton.Content = "Loaded";
RetryLoadButton.IsEnabled = false;
RetryLoadButton.Foreground = new SolidColorBrush(Colors.Black);
TestNameTextBlock.Text = testPair.Key.Name;
TestNameTextBlock.Visibility = Visibility.Visible;
});
Test = testPair.Key;
testTime = Convert.ToInt32(testPair.Value);
}
}
else if (trueMessageFromServer.Command == Command.Reject)
{
MessageBox.Show("There no test to load");
}
else
{
MessageBox.Show("Received message from server is incorrect.", "Error");
}
}
private void RetryLoadButton_Click(object sender, RoutedEventArgs e)
{
TrueMessage trueMessageToServer = new TrueMessage {
Command = Command.LoadCurrentTest, Login = login
};
byte[] dataLoadCurrentTestRequest;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToServer);
dataLoadCurrentTestRequest = stream.ToArray();
}
networkStream.BeginWrite(dataLoadCurrentTestRequest, 0, dataLoadCurrentTestRequest.Length, new AsyncCallback(LoadCurrentTestRequest), null);
}
private void ConnectFunction(IAsyncResult ar)
{
client.EndConnect(ar);
networkStream = client.GetStream();
TrueMessage trueMessageToServer = new TrueMessage {
Command = Command.StudentConnect, Login = login
};
byte[] dataConnectRequest;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToServer);
dataConnectRequest = stream.ToArray();
}
networkStream.BeginWrite(dataConnectRequest, 0, dataConnectRequest.Length, new AsyncCallback(ConnectRequest), null);
}
private void UpdateMarksButton_Click(object sender, RoutedEventArgs e)
{
int idx = TestListView.SelectedIndex;
string selectedTest = TestNames[idx];
TrueMessage trueMessageToServer = new TrueMessage {
Command = Command.UpdateMarks, Login = login, Message = selectedTest
};
byte[] dataUpdateMarksRequest;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToServer);
dataUpdateMarksRequest = stream.ToArray();
}
networkStream.BeginWrite(dataUpdateMarksRequest, 0, dataUpdateMarksRequest.Length, new AsyncCallback(UpdateMarksRequest), null);
}
private void DeleteTest(TcpClient tcpClient, TrueMessage trueMessage)
{
Console.WriteLine($"DeleteTest");
SqlConnection sqlConnection = new SqlConnection(connectionString);
try
{
if (sqlConnection.State == ConnectionState.Closed)
{
sqlConnection.Open();
}
string testNameToDelete = (string)trueMessage.Message;
SqlCommand sqlCommand = new SqlCommand("Proc_GetTestPathByName", sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@Name", testNameToDelete);
string path = Convert.ToString(sqlCommand.ExecuteScalar());
if (File.Exists(path))
{
File.Delete(path);
} //else return file already deleted??
sqlCommand = new SqlCommand("Proc_DeleteTestByName", sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@Name", testNameToDelete);
int nonQ = sqlCommand.ExecuteNonQuery();
TrueMessage trueMessageToClient = new TrueMessage();
if (nonQ == 0)
{
trueMessageToClient.Command = Command.Reject;
}
else
{
trueMessageToClient.Command = Command.Approve;
trueMessageToClient.Message = testNameToDelete;
}
byte[] dataDeleteTestAnswer;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToClient);
dataDeleteTestAnswer = stream.ToArray();
}
NetworkStream networkStream = tcpClient.GetStream();
networkStream.BeginWrite(dataDeleteTestAnswer, 0, dataDeleteTestAnswer.Length, new AsyncCallback(DeleteTestAnswer), tcpClient);
Console.WriteLine($"DeleteTest ended");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
if (sqlConnection.State != ConnectionState.Closed)
{
sqlConnection.Close();
}
}
}
private void LogInAnswer(IAsyncResult ar)
{
networkStream.EndRead(ar);
byte[] dataLogInAnswer = (byte[])ar.AsyncState;
IFormatter formatter = new BinaryFormatter();
TrueMessage trueMessageFromServer = new TrueMessage();
using (MemoryStream memoryStream = new MemoryStream(dataLogInAnswer))
{
trueMessageFromServer = (TrueMessage)formatter.Deserialize(memoryStream);
}
if (trueMessageFromServer.Command == Command.Approve)
{
Disconnect();
if ((string)trueMessageFromServer.Message == "Student")
{
Application.Current.Dispatcher.Invoke((Action) delegate
{
string login = UsernameTextBox.Text;
StudentWindow dashBoard = new StudentWindow(login);
dashBoard.Show();
this.Close();
});
}
else if ((string)trueMessageFromServer.Message == "Teacher")
{
Application.Current.Dispatcher.Invoke((Action) delegate
{
string login = UsernameTextBox.Text;
TeacherWindow dashBoard = new TeacherWindow(login);
dashBoard.Show();
this.Close();
});
}
else if ((string)trueMessageFromServer.Message == "Admin")
{
Application.Current.Dispatcher.Invoke((Action) delegate
{
string login = UsernameTextBox.Text;
AdminWindow dashBoard = new AdminWindow(login);
dashBoard.Show();
this.Close();
});
}
else
{
MessageBox.Show($"Error message from server. Message: {(string)trueMessageFromServer.Message}", "Error");
}
}
else if (trueMessageFromServer.Command == Command.Reject)
{
MessageBox.Show((string)trueMessageFromServer.Message);
}
else
{
MessageBox.Show("Received message from server is incorrect.", "Error");
}
}
private void SetCurrentButton_Click(object sender, RoutedEventArgs e)
{
if ((TextBlock)TimeComboBox.SelectedItem == null)
{
MessageBox.Show("You must set Time", "Error");
return;
}
TextBlock selectedItem = (TextBlock)TimeComboBox.SelectedItem;
string time = selectedItem.Text;
switch (time)
{
case "10 min":
time = "10";
break;
case "20 min":
time = "20";
break;
case "30 min":
time = "30";
break;
case "45 min":
time = "45";
break;
case "60 min":
time = "60";
break;
default:
break;
}
int idx = TestListView.SelectedIndex;
if (idx == -1)
{
MessageBox.Show("You must select test first", "Error");
return;
}
string testToChoose = TestNames[idx];
KeyValuePair <string, string> choosePair = new KeyValuePair <string, string>(testToChoose, time);
TrueMessage trueMessageToServer = new TrueMessage {
Command = Command.ChooseCurrentTest, Login = login, Message = choosePair
};
byte[] dataChooseCurrentTestRequest;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToServer);
dataChooseCurrentTestRequest = stream.ToArray();
}
networkStream.BeginWrite(dataChooseCurrentTestRequest, 0, dataChooseCurrentTestRequest.Length, new AsyncCallback(ChooseCurrentTestRequest), null);
}
private void ChooseCurrentTest(TcpClient tcpClient, TrueMessage trueMessage)
{
Console.WriteLine($"ChooseCurrentTest");
SqlConnection sqlConnection = new SqlConnection(connectionString);
try
{
if (sqlConnection.State == ConnectionState.Closed)
{
sqlConnection.Open();
}
KeyValuePair <string, string> choosePair = (KeyValuePair <string, string>)trueMessage.Message;
string testNameToChoose = choosePair.Key;
SqlCommand sqlCommand = new SqlCommand("Proc_GetTestPathByName", sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@Name", testNameToChoose);
string path = Convert.ToString(sqlCommand.ExecuteScalar());
TrueMessage trueMessageToClient = new TrueMessage();
if (File.Exists(path))
{
currentTest = TrueXmlSerializer.Load <TestDLL.Test>(path);
testTime = choosePair.Value;
trueMessageToClient.Command = Command.Approve;
}
else
{
trueMessageToClient.Command = Command.Reject;
trueMessageToClient.Message = "Test not found";
}
byte[] dataChooseCurrentTestAnswer;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToClient);
dataChooseCurrentTestAnswer = stream.ToArray();
}
NetworkStream networkStream = tcpClient.GetStream();
networkStream.BeginWrite(dataChooseCurrentTestAnswer, 0, dataChooseCurrentTestAnswer.Length, new AsyncCallback(ChooseCurrentTestAnswer), tcpClient);
Console.WriteLine($"ChooseCurrentTest ended");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
if (sqlConnection.State != ConnectionState.Closed)
{
sqlConnection.Close();
}
}
}
private void SendMark(TcpClient tcpClient, TrueMessage trueMessage)
{
Console.WriteLine($"LoadCurrentTest");
SqlConnection sqlConnection = new SqlConnection(connectionString);
try
{
if (sqlConnection.State == ConnectionState.Closed)
{
sqlConnection.Open();
}
//////////////////////////////////////////////////////////////////////////////////////////
KeyValuePair <string, int> markPair = (KeyValuePair <string, int>)trueMessage.Message;
string testName = markPair.Key;
int mark = markPair.Value;
SqlCommand sqlCommand = new SqlCommand("Proc_SelectUserIdByName", sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@Login", trueMessage.Login);
int userId = Convert.ToInt32(sqlCommand.ExecuteScalar());
sqlCommand = new SqlCommand("Proc_SelectTestIdByName", sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@Name", testName);
int testId = Convert.ToInt32(sqlCommand.ExecuteScalar());
sqlCommand = new SqlCommand("Proc_AddMark", sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@Mark", mark);
sqlCommand.Parameters.AddWithValue("@StudentId", userId);
sqlCommand.Parameters.AddWithValue("@TestId", testId);
int execNonQ = sqlCommand.ExecuteNonQuery();
TrueMessage trueMessageToClient = new TrueMessage();
if (execNonQ == 0)
{
trueMessageToClient.Command = Command.Reject;
}
else
{
trueMessageToClient.Command = Command.Approve;
}
byte[] dataSendMarkAnswer;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToClient);
dataSendMarkAnswer = stream.ToArray();
}
NetworkStream networkStream = tcpClient.GetStream();
networkStream.BeginWrite(dataSendMarkAnswer, 0, dataSendMarkAnswer.Length, new AsyncCallback(SendMarkAnswer), tcpClient);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
if (sqlConnection.State != ConnectionState.Closed)
{
sqlConnection.Close();
}
}
}
private void LogIn(TcpClient tcpClient, TrueMessage trueMessage)
{
Console.WriteLine("LogIn");
string login = trueMessage.Login;
string password = (string)trueMessage.Message;
SqlConnection sqlConnection = new SqlConnection(connectionString);
try
{
if (sqlConnection.State == ConnectionState.Closed)
{
sqlConnection.Open();
}
SqlCommand sqlCommand = new SqlCommand("Proc_SelectUserType", sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@Login", login);
sqlCommand.Parameters.AddWithValue("@Password", password);
string userType = Convert.ToString(sqlCommand.ExecuteScalar());
TrueMessage trueMessageToClient = new TrueMessage();
Console.WriteLine($"UserType: {userType}. Length: {userType.Length}");
if (userType.Length == 0)
{
trueMessageToClient.Command = Command.Reject;
trueMessageToClient.Message = "Username or password is incorrect.";
}
else
{
if (clients.Keys.Contains(login))
{
trueMessageToClient.Message = "This user is already logged in!";
}
else
{
trueMessageToClient.Command = Command.Approve;
trueMessageToClient.Message = userType;
}
}
byte[] dataLogInAnswer;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToClient);
dataLogInAnswer = stream.ToArray();
}
NetworkStream networkStream = tcpClient.GetStream();
networkStream.BeginWrite(dataLogInAnswer, 0, dataLogInAnswer.Length, new AsyncCallback(LogInAnswer), tcpClient);
Console.WriteLine("LogInEnd");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
sqlConnection.Close();
}
}
private void AddTest(TcpClient tcpClient, TrueMessage trueMessage)
{
Console.WriteLine($"AddTest");
SqlConnection sqlConnection = new SqlConnection(connectionString);
try
{
if (sqlConnection.State == ConnectionState.Closed)
{
sqlConnection.Open();
}
TestDLL.Test test = (TestDLL.Test)trueMessage.Message;
string path = test.Name;
string invalid = new string(Path.GetInvalidFileNameChars()) + new string(Path.GetInvalidPathChars());
foreach (char c in invalid)
{
path = path.Replace(c.ToString(), "");
}
path = "..\\..\\..\\Tests\\" + path + ".xml";
TrueMessage trueMessageToClient = new TrueMessage();
Random random = new Random();
while (File.Exists(path))
{
path += random.Next(1, 100);
}
TrueXmlSerializer.Save(test, path);
SqlCommand sqlCommand = new SqlCommand("Proc_AddTest", sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@Name", test.Name);
sqlCommand.Parameters.AddWithValue("@Description", test.Description);
sqlCommand.Parameters.AddWithValue("@Path", path);
sqlCommand.ExecuteNonQuery();
trueMessageToClient.Command = Command.Approve;
trueMessageToClient.Message = test.Name;
byte[] dataAddTestAnswer;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToClient);
dataAddTestAnswer = stream.ToArray();
}
NetworkStream networkStream = tcpClient.GetStream();
networkStream.BeginWrite(dataAddTestAnswer, 0, dataAddTestAnswer.Length, new AsyncCallback(AddTestAnswer), tcpClient);
Console.WriteLine($"AddTest ended");
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
if (sqlConnection.State != ConnectionState.Closed)
{
sqlConnection.Close();
}
}
}
private void AdminConnect(TcpClient tcpClient, TrueMessage trueMessage)
{
string login = trueMessage.Login;
IPEndPoint clientEP = (IPEndPoint)tcpClient.Client.RemoteEndPoint;
clients.Add(login, clientEP);
Console.WriteLine($"Admin {login} connected");
SqlConnection sqlConnection = new SqlConnection(connectionString);
try
{
if (sqlConnection.State == ConnectionState.Closed)
{
sqlConnection.Open();
}
SqlCommand sqlCommand = new SqlCommand("Proc_LoadUsers", sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
List <UserLW> users = new List <UserLW>();
using (SqlDataReader sqlReader = sqlCommand.ExecuteReader())
{
while (sqlReader.Read())
{
users.Add(new UserLW
{
Login = Convert.ToString(sqlReader["Login"]),
Password = Convert.ToString(sqlReader["Password"]),
FullName = Convert.ToString(sqlReader["FullName"]),
UserType = Convert.ToString(sqlReader["Type"])
});
}
}
TrueMessage trueMessageToClient = new TrueMessage();
if (users.Count <= 0)
{
trueMessageToClient.Command = Command.Reject;
}
else
{
trueMessageToClient.Command = Command.Approve;
trueMessageToClient.Message = users.ToArray();
}
byte[] dataAdminConnectAnswer;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToClient);
dataAdminConnectAnswer = stream.ToArray();
}
NetworkStream networkStream = tcpClient.GetStream();
networkStream.BeginWrite(dataAdminConnectAnswer, 0, dataAdminConnectAnswer.Length, new AsyncCallback(AdminConnectAnswer), tcpClient);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
if (sqlConnection.State != ConnectionState.Closed)
{
sqlConnection.Close();
}
}
}
private void AddUser(TcpClient tcpClient, TrueMessage trueMessage)
{
Console.WriteLine("AddUser");
SqlConnection sqlConnection = new SqlConnection(connectionString);
try
{
if (sqlConnection.State == ConnectionState.Closed)
{
sqlConnection.Open();
}
UserLW newUser = (UserLW)trueMessage.Message;
SqlCommand sqlCommand = new SqlCommand("Proc_LoginAvailabilityCheck", sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@Login", newUser.Login);
int count = Convert.ToInt32(sqlCommand.ExecuteScalar());
TrueMessage trueMessageToClient = new TrueMessage();
if (count == 1)
{
Console.WriteLine("AddUserReject Login exists");
trueMessageToClient.Command = Command.Reject;
trueMessageToClient.Message = "User with that login already exists";
}
else
{
sqlCommand = new SqlCommand("Proc_GetUserTypeId", sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@UserType", newUser.UserType);
int userTypeId = Convert.ToInt32(sqlCommand.ExecuteScalar());
if (userTypeId == 0)
{
Console.WriteLine("AddUserReject wrong UserType");
trueMessageToClient.Command = Command.Reject;
trueMessageToClient.Message = "Wrong UserType";
}
else
{
Console.WriteLine("AddUserApprove");
sqlCommand = new SqlCommand("Proc_AddUser", sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@Login", newUser.Login);
sqlCommand.Parameters.AddWithValue("@Password", newUser.Password);
sqlCommand.Parameters.AddWithValue("@FullName", newUser.FullName);
sqlCommand.Parameters.AddWithValue("@UserTypeId", userTypeId);
sqlCommand.ExecuteNonQuery();
trueMessageToClient.Command = Command.Approve;
}
}
byte[] dataAddUserAnswer;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToClient);
dataAddUserAnswer = stream.ToArray();
}
NetworkStream networkStream = tcpClient.GetStream();
networkStream.BeginWrite(dataAddUserAnswer, 0, dataAddUserAnswer.Length, new AsyncCallback(AddUserAnswer), tcpClient);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
if (sqlConnection.State != ConnectionState.Closed)
{
sqlConnection.Close();
}
}
}
private void UpdateMarks(TcpClient tcpClient, TrueMessage trueMessage)
{
Console.WriteLine($"UpdateMarks");
SqlConnection sqlConnection = new SqlConnection(connectionString);
try
{
if (sqlConnection.State == ConnectionState.Closed)
{
sqlConnection.Open();
}
string testName = (string)trueMessage.Message;
List <MarkLW> marks = new List <MarkLW>();
SqlCommand sqlCommand = new SqlCommand("Proc_GetMarksByTestName", sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Parameters.AddWithValue("@Name", testName);
using (SqlDataReader sqlReader = sqlCommand.ExecuteReader())
{
while (sqlReader.Read())
{
marks.Add(new MarkLW
{
FullName = Convert.ToString(sqlReader["FullName"]),
Mark = Convert.ToInt32(sqlReader["Mark"])
});
}
}
TrueMessage trueMessageToClient = new TrueMessage();
if (marks.Count <= 0)
{
trueMessageToClient.Command = Command.Reject;
}
else
{
trueMessageToClient.Command = Command.Approve;
trueMessageToClient.Message = marks.ToArray();
}
byte[] dataUpdateMarksAnswer;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToClient);
dataUpdateMarksAnswer = stream.ToArray();
}
NetworkStream networkStream = tcpClient.GetStream();
networkStream.BeginWrite(dataUpdateMarksAnswer, 0, dataUpdateMarksAnswer.Length, new AsyncCallback(UpdateMarksAnswer), tcpClient);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
if (sqlConnection.State != ConnectionState.Closed)
{
sqlConnection.Close();
}
}
}
private void TeacherConnect(TcpClient tcpClient, TrueMessage trueMessage)
{
string login = trueMessage.Login;
IPEndPoint clientEP = (IPEndPoint)tcpClient.Client.RemoteEndPoint;
clients.Add(login, clientEP);
Console.WriteLine($"Teacher {login} connected");
SqlConnection sqlConnection = new SqlConnection(connectionString);
try
{
if (sqlConnection.State == ConnectionState.Closed)
{
sqlConnection.Open();
}
List <string> testNames = new List <string>();
SqlCommand sqlCommand = new SqlCommand("Proc_GetTestNames", sqlConnection);
sqlCommand.CommandType = CommandType.StoredProcedure;
using (SqlDataReader sqlReader = sqlCommand.ExecuteReader())
{
while (sqlReader.Read())
{
testNames.Add(Convert.ToString(sqlReader["Name"]));
}
}
TrueMessage trueMessageToClient = new TrueMessage();
if (testNames.Count <= 0)
{
trueMessageToClient.Command = Command.Reject;
}
else
{
trueMessageToClient.Command = Command.Approve;
trueMessageToClient.Message = testNames.ToArray();
}
byte[] dataTeacherConnectAnswer;
IFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
formatter.Serialize(stream, trueMessageToClient);
dataTeacherConnectAnswer = stream.ToArray();
}
NetworkStream networkStream = tcpClient.GetStream();
networkStream.BeginWrite(dataTeacherConnectAnswer, 0, dataTeacherConnectAnswer.Length, new AsyncCallback(TeacherConnectAnswer), tcpClient);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
if (sqlConnection.State != ConnectionState.Closed)
{
sqlConnection.Close();
}
}
}
private void ReadMessage(IAsyncResult ar)
{
Console.WriteLine("123 ReadMessage");
(TcpClient tcpClient, byte[] dataReadMessage)stateReadMessage = ((TcpClient tcpClient, byte[] dataReadMessage))ar.AsyncState;
TcpClient tcpClient = stateReadMessage.tcpClient;
byte[] dataReadMessage = stateReadMessage.dataReadMessage;
NetworkStream stream = tcpClient.GetStream();
int byteLenght = stream.EndRead(ar);
if (byteLenght > 0)
{
IFormatter formatter = new BinaryFormatter();
TrueMessage trueMessage = new TrueMessage();
using (MemoryStream memoryStream = new MemoryStream(dataReadMessage))
{
trueMessage = (TrueMessage)formatter.Deserialize(memoryStream);
}
if (trueMessage.Command == Command.LogIn)
{
LogIn(tcpClient, trueMessage);
}
else if (trueMessage.Command == Command.AdminConnect)
{
AdminConnect(tcpClient, trueMessage);
}
else if (trueMessage.Command == Command.AddUser)
{
AddUser(tcpClient, trueMessage);
}
else if (trueMessage.Command == Command.DeleteUser)
{
DeleteUser(tcpClient, trueMessage);
}
else if (trueMessage.Command == Command.Disconnect)
{
string login = trueMessage.Login;
clients.Remove(login);
Console.WriteLine($"User {login} disconnected");
}
else if (trueMessage.Command == Command.TeacherConnect)
{
TeacherConnect(tcpClient, trueMessage);
}
else if (trueMessage.Command == Command.UpdateMarks)
{
UpdateMarks(tcpClient, trueMessage);
}
else if (trueMessage.Command == Command.AddTest)
{
AddTest(tcpClient, trueMessage);
}
else if (trueMessage.Command == Command.DeleteTest)
{
DeleteTest(tcpClient, trueMessage);
}
else if (trueMessage.Command == Command.ChooseCurrentTest)
{
ChooseCurrentTest(tcpClient, trueMessage);
}
else if (trueMessage.Command == Command.StudentConnect)
{
StudentConnect(tcpClient, trueMessage);
}
else if (trueMessage.Command == Command.LoadCurrentTest)
{
LoadCurrentTest(tcpClient, trueMessage);
}
else if (trueMessage.Command == Command.SendMark)
{
SendMark(tcpClient, trueMessage);
}
Console.WriteLine("456 COMMAND: " + trueMessage.Command.ToString());
byte[] dataReadMessageNew = new byte[64000];
(TcpClient tcpClient, byte[] dataReadMessageNew)stateReadMessageNew = (tcpClient, dataReadMessageNew);
stream.BeginRead(dataReadMessageNew, 0, dataReadMessageNew.Length, new AsyncCallback(ReadMessage), stateReadMessageNew);
}
}
