public ActionResult AttemptQuiz(QuizAttempt quizAttempt)
{
var name = Session["username"];
if (name != null)
{
quizAttempt.Learner = _db.Users.Where(u => u.Username == (String)name).FirstOrDefault();
quizAttempt.AttemptTime = DateTime.Now;
quizAttempt.Quiz = _db.Quizs.Where(q => q.QuizID == quizAttempt.QuizID).FirstOrDefault();
quizAttempt.OfferedCourse = _db.OfferedCourses.Where(o => o.OfferedCourseID == quizAttempt.OfferedCourseID).FirstOrDefault();
var arr = quizAttempt.Answers.Split(new String[] { "!#!#!" }, StringSplitOptions.RemoveEmptyEntries);
var questions = quizAttempt.Quiz.Questions.ToList();
var i = 0;
quizAttempt.Marks = 0;
foreach (var q in questions)
{
if (q.Answer == arr[i])
{
quizAttempt.Marks++;
}
i++;
}
_db.QuizAttempts.Add(quizAttempt);
_db.SaveChanges();
var offeredCourseId = quizAttempt.OfferedCourseID;
TempData["msg"] = "Quiz Submitted Successfully";
return(RedirectToAction("ViewDetails", "Learner", new { offeredCourseId }));
}
return(RedirectToAction("Index", "Default"));
}
private async Task <UserQuizAnswer> ExecuteQueryGetUserAnswerByAttempt(QuizAttempt quizAttempt)
{
UserQuizAnswer userQuizAnswer = new UserQuizAnswer();
using (SqlConnection connection = GetConnection())
{
connection.Open();
SqlCommand command = CreateCommand($"SELECT * FROM [dbo].[UserAnswer] " +
$"JOIN [dbo].[Answer] ON Answer.id = UserAnswer.answer_id WHERE" +
$" [UserAnswer].quiz_attempt_id = {quizAttempt.Id}", connection);
using (SqlDataReader reader = command.ExecuteReader())
{
if (reader.HasRows)
{
userQuizAnswer.UserAnswers = new List <Answer>();
while (reader.Read())
{
Answer answer = new Answer();
answer.AnswerText = reader.GetStringByName("answer_text");
answer.Id = reader.GetInt32ByName("answer_id");
answer.IsRight = reader.GetBoolByName("is_right");
answer.QuestionId = reader.GetInt32ByName("question_id");
(userQuizAnswer.UserAnswers as List <Answer>).Add(answer);
}
}
}
}
return(userQuizAnswer);
}
private void PerQuestionSave()
{
var answers = new List <Answer>();
foreach (var questionSave in _session.QuestionSaves)
{
var answer = _helper.ExamineQuestion(
_cx.Questions.Find(questionSave.Key),
questionSave.Value.Answer);
answers.Add(answer);
}
_attempt.Mark = _helper.ExamineQuiz(_attempt.Quiz, answers, _session);
_cx.QuizAttempts.Add(_attempt);
foreach (var item in answers)
{
item.Attempt = _attempt;
}
_cx.Answers.AddRange(answers);
_cx.SaveChanges();
Attempt = _attempt;
}
public QuizAttemptVM(QuizAttempt qa)
{
this.QuizId = qa.QuizId;
this.Timestamp = qa.Timestamp;
this.QuestionsAnswered = qa.QuestionsAnswered.Select(a => new QuestionAttemptVM(a));
this.CorrectAnswers = this.QuestionsAnswered.Count(q => q.IsCorrect);
}
private async Task ExecuteQueryInsertQuizAttemptAndUserAnswers(QuizAttempt quizAttempt, string email)
{
using (SqlConnection connection = GetConnection())
{
connection.Open();
User user = await usersRepository.GetUserByEmail(email);
quizAttempt.UserId = user.ID;
//insert quiz attempt
SqlCommand command = CreateCommand($"INSERT INTO [dbo].[QuizAttempt](" +
$"quiz_id, user_id, start_time, end_time" +
$") VALUES ({quizAttempt.Quiz.ID}, {quizAttempt.UserId}," +
$"'{quizAttempt.StartDateTime.ToString("yyyy-MM-dd HH:mm:ss.fff")}', '{quizAttempt.EndDateTime.ToString("yyyy-MM-dd HH:mm:ss.fff")}') SELECT @@IDENTITY AS ID", connection);
using (SqlDataReader sqlDataReader = command.ExecuteReader())
{
sqlDataReader.Read();
quizAttempt.Id = (int)sqlDataReader.GetDecimalByName("ID");
}
//insert user answers
if (quizAttempt.UserQuizAnswer.UserAnswers != null)
{
foreach (var answer in quizAttempt.UserQuizAnswer.UserAnswers)
{
command = CreateCommand($"INSERT INTO [dbo].[UserAnswer](quiz_attempt_id," +
$"question_id, answer_id) VALUES ({quizAttempt.Id}, {answer.QuestionId}, {answer.Id})", connection);
command.ExecuteNonQuery();
}
}
}
}
public ActionResult SaveAttemp(int?id)
{
var quiz = cx.Quizzes.Find(id);
var testSave = (TestSave)Session["save"];
quiz = cx.Quizzes.Find(quiz.Id);
var attemp = new QuizAttempt()
{
Quiz = quiz,
Time = DateTime.Now,
User = cx.Users.Find(UserManager.FindByName(User.Identity.Name).Id),
Type = (AttempType)Session["AttemptType"],
};
if (attemp.Type == AttempType.ByGroup)
{
attemp.Group = cx.Groups.Find((int)Session["GroupId"]);
}
var saver = new AttemptSaver(testSave, cx, attemp, helper);
attemp = saver.Attempt;
return(RedirectToAction("GetAttepmt", "Cabinet", new { id = attemp.Id }));
}
public void QuizAttemptConstructor()
{
var attempt = new QuizAttempt
{
Id = 8,
UserId = 23,
QuizId = 55,
Status = QuizAttemptStatus.Passed,
StartDate = new DateTime(2020, 3, 4),
EndDate = new DateTime(2020, 4, 4),
TimeSpent = 88,
Correct = 4,
Incorrect = 5,
Score = 90.5M
};
Assert.AreEqual(8, attempt.Id);
Assert.AreEqual(23, attempt.UserId);
Assert.AreEqual(55, attempt.QuizId);
Assert.AreEqual(QuizAttemptStatus.Passed, attempt.Status);
Assert.AreEqual(new DateTime(2020, 3, 4), attempt.StartDate);
Assert.AreEqual(new DateTime(2020, 4, 4), attempt.EndDate);
Assert.AreEqual(88, attempt.TimeSpent);
Assert.AreEqual(4, attempt.Correct);
Assert.AreEqual(5, attempt.Incorrect);
Assert.AreEqual(90.5M, attempt.Score);
}
/// <summary>
///
/// </summary>
/// <param name="attempt"></param>
/// <param name="passScore"></param>
/// <param name="timeSpent"></param>
/// <returns></returns>
public async Task <bool> FinishQuizAsync(QuizAttempt attempt, int?passScore, int timeSpent)
{
if (attempt.Status != QuizAttemptStatus.Incomplete)
{
return(false);
}
var questions = (await questionManager.GetQuizQuestions(attempt.UserId, attempt.QuizId)).ToList();
var options = (from qq in Context.QuizQuestions
join q in Context.Questions on qq.QuestionId equals q.Id
join o in Context.Options on q.Id equals o.QuestionId
join a in Context.Answers on new { AttemptId = attempt.Id, QuestionId = q.Id, OptionId = q.Id } equals new { a.AttemptId, a.QuestionId, a.OptionId } into ad
from a in ad.DefaultIfEmpty()
where qq.QuizId == attempt.QuizId
select new QuestionAnswer {
QuestionId = q.Id, IsCorrect = o.IsCorrect, IsMarked = a != null
}
).ToList();
var evaluationResult = EvaluateQuiz(questions, options);
attempt.Score = evaluationResult.Score;
attempt.Correct = evaluationResult.CorrectCount;
attempt.Incorrect = evaluationResult.IncorrectCount;
attempt.Status = EvaluateStatus(evaluationResult.Score, passScore);
attempt.EndDate = DateTime.Now;
attempt.TimeSpent = timeSpent;
Context.QuizAttempts.Update(attempt);
await Context.SaveChangesAsync();
return(true);
}
private async Task <IEnumerable <QuizAttempt> > ExecuteQueryQuizAttemptsByEmail(string email)
{
User user = await usersRepository.GetUserByEmail(email);
IEnumerable <QuizAttempt> quizAttempts = new List <QuizAttempt>();
using (SqlConnection connection = GetConnection())
{
connection.Open();
SqlCommand command = CreateCommand($"SELECT qa.id, qa.quiz_id," +
$" qa.start_time, qa.end_time FROM [dbo].[QuizAttempt] qa WHERE qa.[user_id] = {user.ID}", connection);
using (SqlDataReader reader = command.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
QuizAttempt quizAttempt = new QuizAttempt();
quizAttempt.Id = reader.GetInt32ByName("id");
quizAttempt.StartDateTime = reader.GetDateTimeByName("start_time");
quizAttempt.EndDateTime = reader.GetDateTimeByName("end_time");
quizAttempt.Quiz = new Quiz();
quizAttempt.Quiz.ID = reader.GetInt32ByName("quiz_id");
quizAttempt.Quiz = await quizRepository.GetQuizById(quizAttempt.Quiz.ID);
quizAttempt.UserId = user.ID;
(quizAttempts as List <QuizAttempt>).Add(quizAttempt);
}
}
else
{
throw new QuizAttemptsNotFound();
}
}
if (quizAttempts != null)
{
// throw new QuizAttemptsNotFound();
foreach (var quizAttempt in quizAttempts)
{
try
{
// quizAttempt.Quiz = await quizRepository.GetQuizById(quizAttempt.Quiz.ID);
}
catch (QuizNotFoundException)
{
throw new QuizAttemptsNotFound();
}
quizAttempt.UserQuizAnswer = await ExecuteQueryGetUserAnswerByAttempt(quizAttempt);
}
}
}
return(quizAttempts);
}
public async Task PutError(HttpStatusCode expected, CreateAttemptResult result)
{
var attempt = new QuizAttempt();
var actual = await ExecutePut(2, 5, new CreateAttemptResponse
{
Attempt = attempt,
Result = result
});
Assert.AreEqual(expected, (HttpStatusCode)actual.StatusCode);
}
public async Task <IActionResult> WriteResult([FromBody] QuizAttempt quizAttempt, [FromQuery] string email)
{
try
{
await statsService.InsertQuizAttempt(quizAttempt, email);
return(Ok());
}
catch (Exception e)
{
return(StatusCode(500));
}
}
public async Task Put()
{
var attempt = new QuizAttempt();
var result = await ExecutePut(2, 5, new CreateAttemptResponse
{
Attempt = attempt,
Result = CreateAttemptResult.Success
});
var resultObject = (QuizAttempt)result.Value;
Assert.AreSame(attempt, resultObject);
}
private int Score(QuizAttempt quizAttempt)
{
var correct = 0;
foreach (var answer in quizAttempt.Answers)
{
if (quizAttempt.Quiz.Questions.First(e => e.QuestionID == answer.QuestionID).CorrectAnswer.AnswerID == answer.AnswerID)
{
correct++;
}
}
return(correct);
}
public async Task Post()
{
var attempt = new QuizAttempt();
var actual = await ExecutePost(2, 5, new UpdateQuizAttemptStatus(),
new UpdateQuizAttemptResponse
{
Attempt = attempt,
Result = UpdateQuizAttemptStatusResult.Success
});
var resultObject = (QuizAttempt)actual.Value;
Assert.AreSame(attempt, resultObject);
}
private bool _Filter(QuizAttempt attempt)
{
if (_QuizFilter(attempt, Quiz) &&
_UserFilter(attempt, User) &&
_MinLimitFilter(attempt, MinLimit) &&
_MaxLimitFilter(attempt, MaxLimit) &&
_GroupFilter(attempt, Group) &&
_MinMarkFilter(attempt, MinMark) &&
_MaxMarkFilter(attempt, MaxMark) &&
_IsOnlyMine(attempt, IsOnlyMine, CurrentUser))
{
return(true);
}
return(false);
}
private QuizViewModel.QuizAnswers MapQuizAttempt(QuizAttempt data)
{
var quizAnswers = new QuizViewModel.QuizAnswers();
quizAnswers.QuizID = data.QuizID;
foreach (var answer in data.Answers)
{
var questionAnswer = new QuizViewModel.QuestionAnswer();
questionAnswer.AnswerID = (int)answer.AnswerID;
questionAnswer.QuestionID = (int)answer.QuestionID;
quizAnswers.Answers.Add(questionAnswer);
}
return(quizAnswers);
}
public async Task <ActionResult <QuizAttempt> > PostQuizAttempt(int id, QuizAttempt quizAttempt)
{
var userId = HttpContext.User.Claims.First().Value;
quizAttempt.UserId = userId;
var quiz = await _context.Quiz.FindAsync(id);
quizAttempt.QuizId = quiz.QuizId;
quizAttempt.Percentage = (quizAttempt.CorrectAnswers / quizAttempt.TotalQuestions) * 100;
_context.QuizAttempts.Add(quizAttempt);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetQuizAttempt", new { id = quizAttempt.Id }, quizAttempt));
}
public ActionResult PostResult(int quizID, int userID, int score)
{
var quizAttempt = new QuizAttempt
{
quizIDFK = quizID,
score = score,
useridFK = userID
};
db.QuizAttempts.Add(quizAttempt);
try
{
db.SaveChanges();
return(Json(quizAttempt));
}
catch (Exception ex)
{
return(Json(ex));
}
}
public ActionResult Attempt(QuizViewModel.QuizAnswers data)
{
var quiz = db.Quizzes.First(e => e.QuizID == data.QuizID);
var quizAttempt = new QuizAttempt();
quizAttempt.QuizID = quiz.QuizID;
quizAttempt.StudentName = User.Identity.Name;
foreach (var answer in data.Answers)
{
var quizAnswer = new QuizAnswer();
quizAnswer.QuestionID = answer.QuestionID;
quizAnswer.AnswerID = answer.AnswerID;
quizAttempt.Answers.Add(quizAnswer);
}
db.QuizAttempts.Add(quizAttempt);
db.SaveChanges();
return(null);
}
public AttemptSaver(TestSave save,
QuizContext context,
QuizAttempt attempt,
ControllerHelper helper)
{
_cx = context;
_session = save;
_attempt = attempt;
_helper = helper;
if (_attempt.Quiz.TestingType == QuizTestingType.PerSection)
{
PerSectionSave();
}
else if (_attempt.Quiz.TestingType == QuizTestingType.PerQuestion)
{
PerQuestionSave();
}
else
{
throw new NotImplementedException();
}
}
public QuizVM AddAttempt(int quizId, string userId, IEnumerable <QuestionAttemptVM> attempt)
{
var quiz = _context.Quizes.FirstOrDefault(q => q.Id == quizId);
QuizAttempt qa = new QuizAttempt()
{
QuizId = quizId,
UserId = userId,
Timestamp = DateTime.Now,
QuestionsAnswered = attempt.ToList().Select(a => a.ToPoco()).ToList()
};
//if all questions are correct, complete assignment if available
if (!qa.QuestionsAnswered.Any(q => !q.IsCorrect) && quiz.AssignmentId.HasValue)
{
_assignmentRepo.CompleteAssignment(quiz.AssignmentId.Value, userId, true);
}
_context.QuizAttempts.Add(qa);
_context.SaveChanges();
return(this.GetQuiz(quizId, userId));
}
public IActionResult Answer([FromHeader] string authorization, [FromBody] JObject body)
{
var choices = body.Value <String>("choices");
var choiceArr = JsonConvert.DeserializeObject <String[]>(choices);
var urlName = body.Value <String>("urlName");
var userId = _tokenService.getClaimsId(authorization);
if (String.IsNullOrEmpty(urlName))
{
return(BadRequest());
}
else
{
var courseUser = _context.CourseUsers
.Include(x => x.QuizAttempts)
.SingleOrDefault(x => x.Course.UrlName == urlName && x.User.Id == userId);
var attempt = new QuizAttempt();
attempt.SubmissionTime = DateTime.Now;
foreach (var stringId in choiceArr)
{
var id = int.Parse(stringId);
var answer = new Answer()
{
UserChoiceId = id
};
_context.Answers.Add(answer);
_context.SaveChanges();
attempt.Answers.Add(answer);
}
courseUser.QuizAttempts.Add(attempt);
_context.SaveChanges();
_log.LogInformation($"Added quizattempt for for {userId}");
return(Ok());
}
}
public async Task CreateAttempt(QuizAttempt quizAttempt)
{
await _context.Attempts.InsertOneAsync(quizAttempt);
_logger.LogInformation("CreateAttempt success");
}
public async Task InsertQuizAttempt(QuizAttempt quizAttempt, string email)
{
await quizAttemptRepository.InsertQuizAttempt(quizAttempt, email);
}
public JsonResult SaveQuizAttempt(QuizAttemptInModel qA)
{
int id = Int32.Parse(qA.QuizId);
var Quiz = _db.Quizs.Where(s => s.QuizID == id).FirstOrDefault();
var User = _db.Users.Where(s => s.Username == qA.LearnerId).FirstOrDefault();
var offeredCourse = _db.OfferedCourses.Where(s => s.OfferedCourseID == Quiz.offeredCourseID).FirstOrDefault();
if (Quiz == null)
{
return(Json(new ApiResponse
{
Message = "Quiz Not Found",
Status = false,
}, JsonRequestBehavior.AllowGet));
}
if (User == null)
{
return(Json(new ApiResponse
{
Message = "User details not found",
Status = false,
}, JsonRequestBehavior.AllowGet));
}
QuizAttempt QuizAmpt = new QuizAttempt();
QuizAmpt.LearnerID = qA.LearnerId;
QuizAmpt.OfferedCourseID = Quiz.offeredCourseID;
QuizAmpt.AttemptTime = DateTime.Now;
QuizAmpt.Answers = qA.Answers;
QuizAmpt.QuizID = id;
QuizAmpt.Quiz = Quiz;
QuizAmpt.OfferedCourse = offeredCourse;
QuizAmpt.Learner = User;
var arr = QuizAmpt.Answers.Split(new String[] { "!#!#!" }, StringSplitOptions.RemoveEmptyEntries);
var questions = QuizAmpt.Quiz.Questions.ToList();
var i = 0;
QuizAmpt.Marks = 0;
foreach (var q in questions)
{
if (q.Answer == arr[i])
{
QuizAmpt.Marks++;
}
i++;
}
_db.QuizAttempts.Add(QuizAmpt);
_db.SaveChanges();
return(Json(new ApiResponse
{
Message = "Quiz attempted and saved!",
Status = true,
Data = new {
QuizAmpt.Answers,
QuizAmpt.Learner.Username,
QuizAmpt.OfferedCourse.OfferedCourseID,
oc = QuizAmpt.OfferedCourseID,
},
}, JsonRequestBehavior.AllowGet));
}
public async Task InsertQuizAttempt(QuizAttempt quizAttempt, string email)
{
await ExecuteQueryInsertQuizAttemptAndUserAnswers(quizAttempt, email);
}
//[Authorize(Roles = RoleNames.ADMIN)]
public async Task <IActionResult> Post([FromBody] QuizAttempt @attempt)
{
await _attemptRepository.CreateAttempt(@attempt);
return(new OkObjectResult(@attempt));
}
