def test_quiz_completed_datetime_set_on_save(self):
quiz_form = QuizForm(blank_answers=self.quiz_result.answers.all(),
data=self.data)
quiz_form.is_valid()
self.assertEqual(None, self.quiz_result.completed)
quiz_form.save(self.quiz_result)
self.assertNotEqual(None, self.quiz_result.completed)
def view_quiz(qid):
quiz = Quiz.query.filter_by(id=qid).first()
form = QuizForm(request.form, qid=qid)
result = ''
if form.validate_on_submit():
chosen = [int(i) for i in request.form.getlist('quiz_{}'.format(qid))]
result = check_answer(qid, chosen)
return render_template('quiz.html', quiz=quiz, form=form, result=result)
def view_quiz(qid):
quiz = Quiz.query.filter_by(id=qid).first()
form = QuizForm(request.form, qid=qid)
result = ''
if form.validate_on_submit():
chosen = [int(i) for i in request.form.getlist('quiz_{}'.format(qid))]
result = check_answer(qid, chosen)
return render_template('quiz.html', quiz=quiz, form=form, result=result)
def test_questions_marked_as_answered_on_save(self):
quiz_form = QuizForm(blank_answers=self.quiz_result.answers.all(),
data=self.data)
quiz_form.is_valid()
quiz_form.save(self.quiz_result)
# Note: an unanswered question is represented by None
answers = self.quiz_result.answers.all()
for answer in answers:
self.assertNotEqual(None, answer.correct)
def test_invalid_quizForm():
data = {
"title": "",
"description": "Lorem ipsum",
"category": 1,
"sub_category": 1,
"random_order": False,
}
form = QuizForm(data)
assert form.is_valid() is False
def show_quiz(context, quiz):
user = context['request'].user
try:
submission = QuizSubmission.objects.get(quiz=quiz, user=user)
return {
'quiz': quiz,
'form': QuizForm(quiz, submission.choices),
'submittable': False
}
except QuizSubmission.DoesNotExist:
return {'quiz': quiz, 'form': QuizForm(quiz), 'submittable': True}
def quiz():
form = QuizForm()
category = request.args.get('category')
if (category == 'Mixed'):
all_questions = [i.json() for i in Questions.query.all()]
elif (category == 'Random'):
category = choice([
i[0]
for i in db.session.query(Questions.category).distinct().all()
])
all_questions = [
i.json()
for i in Questions.query.filter_by(category=category).all()
]
else:
all_questions = [
i.json()
for i in Questions.query.filter_by(category=category).all()
]
x = max(int(request.args.get('number_of_questions')), 5)
l = len(all_questions)
number_of_questions = x if x < l else l
shuffle(all_questions)
all_questions = all_questions[:number_of_questions]
db.session.commit()
res = Results(score=-number_of_questions,
player=current_user,
category=category,
timestamp=datetime.datetime.now())
db.session.add(res)
db.session.commit()
return (render_template("playquiz.html",
title="Play-Quiz",
form=form,
quiz=all_questions))
def get(self, request, *args, **kwargs):
return self.render_to_response({
'quiz_form':
QuizForm(prefix='quiz-create'),
'category_form':
CategoryForm(prefix='category-create')
})
def quiz_create(request, quiz_id=None, template='quiz/quiz_form.html'):
""" returns a template to create a new quiz. """
quiz_form = QuizForm()
if request.method == "POST":
quiz_form = QuizForm(request.POST)
if quiz_form.is_valid():
quiz = quiz_form.save(commit=False)
quiz.addOwner(request.user).save()
request.user.message_set.create(message="the quiz is successfully created. yeppie! add questions now :D")
return HttpResponseRedirect(reverse('quiz.views.question_create', args=[quiz.id]))
return render_to_response(template, {
"quiz_form" : quiz_form,
"selected_button" : "details",
"pagetitle" : "Make Test",
}, context_instance=RequestContext(request))
def create_quiz(request):
if request.method == 'POST':
form = QuizForm(request.POST or None)
if form.is_valid():
form.save()
return redirect('quiz:quiz-detail', form.instance.id)
else:
form = QuizForm()
context = {'form': form}
return render(request, 'quiz/create-quiz.html', context)
def quiz_create(request):
""" returns a template to create a new quiz. """
if request.method == "POST":
quiz_form = QuizForm(request.POST, request.FILES)
if quiz_form.is_valid():
new_quiz = quiz_form.save(commit=False)
new_quiz.save()
return HttpResponseRedirect(reverse("quiz.views.question_new", args=[new_quiz.id]))
#GET Request
else:
quiz_form = QuizForm()
return render_to_response('quiz/create_quiz.html', {
"quiz_form" : quiz_form,
"selected_button" : "details",
}, context_instance=RequestContext(request))
return render_to_response('quiz/create_quiz.html', {
"quiz_form" : quiz_form,
"selected_button" : "details",
}, context_instance=RequestContext(request))
def quiz():
questions = Question.query.all()
form = QuizForm(request.form)
if request.method == 'POST':
# we are checking if the number of answers in the form data is the same
# as the number of questions in the quiz.
if len(form.answers.entries) == len(questions):
return _render_score_page_(questions)
else:
flash("You must answer all the questions.")
return _render_quiz_page_(form, questions)
def check_answer(request, game_id):
if request.method == 'POST':
result = Result.objects.get(game_id=game_id)
form = QuizForm(request.POST)
if form.is_valid():
question = Question.objects.get(id=request.POST.get('question_id'))
answered_text = request.POST.get('answer_text')
time_completed = request.POST.get('time_completed')
pass_fail = (answered_text == question.answer_set.first().answer_text)
score_card = ScoreCard.objects.create(
question=question,
answered_text=answered_text,
time_completed=time_completed,
pass_fail=pass_fail,
user_id=request.user.id,
result=result
)
msg = "{} {} {} {} {} {}"
if pass_fail:
messages.add_message(request, messages.SUCCESS, msg.format(
'Correct',
score_card.question.question_text,
score_card.question.answer_set.first().answer_text,
score_card.answered_text,
score_card.pass_fail,
score_card.count(question)
))
else:
messages.add_message(request, messages.ERROR, msg.format(
'Incorrect',
score_card.question.question_text,
score_card.question.answer_set.first().answer_text,
score_card.answered_text,
score_card.pass_fail,
score_card.count(question)
))
return redirect('do_quiz', game_id=game_id)
def quiz_update(request, quiz_id=None, template='quiz/quiz_form.html'):
""" update the quiz, given its quiz-id; and the owner. if quiz is not found, throws 404. """
""" @todo:
done: you can update only a test which you can actually own.
todo : admin should also be able to edit any piece of data.
"""
quiz = get_object_or_404(Quiz, id=quiz_id, owner=request.user,)
quiz_form = QuizForm(instance=quiz)
if request.method == "POST":
quiz_form = QuizForm(request.POST, instance=quiz)
if quiz_form.is_valid():
quiz_form.save()
request.user.message_set.create(message="the quiz succesfully updated. yeah! edited.")
return HttpResponseRedirect(reverse("quiz.views.quiz_update", args=[quiz_id]))
return render_to_response(template, {
"quizobj": quiz,
# @todo: must be overridden in the manager.
"questions" : quiz.quiz_questions.all().order_by('number'),
"quiz_form": quiz_form,
"pagetitle" : "Update Test",
"selected_button" : "details",
}, context_instance=RequestContext(request))
def quiz(request, quiz_result_id):
# Fetch quiz results if they exist and redirect if it has already been taken.
quiz_result = get_object_or_404(QuizResult, id=quiz_result_id)
if quiz_result.completed:
messages.error(request, "This quiz has already been completed")
return redirect(reverse('home'))
# Fetch all the blank questions/answers for this quiz, and build the QuizForm
# based on them.
blank_answers = quiz_result.answers.all().order_by('id')
if request.method == 'POST':
form = QuizForm(blank_answers=blank_answers, data=request.POST)
if form.is_valid():
form.save(quiz_result)
messages.success(request, "Thank you for taking the '{0}' quiz!".format(quiz_result.quiz.name))
return redirect(reverse('home'))
else:
form = QuizForm(blank_answers=blank_answers)
return render_to_response('quiz/quiz.html',
{ 'form': form },
context_instance=RequestContext(request))
def index(request):
add_form = QuizForm()
new_form = ''
if request.method == 'POST':
new_form = QuizForm(request.POST)
if new_form.is_valid():
new_form.save(commit=True)
else:
print('ERROR FORM INVALID')
return render(request, 'quiz/home.html', {'add_form': add_form})
def add_quiz(request):
if request.method == 'POST':
form = QuizForm(request.POST)
if form.is_valid():
quiz = form.save()
return redirect('quiz:add_question', quiz.id)
else:
form = QuizForm()
return render(request, 'quiz/add_quiz.html', {'form': form})
def get(self, request: HttpRequest, *args, **kwargs):
user = kwargs.pop('user')
quiz_id = kwargs.get('id')
quiz = get_quiz(quiz_id)
if not quiz:
return HttpResponse(status=404)
questions = get_questions_of_quiz(quiz)
template_name = "quiz/quiz.html"
# template_name = 'quiz/new_try.html'
form = QuizForm(quiz=quiz, user=user)
context = {
'quiz': quiz,
'questions': questions,
'form': form,
'user': user
}
# Set user cookie for anonymous user
return render(request, template_name, context)
def quiz_update(request, quiz_id):
""" update the quiz, given its id. """
quiz = Quiz.objects.get(id=quiz_id)
if request.method == "POST":
quiz_form = QuizForm(request.POST, request.FILES, instance=quiz)
quiz_form.is_update = True
if quiz_form.is_valid():
quiz_form.save()
return HttpResponseRedirect(reverse("quiz.views.quiz_update", args=[quiz_id]))
else:
quiz_form = QuizForm(instance=quiz)
return render_to_response("quiz/update_quiz.html", {
"quiz_form": quiz_form,
"quizobj": quiz,
"selected_button" : "details",
}, context_instance=RequestContext(request))
#generic case
return render_to_response("quiz/update_quiz.html", {
"quiz_form": quiz_form,
"selected_button" : "details",
}, context_instance=RequestContext(request))
def setup_method(self, method):
self.form = QuizForm()
def create(request):
"""
View dedicated to the creation of the quiz using formsets.
The user has to add at least one question for it to be valid.
"""
TF_Formset = formset_factory(CreationTrueFalseForm)
MC_Formset = formset_factory(CreationMultiChoiceForm)
if request.method == "GET":
logger.info("{levelname} {asctime} - User accessed create page")
quiz_form = QuizForm(request.GET or None, prefix="quiz")
tf_formset = TF_Formset(request.GET or None, prefix="tf")
mc_formset = MC_Formset(request.GET or None, prefix="mc")
elif request.method == "POST":
logger.info("{levelname} {asctime} - User wants to create a quiz")
quiz_form = QuizForm(request.POST, prefix="quiz")
tf_formset = TF_Formset(request.POST or None, prefix="tf")
mc_formset = MC_Formset(request.POST or None, prefix="mc")
if quiz_form.is_valid() and ((tf_formset.is_valid()
and mc_formset.is_valid())):
logger.info("{levelname} {asctime} - Quiz is valid")
quiz_cd = quiz_form.cleaned_data
category = Category.objects.get(id=quiz_cd["category"])
category_name = (category.category.replace(" ", "-").replace(
"ç", "c").replace("é", "e"))
if quiz_cd["sub_category"]:
sub_category = SubCategory.objects.get(
id=quiz_cd["sub_category"])
else:
sub_category = None
new_quiz = Quiz(
title=quiz_cd["title"],
description=quiz_cd["description"],
creator=request.user,
url="placeholder",
category=category,
category_name=category_name,
sub_category=sub_category,
random_order=quiz_cd["random_order"],
difficulty=0,
)
new_quiz.save()
mean_difficulty = 0
n = 0
if tf_formset:
for question in tf_formset:
cd = question.cleaned_data
n += 1
mean_difficulty += int(cd["difficulty"])
new_tf = TF_Question(
content=cd["content"],
difficulty=cd["difficulty"],
theme1=cd["theme1"],
theme2=cd["theme2"],
theme3=cd["theme3"],
order=cd["order"],
correct=cd["correct"],
quiz=new_quiz,
)
new_tf.save()
if mc_formset:
for question in mc_formset:
cd = question.cleaned_data
n += 1
mean_difficulty += int(cd["difficulty"])
new_mc = MCQuestion(
content=cd["content"],
difficulty=cd["difficulty"],
theme1=cd["theme1"],
theme2=cd["theme2"],
theme3=cd["theme3"],
order=cd["order"],
answer1=cd["answer1"],
answer2=cd["answer2"],
answer3=cd["answer3"],
answer1_correct=cd["answer1_correct"],
answer2_correct=cd["answer2_correct"],
answer3_correct=cd["answer3_correct"],
quiz=new_quiz,
)
new_mc.save()
mean_difficulty /= n
# Calculation of the difficulty
if mean_difficulty < 1.667:
quiz_difficulty = 1
elif mean_difficulty > 2.333:
quiz_difficulty = 3
else:
quiz_difficulty = 2
new_quiz.difficulty = quiz_difficulty
new_quiz.url = slugify(quiz_cd["title"]) + "-" + str(new_quiz.id)
new_quiz.save()
return redirect("profile")
return render(
request,
"quiz/create.html",
{
"quiz_form": quiz_form,
"tf_form": tf_formset,
"mc_form": mc_formset
},
)
def get(self, request):
form = QuizForm()
context = {
'form': form,
}
return render(request, 'quiz/training.html', context)
def play(request):
#If we handle the page after POST (ie: after we validate the answer)
if request.method == 'POST':
# Create a form instance and populate it with data from the request (binding):
form = QuizForm(request.POST)
#We take the question ID from the JavaScript getAnswer() function
questionID = request.POST['questionID']
#We take the answer ID from the JavaScript getAnswer() function
answerID = request.POST['answerID']
#We take all the answer from the question
answers = Answer.objects.filter(question__id=questionID)
#We take the ID of the good answer
for i in range(0, answers.count()):
if (answers[i].is_correct == True):
goodAnswerID = i
#If the answer selected by the user is right...
if True == answers[int(answerID)].is_correct:
#We set the boolean to True
goodAnswerBool = True
print("score : ")
print(request.user.score)
print("new score:")
request.user.score += 10
print(request.user.score)
request.user.save()
#We set the boolean to False
else:
goodAnswerBool = False
print("score : ")
print(request.user.score)
print("score : ")
print(request.user.score)
print("new score:")
request.user.score += -5
print(request.user.score)
request.user.save()
data = {
'goodAnswerBool': goodAnswerBool,
'goodAnswerID': goodAnswerID,
}
theReturn = JsonResponse(data)
# If this is a GET (or any other method) create the default form.
else:
#Initiate the random
seed()
#We take a question randomly
questionID = randint(1, Question.objects.all().count())
#We take all the answers possible
answers = Answer.objects.filter(question__id=questionID)
#We take the question
question = Question.objects.filter(id=questionID)
#Array of the iteration to random the answer
keys = []
#Array of answers randomed
answersArray = []
#Array to stock the answer temporaly
anAnswer = []
#We create a form (not used anymore)
form = QuizForm(request.POST or None)
#We randomise all the answers and put i in a format to be understand by the form
for i in range(0, 3):
while True:
key = randint(0, 2)
if ((key in keys) == False):
keys.append(key)
anAnswer.append(key)
anAnswer.append(answers[key].answer_text)
answersArray.append(tuple(anAnswer))
anAnswer = []
#We handle the ID of the correct answer
if (answers[key].is_correct == True):
goodAnswer = key
break
#We put the randomised answers in the form
form.fields['choice_field'].choices = answersArray
#We put the good answer ID in the form
form.answerID = goodAnswer
#Set up of the data set send at the HTML page when it's loading
context = {
'form': form,
'question': question[0],
'questionID': questionID,
'answerArray': answersArray,
}
theReturn = render(request, 'quiz/play.html', context)
return theReturn
