public IActionResult SetOpenedQuestionsAnswers(IFormCollection AnswersForm)
{
try
{
var QuestionUserAnswer = new Dictionary <string, string>();
foreach (var key in AnswersForm)
{
if (!key.Equals(AnswersForm.Last()))
{
QuestionUserAnswer.Add(key.Key, key.Value);
}
}
var exID = HttpContext.Session.GetInt32("ExamID");
using (var context = new ExamPlatformDbContext())
{
List <ExamOpenedQuestions> UserAnswers = SetUserAnswers(context, QuestionUserAnswer, exID);
UserAnswers.ForEach(x => context.ExamOpenedQuestions.Update(x));
context.SaveChanges();
return(View("ExamFinished"));
}
}
catch (Exception ex)
{
logger.Error("ExamsController - SetOpenedQuestionsAnswers " + ex.Message);
return(View());
}
}
/// <summary>Sets the user answers in dictionary<Key,Value></summary>
/// <param name="context">The context.</param>
/// <param name="QuestionsAndUserAnswersFromExam">The questions and user answers from exam.</param>
/// <param name="examID">The exam identifier.</param>
/// <returns></returns>
public List <ExamOpenedQuestions> SetUserAnswers(ExamPlatformDbContext context, Dictionary <string, string> QuestionsAndUserAnswersFromExam, int?examID)
{
try
{
var QuestionsFromDB = (from x in context.ExamOpenedQuestions
where x.ExamsID == examID && x.OpenedQuestionsID == x.OpenedQuestions.OpenedQuestionsID
select new { ExamOpenedQuestionObject = x, OpenedQuestionObject = x.OpenedQuestions })
.ToDictionary(z => z.OpenedQuestionObject, t => t.ExamOpenedQuestionObject);
foreach (var singleQuestion in QuestionsFromDB)
{
foreach (var questionAndAnswerExam in QuestionsAndUserAnswersFromExam)
{
if (singleQuestion.Key.Question == questionAndAnswerExam.Key)
{
singleQuestion.Value.UserAnswer = questionAndAnswerExam.Value;
}
}
}
return(QuestionsFromDB.Values.ToList());
}
catch (Exception ex)
{
logger.Error("ExamsController - SetUserAnswers " + ex.Message);
return(null);
}
}
public IActionResult CheckLoginDetails(Accounts account)
{
try {
account.Password = HashPass(account.Password);
using (var context = new ExamPlatformDbContext())
{
var selectedAccount = (from accounts
in context.Account
where accounts.Username == account.Username && accounts.Password == account.Password
select accounts).Single();
int amountOfUncheckedExams = (from exams in context.Exam
where exams.ExamResult.Grade == null
select exams).ToList().Count();
HttpContext.Session.SetInt32("UserID", selectedAccount.AccountsID);
if (selectedAccount.Status == "STUDENT")
{
return(View("LogIn", selectedAccount));
}
else
{
return(View("AdminLogIn", amountOfUncheckedExams));
}
}
}
catch (Exception ex)
{
logger.Error("AccountsController - CheckLoginDetails. " + ex.Message);
return(View("LoginError"));
}
}
/// <summary>Navigates to main page, depends on type of user Admin/Student</summary>
/// <returns></returns>
public IActionResult NavigateToMainPage()
{
var accountID = HttpContext.Session.GetInt32("UserID");
using (var context = new ExamPlatformDbContext())
{
if (accountID != null)
{
var SelectedAccount = (from account
in context.Account
where account.AccountsID == accountID
select account).First();
int amountOfUncheckedExams = (from exams in context.Exam
where exams.ExamResult.Grade == null
select exams).ToList().Count();
if (SelectedAccount.Status == "STUDENT")
{
return(View("LogIn", SelectedAccount));
}
else if (SelectedAccount.Status == "ADMIN")
{
return(View("AdminLogIn", amountOfUncheckedExams));
}
}
return(View("UserSignUp"));
}
}
/// <summary>Sends the email with informations associated with results of exams for each students.</summary>
/// <param name="ExamIDList">The exam identifier list.</param>
/// <param name="context">The context.</param>
public ActionResult SendEmail(IFormCollection StudentData)
{
using (var context = new ExamPlatformDbContext())
{
try
{
String getGrade = StudentData.ElementAt(5).Value;
String withoutZero = getGrade.Substring(0, 1);
double grade = Convert.ToDouble(withoutZero);
String getScore = StudentData.ElementAt(6).Value;
double score = Convert.ToDouble(getScore);
String getDate = StudentData.ElementAt(3).Value;
DateTime date = Convert.ToDateTime(getDate);
String maxExamScore = StudentData.ElementAt(7).Value;
double maxScore = Convert.ToDouble(maxExamScore);
UserEmailInfoModel user = new UserEmailInfoModel
(
StudentData.ElementAt(0).Value,
StudentData.ElementAt(1).Value,
StudentData.ElementAt(2).Value,
StudentData.ElementAt(4).Value,
grade,
date,
score,
maxScore
);
JObject messageTemplate = RenderMessageTemplateFromFile();
Dictionary <string, string> emailAccount = GetEmailAccountFromDB();
var purveyed = sendMessage(emailAccount, user, messageTemplate);
var studentResult = context.Exam
.Include(e => e.ExamResult)
.Include(a => a.Account)
.Where(e =>
e.DateOfExam.Date == user.ExamDate.Date &&
e.DateOfExam.Hour == user.ExamDate.Hour &&
e.DateOfExam.Minute == user.ExamDate.Minute)
.Select(z => z.ExamResult).ToList();
studentResult.First().ifResultSent = purveyed;
context.Results.Update(studentResult.First());
context.SaveChanges();
}
catch (Exception ex)
{
logger.Error("StudentExamsController - SendEmail " + ex.Message);
}
return(RedirectToAction("ShowAllCheckedExams"));
}
}
public ActionResult ShowStudentExamsToCheck()
{
try
{
using (var context = new ExamPlatformDbContext())
{
var data = context.Exam
.Include(e => e.ExamResult)
.Include(e => e.ExamOpenedQuestions)
.ThenInclude(e => e.OpenedQuestions)
.Include(e => e.ExamClosedQuestions)
.Include(a => a.Account)
.Where(e => e.ExamResult.Grade == null)
.Select(z => z).ToList();
List <SingleStudentExamModel> singleModelList = new List <SingleStudentExamModel>();
List <StudentExamsModel> modelList = new List <StudentExamsModel>();
foreach (var StudentAccount in data)
{
singleModelList.Clear();
foreach (var ExamOpenQuestions in StudentAccount.ExamOpenedQuestions)
{
singleModelList.Add(
new SingleStudentExamModel
(
ExamOpenQuestions.ExamOpenedQuestionsID,
ExamOpenQuestions.OpenedQuestions.Question,
ExamOpenQuestions.UserAnswer,
ExamOpenQuestions.OpenedQuestions.MaxPoints
)
);
}
modelList.Add(
new StudentExamsModel
(
StudentAccount.ExamsID,
StudentAccount.Account.AccountsID,
StudentAccount.Account.Name,
StudentAccount.Account.Surname,
new List <SingleStudentExamModel>(singleModelList)
));
}
return(View("StudentExamsList", modelList));
}
}
catch (Exception ex)
{
logger.Error("StudentExamsController - ShowStudentExamsToCheck " + ex.Message);
return(View());
}
}
public IActionResult SetNewAccountIntoDatabase(Accounts NewAccount)
{
try
{
bool ifNewUsernameExistInDB(String usernameFromUserLoginToCheck, List <Accounts> accountsListFromDB)
{
foreach (Accounts account in accountsListFromDB)
{
if (account.Username == usernameFromUserLoginToCheck)
{
return(true);
throw new Exception("The username is occupied");
}
}
return(false);
}
string newUsername = NewAccount.Username;
using (var context = new ExamPlatformDbContext())
{
var accountsList = (from securityAccount
in context.Account
select securityAccount).ToList();
if (!ifNewUsernameExistInDB(newUsername, accountsList))
{
NewAccount.Username = newUsername;
NewAccount.Password = HashPass(NewAccount.Password);
context.Account.Add(NewAccount);
context.SaveChanges();
HttpContext.Session.SetInt32("UserID", NewAccount.AccountsID);
return(View("LogIn", NewAccount));
}
else
{
return(View("RegisterError"));
}
}
}
catch (Exception ex)
{
logger.Error("AccountsController - SetNewAccountIntoDatabase " + ex.Message);
return(View());
}
}
public IActionResult SetClosedQuestionsAnswers(IFormCollection AnswersForm)
{
try
{
var QuestionAnswer = new Dictionary <string, string>();
foreach (var key in AnswersForm)
{
if (!key.Equals(AnswersForm.Last()))
{
QuestionAnswer.Add(key.Key, key.Value);
}
}
var exID = HttpContext.Session.GetInt32("ExamID");
using (var context = new ExamPlatformDbContext())
{
var examCQuestions = (from ex
in context.ExamClosedQuestions
where ex.ExamsID == exID
select ex.ClosedQuestions).ToList();
Results examResults = (from ex
in context.Results
where ex.ExamID == exID
select ex).Single();
examResults = SetExamScoreFromClosedQuestionAnswers(examCQuestions, QuestionAnswer, examResults);
context.Results.Update(examResults);
context.SaveChanges();
var examQuestions = context.OpenedQuestion
.Where(q => q.ExamOpenedQuestions.All(x => x.ExamsID == exID))
.Select(q => q).ToList();
return(RedirectToAction("ShowOpenedQuestions"));
}
}
catch (Exception ex)
{
logger.Error("ExamsController - SetClosedQuestionsAnswers " + ex.Message);
return(View());
}
}
public IActionResult ShowCourses()
{
try
{
using (var context = new ExamPlatformDbContext())
{
var CoursesFromDB = context.Course.GroupBy(c => c.CourseType).Select(c => c.First()).ToList();
CoursesViewModel model = new CoursesViewModel()
{
Courses = CoursesFromDB.ToList()
};
return(View("Courses", model));
}
} catch (Exception ex)
{
logger.Error("CourseController - ShowCourses " + ex.Message);
return(View());
}
}
public IActionResult ShowOpenedQuestions()
{
try
{
var exID = HttpContext.Session.GetInt32("ExamID");
using (var context = new ExamPlatformDbContext())
{
var openedQuestions = context.ExamOpenedQuestions
.Where(q => q.ExamsID == exID)
.Select(o => o.OpenedQuestions).ToList();
return(View("ExamOpenedQuestions", openedQuestions));
}
}
catch (Exception ex)
{
logger.Error("ExamsController - ShowOpenedQuestions " + ex.Message);
return(View());
}
}
/// <summary>Gets the email account from database and return.</summary>
/// <returns></returns>
private Dictionary <string, string> GetEmailAccountFromDB()
{
Dictionary <string, string> emailAccount = new Dictionary <string, string>();
try
{
using (var context = new ExamPlatformDbContext())
{
var emailSecureData = (from x in context.EmailAccount
where x.EmailAccountID == 1
select new { x.EmailDomain, x.EmailAccountPassword }).Single();
emailAccount.Add("domain", emailSecureData.EmailDomain);
emailAccount.Add("emailPass", emailSecureData.EmailAccountPassword);
return(emailAccount);
}
}
catch (Exception ex)
{
logger.Error("StudentExamsController - RenderEmailAccount " + ex.Message);
return(emailAccount);
}
}
public IActionResult ShowAllCheckedExams()
{
try
{
using (var context = new ExamPlatformDbContext())
{
var UserEmail = (from ex in context.Exam
where ex.ExamResult.Grade != null
join results in context.Results on ex.ExamResult.ExamID equals results.ExamID
join account in context.Account on ex.AccountID equals account.AccountsID
select new { account.Name, account.Surname, account.Email, ex.Course.CourseType, results.Grade, ex.DateOfExam, results.Score, results.MaxExamPoints, results.ifResultSent }).ToList();
List <UserEmailInfoModel> modelList = new List <UserEmailInfoModel>();
UserEmail.ForEach(x =>
modelList.Add(new UserEmailInfoModel
(
x.Name,
x.Surname,
x.Email,
x.CourseType,
x.Grade,
x.DateOfExam,
x.Score,
x.MaxExamPoints,
x.ifResultSent
))
);
return(View("ExamsResults", modelList));
}
}
catch (Exception ex)
{
logger.Error("StudentExamsController - ShowAllCheckedExams " + ex.Message);
return(View());
}
}
public ActionResult SetPointsForOpenedQuestionsToStudent(IFormCollection AnswerPoint)
{
try
{
var StudentExamModel = new Dictionary <string, List <string> >();
var Results = new Dictionary <int, double>();
foreach (var x in AnswerPoint)
{
List <String> valueList = new List <string>();
if (!x.Equals(AnswerPoint.Last()))
{
foreach (var value in x.Value)
{
if (x.Key == "AnswerPoints" && value.Length == 0)
{
TempData["Message"] = "Nie wszystkie odpowiedzi studenta otrzymały odpowiednią punktację";
return(RedirectToAction("ShowStudentExamsToCheck"));
}
valueList.Add(value);
}
StudentExamModel.Add(x.Key, valueList);
}
}
List <int> ExamOpenedQuestionIDList = new List <int>();
List <double> ResultsList = new List <double>();
List <int> ExamsID = new List <int>();
StudentExamModel.ElementAt(1).Value.ForEach(x => ExamOpenedQuestionIDList.Add(Int32.Parse(x)));
StudentExamModel.ElementAt(4).Value.ForEach(
x => ResultsList.Add(double.Parse(x.Replace(".", ","))));
StudentExamModel.ElementAt(0).Value.ForEach(x => ExamsID.Add(Int32.Parse(x)));
ExamsID = ExamsID.Distinct().ToList();
for (int i = 0; i < ResultsList.Count(); i++)
{
Results.Add(ExamOpenedQuestionIDList[i], ResultsList[i]);
}
using (var context = new ExamPlatformDbContext())
{
List <ExamOpenedQuestions> ExamOQuestionList = new List <ExamOpenedQuestions>();
foreach (var x in Results)
{
var ExamOpenedQuestionModel = (from z in context.ExamOpenedQuestions
where z.ExamOpenedQuestionsID == x.Key
select z).Single();
ExamOpenedQuestionModel.AnswerPoints = x.Value;
ExamOQuestionList.Add(ExamOpenedQuestionModel);
}
context.ExamOpenedQuestions.UpdateRange(ExamOQuestionList);
context.SaveChanges();
foreach (var examID in ExamsID)
{
var score = (from x in context.ExamOpenedQuestions
where x.ExamsID == examID
select x.AnswerPoints).ToList();
var result = (from r in context.Results
where r.ExamID == examID
select r).Single();
score.ForEach(x => result.Score += x.Value);
result.Grade = SetExamGrade(result.Score, result.MaxExamPoints);
context.Results.Update(result);
context.SaveChanges();
}
}
return(RedirectToAction("ShowStudentExamsToCheck"));
}
catch (Exception ex)
{
logger.Error("StudentExamsController - SetPointsForOpenedQuestionsToStudent " + ex.Message);
return(View());
}
}
public async Task <ActionResult> ShowExam(int courseID)
{
var accountID = HttpContext.Session.GetInt32("UserID");
using (var context = new ExamPlatformDbContext())
{
try
{
Accounts SelectedAccount = await context.Account
.Where(a => a.AccountsID == accountID)
.Select(a => a).SingleAsync();
Course SelectedCourse = await context.Course
.Include(c => c.ClosedQuestionsList)
.Include(q => q.OpenedQuestionsList)
.Where(course => course.CourseID == courseID)
.Select(seleceteCourse => seleceteCourse).SingleAsync();
var CQuestions = SelectedCourse.ClosedQuestionsList.DistinctBy(q => q.Question).ToList();
var OQuestions = SelectedCourse.OpenedQuestionsList.DistinctBy(q => q.Question).ToList();
CQuestions = SelectClosedQuestions(CQuestions, 7);
OQuestions = SelectOpenedQuestions(OQuestions, 6);
var ExamCQuestions = CreateExamClosedQuestions(CQuestions);
var ExamOQuestions = CreateExamOpenedQuestions(OQuestions);
Exams exam = new Exams()
{
AmountClosedQuestions = CQuestions.Count(),
AmountOpenedQuestions = OQuestions.Count(),
ExamTimeInMinute = 30,
DateOfExam = DateTime.Now,
ExamClosedQuestions = ExamCQuestions,
ExamOpenedQuestions = ExamOQuestions,
CourseID = SelectedCourse.CourseID,
AccountID = SelectedAccount.AccountsID,
ExamResult = new Results()
{
ifResultSent = false
}
};
ExamCQuestions.ForEach(x => exam.ExamResult.MaxExamPoints += 1);
ExamOQuestions.ForEach(x => exam.ExamResult.MaxExamPoints += x.OpenedQuestions.MaxPoints);
context.Exam.Add(exam);
context.SaveChanges();
HttpContext.Session.SetInt32("ExamID", exam.ExamsID);
return(View("ExamClosedQuestions", exam));
}
catch (Exception ex)
{
logger.Error("ExamsController - ShowExam " + ex.Message);
return(View());
}
}
}
