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 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