/// <summary>
/// Submits the user's answers
/// </summary>
/// <param name="userID">The ID of the user</param>
/// <param name="testID">The ID of the test</param>
/// <param name="answers">The list of answers that belongs to the user</param>
public static async Task SubmitUsersAnswersAsync(int userID, int testID, List <int> answers)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
// Fetch the questions for the test
List <Question> questions = await multipleChoiceEntities.Questions
.Where(x => x.Test_ID == testID)
.ToListAsync();
// Submit the test to the DB
for (int i = 0; i < answers.Count; i++)
{
multipleChoiceEntities.Answers.Add(new Answer()
{
Question_ID = questions[i].Question_ID,
User_ID = userID,
User_Answer = answers[i]
});
}
await multipleChoiceEntities.SaveChangesAsync();
// Submit mark
multipleChoiceEntities.Marks.Add(new Mark()
{
User_ID = userID,
Test_ID = testID,
User_Mark = GetMark(userID, testID)
});
await multipleChoiceEntities.SaveChangesAsync();
}
}
/// <summary>
/// Adds a new test
/// </summary>
/// <param name="test">The test to add</param>
public static void AddTest(Test test)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
multipleChoiceEntities.Tests.Add(test);
multipleChoiceEntities.SaveChanges();
}
}
/// <summary>
/// Retrieves how many questions are in the test
/// </summary>
/// <param name="testID">The ID of the test</param>
public static int GetTestSize(int testID)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
return(multipleChoiceEntities.Questions
.CountAsync(x => x.Test_ID == testID).Result);
}
}
/// <summary>
/// Gets a question from the specific test
/// </summary>
/// <param name="testID">The ID of the test</param>
/// <param name="questionID">The ID of the question</param>
public static Question GetQuestion(int testID, int questionID)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
return(multipleChoiceEntities.Questions
.FirstOrDefault(x => x.Test_ID == testID && x.Question_ID == questionID));
}
}
/// <summary>
/// Gets the ID of the test
/// </summary>
/// <param name="test">The test to get the ID of</param>
public int GetTestID(Test test)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
return(multipleChoiceEntities.Tests
.Find(test).Test_ID);
}
}
/// <summary>
/// Removes a question
/// </summary>
/// <param name="question">The question to remove</param>
public void RemoveQuestion(Question question)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
multipleChoiceEntities.Questions.Remove(question);
multipleChoiceEntities.SaveChanges();
}
}
/// <summary>
/// Returns the test with the specified ID
/// </summary>
/// <param name="testID">The ID of the test</param>
public Test GetTest(int testID)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
return(multipleChoiceEntities.Tests
.FirstOrDefault(x => x.Test_ID == testID));
}
}
/// <summary>
/// Removes a test
/// </summary>
/// <param name="test">The test to remove</param>
public void RemoveTest(Test test)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
multipleChoiceEntities.Tests.Remove(test);
multipleChoiceEntities.SaveChanges();
}
}
/// <summary>
/// Adds a new question to a test
/// </summary>
/// <param name="question">The question to add to the test</param>
/// <param name="testID">The ID of the test</param>
public static void AddQuestion(Question question, int testID)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
question.Test_ID = testID;
multipleChoiceEntities.Questions.Add(question);
multipleChoiceEntities.SaveChanges();
}
}
/// <summary>
/// Retrieves all the tests in the database
/// </summary>
public static async Task <List <Test> > GetAllTestsAsync()
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
List <Test> tests = await multipleChoiceEntities.Tests.ToListAsync();
return(tests);
}
}
/// <summary>
/// Retrieves the total marks a test is worth
/// </summary>
/// <param name="testID">The ID of the test</param>
public static int GetTotalMarks(int testID)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
var questions = multipleChoiceEntities.Questions
.Where(x => x.Test_ID == testID).ToList();
return(questions.Count == 0 ? 0 : questions.Sum(x => x.Points));
}
}
/// <summary>
/// Retrieves the test's name
/// </summary>
/// <param name="testID">The ID of the test</param>
public static string GetTestName(int testID)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
return(multipleChoiceEntities.Tests
.FirstOrDefault(x => x.Test_ID == testID)
.Name);
}
}
/// <summary>
/// Gets all the questions for the specific test
/// </summary>
/// <param name="testID">The ID of the test</param>
public static List <Question> GetQuestions(int testID)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
Test test = multipleChoiceEntities.Tests
.FirstOrDefaultAsync(x => x.Test_ID == testID).Result;
return(test.Questions.ToList());
}
}
/// <summary>
/// Removes a question
/// </summary>
/// <param name="question">The question to remove</param>
public static void RemoveQuestion(int questionID)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
Question entity = multipleChoiceEntities.Questions.FirstOrDefault(x => x.Question_ID == questionID);
multipleChoiceEntities.Questions.Remove(entity);
multipleChoiceEntities.SaveChanges();
}
}
/// <summary>
/// Sets the user type eg. Student or Lecture
/// </summary>
/// <param name="ID">The ID of the user</param>
/// <param name="value">The value to assign to the type</param>
public static void SetType(int ID, string value)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
multipleChoiceEntities.Users.FirstOrDefault(x => x.User_ID == ID)
.Type = value;
multipleChoiceEntities.SaveChangesAsync();
}
}
/// <summary>
/// Gets the amount of points a question is worth
/// </summary>
/// <param name="questionID">The ID of the question</param>
/// <param name="testID">The ID of the test</param>
public int GetPoints(int questionID, int testID)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
return(multipleChoiceEntities.Questions
.FirstOrDefault(x => x.Question_ID == questionID && x.Test_ID == testID)
.Points);
}
}
/// <summary>
/// Checks if the credentials match
/// </summary>
/// <param name="ID">The ID of the user</param>
/// <param name="password">The user's password</param>
/// <returns>True if the ID and password match</returns>
public static bool CredentialsMatch(int ID, string password)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
return(multipleChoiceEntities.Users
.Any(e => e.User_ID == ID &&
e.Password == password));
}
}
/// <summary>
/// Retrieves the user with the specified ID.
/// NB - Altered data will NOT be saved.
/// </summary>
/// <param name="userID">The ID of the user</param>
/// <returns>A user</returns>
public static User GetUser(int userID)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
User user = multipleChoiceEntities.Users
.FirstOrDefault(x => x.User_ID == userID);
return(user);
}
}
/// <summary>
/// Sets the name of the test to the value
/// </summary>
/// <param name="testID">The ID of the test</param>
/// <param name="value">The value to assign to the test</param>
public static void SetTestName(int testID, string value)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
multipleChoiceEntities.Tests
.FirstOrDefault(x => x.Test_ID == testID)
.Name = value;
multipleChoiceEntities.SaveChanges();
}
}
/// <summary>
/// Gets all the tests that the user has already written
/// </summary>
/// <param name="userID">The ID of the user</param>
public static async Task <List <Test> > GetTestsUserHasWrittenAsync(int userID)
{
List <Test> writtenTests;
using (MultipleChoiceEntities multipleChoice = new MultipleChoiceEntities())
{
writtenTests = await LoadWrittenTestsAsync(userID, multipleChoice);
}
return(writtenTests);
}
/// <summary>
/// Gets the user's answer at a specific index
/// </summary>
/// <param name="userID">The ID of the user</param>
/// <param name="questionID">The ID of the question</param>
public static int GetUserAnswerAtIndex(int userID, int questionID)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
return(multipleChoiceEntities.Answers
.FirstOrDefaultAsync(x => x.User_ID == userID && x.Question_ID == questionID)
.Result
.User_Answer);
}
}
/// <summary>
/// Sets choice B to the value specified
/// </summary>
/// <param name="questionID">The ID of the question</param>
/// <param name="testID">The ID of the test</param>
/// <param name="value">The value to assign</param>
public static void SetChoiceB(int questionID, int testID, string value)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
multipleChoiceEntities.Questions
.FirstOrDefault(x => x.Question_ID == questionID && x.Test_ID == testID)
.ChoiceB = value;
multipleChoiceEntities.SaveChanges();
}
}
/// <summary>
/// Checks if the credentials match async
/// </summary>
/// <param name="ID">The ID of the user</param>
/// <param name="password">The user's password</param>
/// <returns>True if the ID and password match</returns>
public static async Task <bool> CredentialsMatchAsync(int ID, string password)
{
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
User user = await multipleChoiceEntities
.Users
.Where(x => x.User_ID == ID && x.Password == password)
.FirstOrDefaultAsync();
return(user != null);
}
}
/// <summary>
/// Gets all the tests that the user has not written
/// </summary>
/// <param name="userID">The ID of the user</param>
public static async Task <List <Test> > GetTestsUserHasNotWrittenAsync(int userID)
{
List <Test> unwrittenTests;
using (MultipleChoiceEntities multipleChoice = new MultipleChoiceEntities())
{
// Loads all the written tests
var writtenTests = await LoadWrittenTestsAsync(userID, multipleChoice);
// Get the tests the student hasn't written
unwrittenTests = LoadUnwrittenTests(writtenTests, multipleChoice);
}
return(unwrittenTests);
}
/// <summary>
/// Returns a list of tests the user has not written
/// </summary>
private static List <Test> LoadUnwrittenTests(
IEnumerable <Test> writtenTests, MultipleChoiceEntities multipleChoice)
{
List <Test> unwrittenTests = multipleChoice.Tests.ToListAsync().Result;
foreach (Test test in writtenTests)
{
if (unwrittenTests.Contains(test))
{
unwrittenTests.Remove(test);
}
}
return(unwrittenTests);
}
/// <summary>
/// Gets the mark a student got for a test
/// </summary>
/// <param name="userID">The ID of the user</param>
/// <param name="testID">The ID of the test</param>
/// <returns>The student's mark</returns>
public static int GetMark(int userID, int testID)
{
int mark;
using (MultipleChoiceEntities multipleChoiceEntities = new MultipleChoiceEntities())
{
List <Question> questions = multipleChoiceEntities.Tests
.FirstOrDefaultAsync(x => x.Test_ID == testID)
.Result?.Questions
.ToList();
// Get all the answers for the specific test the user wrote
List <Answer> answers = LoadAnswersFromTest(userID, questions);
// Calculate user's mark
mark = CalculateMark(questions, answers);
}
return(mark);
}
/// <summary>
/// Returns a list of tests the user has not written
/// </summary>
private static async Task <List <Test> > LoadWrittenTestsAsync(int userID, MultipleChoiceEntities multipleChoice)
{
List <Test> writtenTests = new List <Test>();
// Get all the tests the student has written
List <Answer> answers = await multipleChoice.Answers
.Where(x => x.User_ID == userID)
.ToListAsync();
// Add written tests to a list
foreach (Answer answer in answers)
{
if (!writtenTests.Contains(answer.Question.Test))
{
writtenTests.Add(answer.Question.Test);
}
}
return(writtenTests);
}
