/// <summary>
/// Retrieves the exam data from the given filters.
/// </summary>
/// <param name="userFilter">An SQL query.</param>
/// <returns>A DataTable with the full Data.</returns>
public DataTable ExportDataExam(string filter)
{
FullDataTable = new DataTable();
ColumnTitles = new List <string>();
string sql = "SELECT IdUserExam FROM UserExam";
sql = Common.StrAdd(sql, " WHERE ", filter);
string[] idUserExamList = Common.CSVToArray(Common.GetBDList("IdUserExam", sql, false));
FullDataTable.Columns.Add("usr_name", typeof(string));
ColumnTitles.Add(Text.FullName);
FullDataTable.Columns.Add("exam_name", typeof(string));
ColumnTitles.Add(Text.Exam);
FullDataTable.Columns.Add("exam_date", typeof(string));
ColumnTitles.Add(Text.DateTime);
FullDataTable.Columns.Add("exam_status", typeof(string));
ColumnTitles.Add(Text.Status);
FullDataTable.Columns.Add("exam_score", typeof(double));
ColumnTitles.Add(Text.Score);
foreach (string idUserExam in idUserExamList)
{
var row = FullDataTable.NewRow();
UserExam userExam = new UserExam(Convert.ToInt32(idUserExam));
User user = new User(userExam.IdUser);
Exam exam = new Exam(userExam.IdExam);
row["usr_name"] = user.FullName(true);
row["exam_name"] = exam.ExamName;
row["exam_date"] = userExam.DateComplete;
row["exam_status"] = UserExamStatus.FriendlyText(userExam.Status);
row["exam_score"] = String.Format("{0:0.00}", userExam.Score);
FullDataTable.Rows.Add(row);
}
return(FullDataTable);
}
public async Task <IActionResult> AddUserToExamAsync(int userId, int examId, [FromBody] string password)
{
if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
{
return(Unauthorized());
}
var examFromRepo = await _repo.ExamRepository.GetExamAsync(examId);
if (!password.VerifyPasswordHash(examFromRepo.PasswordHash, examFromRepo.PasswordSalt))
{
return(Unauthorized());
}
if (examFromRepo == null)
{
return(NotFound("Exam not exists"));
}
var userExam = new UserExam
{
UserId = userId,
ExamId = examId
};
_repo.UserExamRepository.Add(userExam);
if (await _repo.SaveAllAsync())
{
return(CreatedAtRoute("GetEnrolledExamsForUserAsync", new { userId = userId }, userExam));
}
return(BadRequest("Failed to add user to exam"));
}
private async Task CalculateStuScore(string stuID, int examID)
{
try
{
var answerList = await this.GetStuAnswerListAsync(examID, stuID);
var totalScore = 0;
foreach (var an in answerList)
{
if (an.Mark != null)
{
totalScore += an.Mark.Value;
}
}
var ueToUpdate = new UserExam()
{
UserId = stuID,
ExamId = examID,
Mark = totalScore
};
await this.UpdateStuExamAsync(ueToUpdate);
await this.AddExamGradedEventAsync(ueToUpdate);
}
catch (Exception e)
{
logger.LogError(e.Message);
throw new Exception("Action Failed!");
}
}
public void QuizTest(List <AnswerView> yourAnswers)
{
List <AnswerView> finalResultQuiz = new List <AnswerView>();
int right = 0;
float score = 0;
foreach (AnswerView answser in yourAnswers)
{
AnswerView result = questionService.GetResult(answser);
finalResultQuiz.Add(result);
if (result.IsCorrect)
{
right++;
}
}
score = ((float)right / (float)finalResultQuiz.Count) * 10;
string subject = (string)HttpContext.Session.GetString(SessionSubject);
string user = (string)HttpContext.Session.GetString(SessionUser);
User userModel = userService.GetUserByName(user);
Subject subjectModel = subjectService.GetSubjectByName(subject);
UserExam userExam = new UserExam {
Score = score,
UserId = userModel.UserId,
SubjectId = subjectModel.SubjectId
};
if (ModelState.IsValid)
{
userExamService.CreateUserExam(userExam);
}
}
private ExamTotal FinishExam(UserExam currentUserExam)
{
DateTime examStartTime = SessionCache.GetExamStartTime();
ExamTotal examTotal = null;
SessionCache.ClearExamSessionInfo();
if (currentUserExam.EndDate == DateTime.MinValue || ACTION_FINISH_RESULT == Action)
{
if (ACTION_FINISH_RESULT == Action)
{
currentUserExam.TotalTime = ConfigReader.ExamLengthInMinutes * 60;
}
else
{
currentUserExam.TotalTime = DateTime.Now.Subtract(examStartTime).Seconds;
}
currentUserExam.EndDate = DateTime.Now;
userExamManager.SaveOrUpdateSavedQuestion(null, currentUserExam);
examTotal = userExamManager.ProcessResult(ExamSessionID);
}
else
{
examTotal = userExamManager.GetExamTotal(ExamSessionID);
}
return examTotal;
}
private void ListView_ItemClick(object sender, ItemClickEventArgs e)
{
UserExam userExam = new UserExam();
userExam.student = _student;
userExam.exam = (Exam)e.ClickedItem;
this.Frame.Navigate(typeof(TakeExam), userExam);
}
public IActionResult Edit(UserExam UserExam)
{
if (ModelState.IsValid)
{
userExamService.Update(UserExam);
return(RedirectToAction("Index"));
}
return(View());
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
viewModel = new TakeExamViewModel();
UserExam us = new UserExam();
us = (UserExam)e.Parameter;
_student = us.student;
_exam = us.exam;
CurrentTestQuestion(questionIndex);
}
public async Task <int> SolveExam(ExamQuestions examQuestion, string name)
{
var exam = this.repository.FirstOrDefault(exam => exam.YearOfCreation == examQuestion.YearOfCreation);
var points = 0;
for (int i = 0; i < exam.Questions.Count; i++)
{
var correct = exam.Questions[i].CorrectAnswer - 1;
var answer = examQuestion?.Questions[i].Answers.Where(a => a.IsSelected == true).FirstOrDefault();
var actual = Array.IndexOf(examQuestion.Questions[i].Answers.ToArray(), answer);
if (correct == actual)
{
points++;
}
}
var user = await this.userManager.FindByNameAsync(name);
var userExam = new UserExam()
{
ExamId = exam.Id, UserId = user.Id
};
if (user.UserExams.FirstOrDefault(x => x.UserId == user.Id) == null && user.UserExams.FirstOrDefault(x => x.ExamId == exam.Id) == null)
{
userExam = new UserExam()
{
ExamId = exam.Id, UserId = user.Id, Points = points
};
user.UserExams.Add(userExam);
await this.repository.SaveChangesAsync();
}
else if (user.UserExams.FirstOrDefault(x => x.UserId == user.Id) != null && user.UserExams.FirstOrDefault(x => x.ExamId == exam.Id) != null)
{
userExam.Points = Math.Max(userExam.Points, points);
var userExamFromDb = user.UserExams.FirstOrDefault(x => x.UserId == user.Id && x.ExamId == exam.Id);
userExamFromDb.Points = Math.Max(points, userExamFromDb.Points);
await this.repository.SaveChangesAsync();
}
return(points);
}
public async Task <ApiResponse <bool> > EnrollUserExam(UserExamViewModel userExam)
{
var result = new ApiResponse <bool>();
try
{
var oUserExam = await dbContext.UserExams
.FirstOrDefaultAsync(e => (e.ExamId == userExam.ExamId && e.ApplicationUserId == this.CurrentUser().Id)) as UserExam;
if (oUserExam == null)
{
var userExamd = new UserExam
{
ApplicationUserId = this.CurrentUser().Id,
ExamId = userExam.ExamId,
Status = userExam.Status,
StartDate = userExam.StartDate,
EndDate = userExam.EndDate,
Score = userExam.Score
};
await dbContext.UserExams.AddAsync(userExamd);
await dbContext.SaveChangesAsync();
result.Data = true;
result.AddSuccess();
result.AddMessage("You are Enrolled Succesfully");
return(await Task.FromResult(result));
}
else
{
result.Data = false;
result.AddMessage("You have already been enrolled successfully");
return(await Task.FromResult(result));
}
}
catch (Exception ex)
{
result.AddError(ex);
return(await Task.FromResult(result));
}
}
private async Task UpdateStuExamAsync(UserExam ue)
{
try
{
var cmd = this.sqlConnection.CreateCommand();
cmd.CommandType = System.Data.CommandType.Text;
cmd.CommandText = "update user_exam set mark = @mark where exam_id = @exam_id and user_id = @user_id";
cmd.Parameters.Add("@exam_id", MySqlDbType.Int32);
cmd.Parameters.Add("@user_id", MySqlDbType.VarChar);
cmd.Parameters.Add("@mark", MySqlDbType.Int32);
cmd.Parameters["@exam_id"].Value = ue.ExamId;
cmd.Parameters["@user_id"].Value = ue.UserId;
cmd.Parameters["@mark"].Value = ue.Mark;
await cmd.ExecuteNonQueryAsync();
}
catch (Exception e)
{
logger.LogError(e.Message);
throw new Exception("Action Failed!");
}
}
public async Task <ActionResult <Exam> > PostExam(Exam exam, int userId)
{
var userExam = new UserExam()
{
Exam = exam, UserId = userId
};
var examQuestions = exam.Questions
.Select(q => new ExamQuestion
{
QuestionId = q.QuestionId,
Exam = exam
}).ToList();
exam.Questions.Clear();
_context.UserExam.Add(userExam);
_context.ExamQuestion.AddRange(examQuestions);
_context.Exam.Add(exam);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetExam", new { id = exam.ExamId }, exam));
}
private async Task AddExamGradedEventAsync(UserExam ue)
{
try
{
var exam = await this.GetExamAsync(ue.ExamId);
var e = new Event()
{
EventType = EventType.ExamGraded,
Content = JsonConvert.SerializeObject(new { Id = exam.ID, Title = exam.Title, Score = ue.Mark.Value }),
CourseID = exam.CourseID,
CourseName = await this.GetCourseNameAsync(exam.CourseID),
RelatedUser = ue.UserId,
Time = DateTime.Now
};
await this.AddEventAsync(e);
}
catch (Exception e)
{
logger.LogError(e.Message);
throw new Exception("Action Failed!");
}
}
public async Task CreateUserAnswerAsync_ExamAuthorRequest_ReturnsBadRequestResult()
{
var user = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, "1"),
}));
var exam = new Exam
{
AuthorId = 1
};
var userExam = new UserExam
{
Exam = exam
};
var mapperMock = new Mock <IMapper>();
var repositoryMock = new Mock <IRepositoryWrapper>();
repositoryMock.Setup(r => r.UserExamRepository.GetUserWithExamAsync(It.IsAny <int>(), It.IsAny <int>())).ReturnsAsync(userExam);
repositoryMock.Setup(r => r.UserExamRepository.Update(It.IsAny <UserExam>()));
repositoryMock.Setup(r => r.UserAnswerRepository.Add(It.IsAny <UserAnswer>()));
repositoryMock.Setup(r => r.SaveAllAsync()).ReturnsAsync(true);
mapperMock.Setup(m => m.Map <IEnumerable <UserAnswer> >(It.IsAny <IEnumerable <UserAnswersForCreationDto> >())).Returns(new List <UserAnswer>());
var controllerMock = new ExamsController(repositoryMock.Object, mapperMock.Object);
controllerMock.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = user
}
};
var result = await controllerMock.CreateUserAnswersAsync(1, new List <UserAnswersForCreationDto>());
Assert.IsType <BadRequestObjectResult>(result);
}
public void Update(UserExam entity)
{
_userExamDAL.Update(entity);
}
private void PopulateResultSummary(ExamTotal examTotal, UserExam currentUserExam)
{
if (examTotal != null)
{
int totalQuestions = examTotal.CountOfQuestionID;
int totalCorrect = examTotal.SumOfCorrect;
double percentCorrect = Math.Round((float)totalCorrect / (float)totalQuestions * 100, 2);
int avgTime = currentUserExam.TotalTime / totalQuestions;
lblTotalQuestions.Text = totalQuestions.ToString();
lblTotalCorrectAnswers.Text = totalCorrect.ToString();
lblPercentCorrectAnswers.Text = string.Format("{0}%", percentCorrect.ToString());
lblAvgTimePerQuestion.Text = avgTime.ToString();
lblTotalTime.Text = currentUserExam.TotalTime.ToString();
}
else
{
IList < QuestionForExamType > questions = SessionCache.Instance.GetExamQuestionsForExamType(currentUserExam.ExamID);
lblTotalQuestions.Text = questions.Count.ToString();
}
}
public void CreateUserExam(UserExam userExam)
{
userExamRepository.Add(userExam);
SaveUserExam();
}
private bool LoadParams()
{
ExamID = WebUtil.GetRequestParamValueInInt(AppConstants.QueryString.EXAM_ID);
ExamSessionID = WebUtil.GetRequestParamValueInInt(AppConstants.QueryString.EXAM_SESSION_ID);
ExamKey = WebUtil.GetRequestParamValueInString(AppConstants.QueryString.EXAM_KEY);
Action = WebUtil.GetRequestParamValueInString(AppConstants.QueryString.EXAM_ACTION);
int clear = WebUtil.GetRequestParamValueInInt("Clear");
if(clear == 1)
{
SessionCache.ClearExamSessionInfo();
}
if (Action == ACTION_CONTINUE_EXAM)
{
if (ExamSessionID == 0) return false;
if (ExamID == 0)
{
currentUserExam = userExamManager.Get(ExamSessionID);
if (currentUserExam.UserID != SessionCache.CurrentUser.Author_ID)
{
Response.Redirect("~/Error.aspx?ErrorCode=1");
return false;
}
if (currentUserExam.EndDate != DateTime.MinValue)
{
Response.Redirect("ExamResult.aspx?ExamSessionID=" + ExamSessionID);
}
ExamID = currentUserExam.ExamID;
}
}
else if (Action == ACTION_NEW_EXAM)
{
if (ExamID == 0)
{
return false;
}
}
else if(Action == ACTION_EXAM_FINISHED)
{
currentUserExam = userExamManager.Get(ExamSessionID);
ExamID = currentUserExam.ExamID;
return true;
}
else
{
return false;
}
return true;
}
private UserExam CreateNewExamSessionForUser()
{
UserExam userExam = new UserExam();
userExam.StartDate = DateTime.Now;
userExam.UserID = SessionCache.CurrentUser.Author_ID;
userExam.ExamID = ExamID;
userExamManager.SaveOrUpdate(userExam);
return userExam;
}
protected void Page_Load(object sender, EventArgs e)
{
Response.Expires = -1;
//SessionCache.ClearExamSessionInfo();
if (!LoadParams())
{
//If required parameters are not supplied, redirect to Error page
Response.Redirect("~/Error.aspx?ErrorCode=3");
return;
}
if (IsTimerElapsed())
{
//If time is over, save current answer and redirect to the result page
SaveAnswer(null,true);
Response.Redirect("ExamResult.aspx?Action=Finish&ExamSessionID=" + ExamSessionID);
return;
}
if (!IsPostBack)
{
//This is the first hit in the exam page
string examKey = WebUtil.GetExamKeyForExamType(ExamID);
if (SessionCache.ExamOngoing)
{
//If an active exam is already ongoing
if (examKey != SessionCache.CurrentExamKey)
{
//If the ongoing exam's key does not match with the current exam key,
//Redirect user to the error page
Response.Redirect("~/Error.aspx?ErrorCode=2");
return;
}
}
ClearCheckBoxes();
if (Action == ACTION_NEW_EXAM)
{
//If this is a new exam request, create a new Exam session
currentUserExam = CreateNewExamSessionForUser();
//Set the current examSessionID into the view state
SessionCache.SetCurrentExamSessionID((int)currentUserExam.Id);
//And redirect to continue mode
Response.Redirect(string.Format("Exam.aspx?Action=Continue&ExamSessionID={0}", currentUserExam.Id));
return;
}
else
{
//Start the exam if no exam is ongoing at this moment
if (!SessionCache.ExamOngoing)
{
//The exam has just started. So, set the exam key in the session
SessionCache.CurrentExamKey = examKey;
//Also, put the exam started flag in the session
SessionCache.ExamOngoing = true;
//An exam will always start with question no 1
QuestionNo = 1;
BookmarkedQuestionNo = 1;
SessionCache.AnsweredQuestionCount = 0;
//Set current question no in the ViewState
SessionCache.SetCurrentQuestionNo(QuestionNo);
SessionCache.SetBookmarkedCurrentQuestionNo(BookmarkedQuestionNo);
//Set exam start time in the Session
if (ConfigReader.RememberProgress != 1)
{
//If Remember progress is not enabled for the the Exam Sessions,
//Delete existing info and clear the Exam session information
currentUserExam.TotalTime = 0;
userExamManager.SaveOrUpdate(currentUserExam);
DeleteExistingExamInfo();
SessionCache.SetExamStartTime(DateTime.Now);
}
else
{
//Obtain the saved answer record
IList<ExamSaved> savedQuestions = userExamManager.GetSavedExamsByExamSessionID(currentUserExam.ExamSessionID);
SessionCache.SetCurrentQuestionNo(savedQuestions.Count + 1);
QuestionNo = savedQuestions.Count + 1;
SessionCache.SetExamStartTime(DateTime.Now.AddSeconds(-1 * currentUserExam.TotalTime));
}
//Set current exam session id into the viewstate
SessionCache.SetCurrentExamSessionID(ExamSessionID);
}
else
{
QuestionNo = SessionCache.GetCurrentQuestionNo();
ExamSessionID = SessionCache.GetCurrentExamSessionID();
if (ConfigReader.RememberProgress == 1 && !SessionCache.ExamOngoing)
{
IList<ExamSaved> savedQuestions = userExamManager.GetSavedExamsByExamSessionID(currentUserExam.ExamSessionID);
SessionCache.SetCurrentQuestionNo(savedQuestions.Count + 1);
QuestionNo = savedQuestions.Count + 1;
SessionCache.SetExamStartTime(DateTime.Now.AddSeconds(-1 * currentUserExam.TotalTime));
}
}
}
PopulateQuestion();
}
else
{
QuestionNo = SessionCache.GetCurrentQuestionNo();
ExamSessionID = SessionCache.GetCurrentExamSessionID();
SessionCache.SetDateTimeInfoForCurrentQuestion();
}
StartCountDown();
}
public void Update(int?id, UserExam obj)
{
DB.Entry(obj).State = EntityState.Modified;
DB.SaveChanges();
}
private async Task <string> InitializeTests()
{
_databaseContext = DatabaseContextGenerator.GenerateDbContext();
_databaseContext.Database.EnsureCreated();
_userManagerTest = UserManagerGenerator.GenerateUserManager();
var userViewModel = InitProfessor();
var result = await _userManagerTest.CreateAsync(new User
{
Email = userViewModel.Email.ToLower(),
UserName = userViewModel.Email.ToLower(),
FirstName = userViewModel.FirstName,
LastName = userViewModel.LastName
}, userViewModel.Password);
if (!result.Succeeded)
{
throw new System.Exception("Operation error");
}
_professor = await _userManagerTest.FindByEmailAsync(userViewModel.Email);
userViewModel = InitStudent();
result = await _userManagerTest.CreateAsync(new User
{
Email = userViewModel.Email.ToLower(),
UserName = userViewModel.Email.ToLower(),
FirstName = userViewModel.FirstName,
LastName = userViewModel.LastName
}, userViewModel.Password);
if (!result.Succeeded)
{
throw new System.Exception("Operation error");
}
_student = await _userManagerTest.FindByEmailAsync(userViewModel.Email);
_courseRepository = new CourseRepository(_databaseContext);
_course = InitCourse();
_databaseContext.Courses.Add(_course);
_databaseContext.SaveChanges();
var professorCourse = new UserCourse
{
UserId = _professor.Id,
CourseId = _course.Id
};
_databaseContext.UserCourses.Add(professorCourse);
_databaseContext.SaveChanges();
_classroom = InitClassroom();
_databaseContext.Classrooms.Add(_classroom);
_databaseContext.SaveChanges();
_examRepository = new ExamRepository(_databaseContext);
_exam = InitExam();
_exam.CourseId = _course.Id;
_databaseContext.Exams.Add(_exam);
_databaseContext.SaveChanges();
var studentExam = new UserExam()
{
UserId = _student.Id,
ExamId = _exam.Id
};
_databaseContext.UserExams.Add(studentExam);
return("Success");
}
public void Update(UserExam userExam)
{
userExamRepository.Edit(userExam);
SaveUserExam();
}
public void Delete(UserExam userExam)
{
userExamRepository.Delete(userExam);
SaveUserExam();
}
public void Delete(UserExam entity)
{
entity.IsActive = false;
_userExamDAL.Update(entity);
}
public void Add(UserExam entity)
{
_userExamDAL.Add(entity);
}
public async void Add(UserExam obj)
{
await DB.UserExam.AddAsync(obj);
DB.SaveChanges();
}
