def add_question(request):
if not request.user.is_authenticated():
return redirect(reverse('login'))
errors = []
if request.method == 'POST':
question_form = QuestionForm(data=request.POST)
if question_form.is_valid():
question_form.save()
new_question_form = QuestionForm()
return render_to_response('quiz/add_question.html', {
'question_form': new_question_form,
'messages': u'سوال جدید اضافه شد'
},
context_instance=RequestContext(request))
else:
return render_to_response('quiz/add_question.html', {
'question_form': question_form,
'error_message': question_form.errors
},
context_instance=RequestContext(request))
elif request.method == 'GET':
question_form = QuestionForm()
return render_to_response('quiz/add_question.html', {
'question_form': question_form,
'error_message': errors
},
context_instance=RequestContext(request))
def questionEdit(request, quiz_pk, question_pk):
quiz = get_object_or_404(Quiz, pk=quiz_pk, owner=request.user)
question = get_object_or_404(Question, pk=question_pk, quiz=quiz)
AnswerFormSet = inlineformset_factory(Question,
Answer,
formset=BaseAnswerInlineFormset,
fields=("content", "is_correct"),
min_num=4,
validate_min=True,
max_num=4,
validate_max=True)
if request.method == "POST":
form = QuestionForm(request.POST, instance=question)
formset = AnswerFormSet(request.POST, instance=question)
if form.is_valid() and formset.is_valid():
form.save()
formset.save()
return redirect('quizEdit', quiz.pk)
else:
form = QuestionForm(instance=question)
formset = AnswerFormSet(instance=question)
return render(request, 'Question/questionEdit.html', {
'quiz': quiz,
'question': question,
'form': form,
'formset': formset
})
def questionform_view(request):
form = QuestionForm()
if request.method == "POST":
form = QuestionForm(request.POST)
if form.is_valid():
form.save()
return redirect('quiz:list')
return render(request, 'quiz/question.html', {'form': form})
def exam(request, quiz_name_slug):
if request.method == 'GET':
try:
question_id = request.session.get('current_deck', []).pop()
request.session['current_question'] = question_id
question = Questions.objects.get(id=question_id)
form = QuestionForm(question=question)
pics = {
answer.id: answer.answer_pic
for answer in question.get_answers()
}
context_dict = {
'question': question,
'form': form,
'pics': pics,
'quiz_name_slug': quiz_name_slug,
'answered': request.session.get('answered', 0),
'deck_length': request.session.get('deck_length', 0)
}
return render(request, 'quiz/question.html', context_dict)
except IndexError: # questions in deck are finished
print('deck is empty')
return redirect(f'/quiz/{quiz_name_slug}/result')
elif request.method == 'POST':
question_id = request.session.get('current_question', 0)
question = Questions.objects.get(id=question_id)
form = QuestionForm(request.POST, question=question)
answered = request.session.get('answered', 0)
deck = request.session.get('current_deck', [])
if form.is_valid():
user_answers = set(form.cleaned_data['answers'])
correct_answers = set(
str(answer.id) for answer in question.get_right_answer())
user_answer_is_correct = user_answers == correct_answers
question.user_answered(request.user, user_answer_is_correct)
if not user_answer_is_correct:
request.session['user_answers'][question_id] = list(
user_answers)
# in learning mode show right answer after each question, exam mode shows answers only in the end
if request.session.get('exam', False) or user_answer_is_correct:
request.session['answered'] = answered + 1
return redirect(f'/quiz/{quiz_name_slug}/exam')
else:
deck.append(question_id)
shuffle(deck)
request.session['current_deck'] = deck
return redirect(f'/quiz/{quiz_name_slug}/result')
else:
deck.append(question_id)
shuffle(deck)
request.session['current_deck'] = deck
return redirect(f'/quiz/{quiz_name_slug}/exam')
def adminpage(request):
form = QuestionForm(request.POST)
if form.is_valid():
form.save()
return redirect('quiz:adminpage')
else:
return render(request, 'AddQuestion.html', locals())
def add_question(request, quiz_id):
quiz = get_object_or_404(Quiz, pk=quiz_id)
context = {'quiz': quiz}
if request.method == 'POST':
form = QuestionForm(request.POST)
if form.is_valid():
question = form.save()
if form.cleaned_data['add_another']:
return redirect('quiz:add_question', quiz.id)
else:
return redirect('quiz:quiz', quiz_id)
else:
form = QuestionForm(initial={'quiz': quiz})
context['form'] = form
return render(request, 'quiz/add_question.html', context)
def edit_question(question_id):
question = Questions.query.get(question_id)
answers = Answers.query.filter_by(question_id = question.id)
wrong_answers = answers.filter_by(correct = 0).all()
correct_answer = answers.filter_by(correct = 1).first()
values = {
'question': question.question_text,
'wrong_answers': [a.answer_text for a in wrong_answers],
'correct_answer': correct_answer.answer_text
}
form = QuestionForm(content = question.content_id)
form.content.choices = [(r.id, r.title) for r in Content.query.all()]
form.new_question = False
if form.validate_on_submit():
question.question_text = form.question.data
question.content = Content.query.filter_by(id = form.content.data).first()
wrong_answers[0].answer_text = form.first_answer.data
wrong_answers[1].answer_text = form.second_answer.data
wrong_answers[2].answer_text = form.third_answer.data
correct_answer.answer_text = form.correct_answer.data
db.session.commit()
return redirect(url_for('quiz.questions'))
return render_template('questions/edit.html', values=values, form=form)
def questionAdd(request, pk):
quiz = get_object_or_404(Quiz, pk=pk, owner=request.user)
if request.method == "POST":
form = QuestionForm(request.POST)
if form.is_valid():
question = form.save(commit=False)
question.quiz = quiz
quiz.total_marks = quiz.total_marks + question.marks
quiz.save()
question.save()
return redirect('questionEdit', quiz.pk, question.pk)
else:
form = QuestionForm()
return render(request, 'Question/questionAdd.html', {
'quiz': quiz,
'form': form
})
def test_valid_questionForm():
data = {
"content": "question",
"difficulty": 1,
"theme1": "t1",
"theme2": "t2",
"theme3": "t3",
"order": 1,
}
form = QuestionForm(data)
assert form.is_valid() is True
def get_context_data(self, **kwargs):
context = super(QuestionCreatePageView,
self).get_context_data(**kwargs)
context['question_form'] = QuestionForm()
if self.request.POST:
context['answer_formset'] = AnswerFormSet(self.request.POST)
else:
context['answer_formset'] = AnswerFormSet(initial=[{
'correct': True
}])
context['test'] = 'test'
return context
def question_change(request, quiz_pk, question_pk):
# Simlar to the `question_add` view, this view is also managing
# the permissions at object-level. By querying both `quiz` and
# `question` we are making sure only the owner of the quiz can
# change its details and also only questions that belongs to this
# specific quiz can be changed via this url (in cases where the
# user might have forged/player with the url params.
quiz = get_object_or_404(Quiz, pk=quiz_pk, owner=request.user)
question = get_object_or_404(Question, pk=question_pk, quiz=quiz)
AnswerFormSet = inlineformset_factory(
Question, # parent model
Answer, # base model
formset=BaseAnswerInlineFormSet,
fields=('text', 'is_correct'),
min_num=2,
validate_min=True,
max_num=10,
validate_max=True)
if request.method == 'POST':
form = QuestionForm(request.POST, instance=question)
formset = AnswerFormSet(request.POST, instance=question)
if form.is_valid() and formset.is_valid():
with transaction.atomic():
form.save()
formset.save()
messages.success(request,
'Question and answers saved with success!')
return redirect('instructor:quiz_change', quiz.pk)
else:
form = QuestionForm(instance=question)
formset = AnswerFormSet(instance=question)
return render(request, 'question_change_form.html', {
'quiz': quiz,
'question': question,
'form': form,
'formset': formset
})
def add_question():
form = QuestionForm(request.form)
if request.method == 'POST':
if form.validate():
try:
return _add_question_to_db_(request.form)
except SQLAlchemyError:
flash("We couldn't add your question due to a technical issue"
" on our side. Please try again later.")
else:
flash("Not all required fields were filled.")
return _render_form_(form)
def question_add(request, pk):
# By filtering the quiz by the url keyword argument `pk` and
# by the owner, which is the logged in user, we are protecting
# this view at the object-level. Meaning only the owner of
# quiz will be able to add questions to it.
quiz = get_object_or_404(Quiz, pk=pk, owner=request.user)
if request.method == 'POST':
form = QuestionForm(request.POST)
if form.is_valid():
question = form.save(commit=False)
question.quiz = quiz
question.save()
messages.success(
request, 'You may now add answers/options to the question.')
return redirect('instructor:question_change', quiz.pk, question.pk)
else:
form = QuestionForm()
return render(request, 'question_add_form.html', {
'quiz': quiz,
'form': form
})
def quiz():
if current_user.is_authenticated:
global limit, count
form = QuestionForm()
id = Questions.query.order_by(func.random()).first().id
question = Questions.query.filter_by(id=id).first().question
answer = Questions.query.filter_by(id=id).first().answer
option1 = Questions.query.filter_by(id=id).first().option1
option2 = Questions.query.filter_by(id=id).first().option2
option3 = Questions.query.filter_by(id=id).first().option3
choice = [('answer', answer), ('option1', option1),
('option2', option2), ('option3', option3)]
random.shuffle(choice)
form.options.choices = choice
if form.validate_on_submit():
dat = form.options.data
if dat == 'answer':
flash(f'Correct!', 'success')
count = count + 1
else:
flash(f'Incorrect!', 'danger')
if limit >= 10:
limit = 0
score_user = current_user.username
user = User.query.filter_by(username=score_user).first()
user.score = count
db.session.commit()
return redirect(url_for('result'))
return redirect(url_for('quiz'))
limit = limit + 1
return render_template('questions.html',
title='Quiz',
form=form,
question=question,
limit=str(limit))
else:
return redirect(url_for('login'))
def quiz(request):
global questions
questions = Question.objects.all()
FORM = []
if request.method == "POST":
choice = request.POST.get("title")
if choice:
k, v = eval(choice)
request.session[str(k)] = v
if DEBUG:
print "request.session==================>", request.session.items()
print "request.session[name]==================>",\
request.session.get("name")
page = request.session.get("page")
if page <= request.session.get("num_pages"):
url_ = "/quiz/quiz/?page={0}".format(page)
else:
# return HttpResponse("Reached the Final Page")
url_ = "/quiz/result/"
return redirect(url_)
else:
for q in questions:
form = QuestionForm(q)
FORM.append(form)
paginator = Paginator(FORM, 1)
print "request.GET==================>", request.GET
page = request.GET.get("page")
print "request.pageno==================>", paginator.num_pages
request.session["num_pages"] = int(paginator.num_pages)
try:
if page:
pages = int(page) + 1
request.session["page"] = pages
FORM = paginator.page(page)
except PageNotAnInteger:
FORM = paginator.page(1)
request.session["page"] = 2
except EmptyPage:
FORM = paginator.page(
paginator.num_pages)
return render(request, 'quiz/questions.html', {'FORM': FORM})
def add_question():
form = QuestionForm()
form.content.choices = [(r.id, r.title) for r in Content.query.all()]
if form.validate_on_submit():
question = Questions(question_text = form.question.data, content = Content.query.filter_by(id = form.content.data).first())
answers = [
Answers(answer_text = form.first_answer.data, correct = 0, question = question),
Answers(answer_text = form.second_answer.data, correct = 0, question = question),
Answers(answer_text = form.third_answer.data, correct = 0, question = question),
Answers(answer_text = form.correct_answer.data, correct = 1, question = question)
]
db.session.add(question)
for answer in answers:
db.session.add(answer)
db.session.commit()
return redirect(url_for('quiz.questions'))
return render_template('questions/add.html', form=form)
def _render_form_():
form = QuestionForm()
return render_template('add_question.html', form=form)
def setup_method(self, method):
self.form = QuestionForm()
