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 question_new(request, quiz_id):
""" returns a template to create a new quiz. """
quiz = Quiz.objects.get(id=quiz_id)
questions = quiz.question_set.all()
if request.method == "POST":
question_form = QuestionForm(request.POST, request.FILES)
if question_form.is_valid():
new_question = question_form.save(commit=False)
new_question.qQuiz = quiz
new_question.save()
return HttpResponseRedirect(reverse("quiz.views.question_new", args=[quiz_id]))
#GET Request
else:
question_form = QuestionForm()
return render_to_response('quiz/create_question.html', {
"question_form" : question_form,
"questions" : questions,
"quizobj" : quiz,
}, context_instance=RequestContext(request))
return render_to_response('quiz/create_question.html', {
"question_form" : question_form,
"questions" : questions,
"quizobj" : quiz,
}, context_instance=RequestContext(request))
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 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 question_create(request, quiz_id, question_id=None):
""" returns a template to create a new quiz. """
quiz = get_object_or_404(Quiz, id=quiz_id, owner=request.user)
iscomplete = True
if request.method == "POST":
question_form = QuestionForm(request.POST)
answer_formset = AnswerFormSet(request.POST)
if question_form.is_valid() and answer_formset.is_valid():
""" @todo : this must be moved to the quiz-manager """
new_question = question_form.save(commit=False)
new_question.number = (quiz.quiz_questions.aggregate(Max('number'))['number__max'] or 0) +1
new_question.owner = request.user
new_question.quiz = quiz
new_question.save()
for answer_form in answer_formset.forms:
new_answer = answer_form.save(commit=False)
new_answer.owner = request.user
new_answer.question = new_question
new_answer.save()
##status updation is ugly, must be fixed.
iscomplete = iscomplete and not (new_answer.option == '')
##status updation is ugly, must be fixed.
iscomplete = iscomplete and not (new_question.text == '')
if iscomplete:
new_question.status = "complete"
new_question.save()
if len(quiz.quiz_questions.filter(status="incomplete")) == 0:
quiz.status = "complete"
else:
quiz.status = "incomplete"
quiz.save()
request.user.message_set.create(message="the question was created successfully. yeppie! add another")
return HttpResponseRedirect(reverse("quiz.views.question_create", args=[quiz_id]))
#GET Request
else:
question_form = QuestionForm()
answer_formset = AnswerFormSet(queryset=Answer.objects.none())
return render_to_response('quiz/question_form.html', {
"question_form" : question_form,
"answer_formset" : answer_formset,
"questions" : quiz.quiz_questions.all().order_by('number'),
"quizobj" : quiz,
"selected_button" : "create",
"current_question" : (quiz.quiz_questions.aggregate(Max('number'))['number__max'] or 0) +1,
"pagetitle" : "Create Question",
}, context_instance=RequestContext(request))
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 question_update(request, quiz_id, question_id):
""" opens the selected question in the preview mode. """
quiz = get_object_or_404(Quiz, id=quiz_id, owner=request.user)
question = get_object_or_404(Question, quiz=quiz, number=question_id)
answers = Answer.objects.filter(question=question)
iscomplete = True
if request.method == "POST":
question_form = QuestionForm(request.POST, instance=question)
answer_formset = AnswerFormSet(request.POST)
if question_form.is_valid() and answer_formset.is_valid():
answers.delete()
new_question = question_form.save()
for answer_form in answer_formset.forms:
answer_form = answer_form.save(commit=False)
answer_form.owner = request.user
answer_form.question = question
answer_form.save()
##status updation is ugly, must be fixed.
iscomplete = iscomplete and not (answer_form.option == '')
##status updation is ugly, must be fixed.
iscomplete = iscomplete and not (new_question.text == '')
if iscomplete:
new_question.status = "complete"
else:
new_question.status = "incomplete"
new_question.save()
if len(quiz.quiz_questions.filter(status="incomplete")) == 0:
quiz.status = "complete"
else:
quiz.status = "incomplete"
quiz.save()
request.user.message_set.create(message="the question was updated successfully :D ")
return HttpResponseRedirect(reverse("quiz.views.question_view", args=[quiz_id, question_id]))
#GET Request
else:
question_form = QuestionForm(instance=question)
answer_formset = AnswerFormSet(queryset=Answer.objects.filter(question=question))
return render_to_response("quiz/question_form.html", {
"quizobj" : quiz,
"questions" : quiz.quiz_questions.all().order_by('number'),
"question_form" : question_form,
"answer_formset" : answer_formset,
"selected_question": question,
"pagetitle" : "Update Question",
}, context_instance=RequestContext(request))
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 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 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 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 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 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 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_view(request, quiz_id, question_id):
""" opens the selected question in the preview mode. """
""" update the quiz, given its id. """
quiz = Quiz.objects.get(id=quiz_id)
#two unnecessary sql queries.
question = Question.objects.get(id=question_id)
questions = quiz.question_set.all()
if request.method == "POST":
question_form = QuestionForm(request.POST, request.FILES, instance=question)
question_form.is_update = True
if question_form.is_valid():
question_form.save()
return HttpResponseRedirect(reverse("quiz.views.question_view", args=[quiz_id, question_id]))
else:
#GET request.
question_form = QuestionForm(instance=question)
return render_to_response("quiz/create_question.html", {
"question_form" : question_form,
##this is a redundant field, passed here; must be removed.
"selected_question": question,
"questions" : questions,
"quizobj" : quiz,
}, context_instance=RequestContext(request))
#generic case
return render_to_response("quiz/create_question.html", {
"question_form" : question_form,
##this is a redundant field, passed here; must be removed.
"selected_question" : question,
"questions" : questions,
"quizobj" : quiz,
}, context_instance=RequestContext(request))
def question(request, slug=None):
if slug is None:
question = request.current_quiz.start()
request.session['ticket'] = [request.path]
else:
question = get_object_or_404(request.current_quiz.question_set, slug=slug)
ticket = request.session.get('ticket', [])
valid = request.path in ticket
if valid:
cur_index = ticket.index(request.path)
if cur_index:
previous_url = ticket[cur_index - 1]
elif ticket:
valid_url = ticket[-1]
if request.method == 'POST' and valid:
form = QuestionForm(question, request.POST)
if form.is_valid():
answer = form.cleaned_data['answer']
where_to = answer.where_to()
del ticket[cur_index + 1:]
try:
del ticket[ticket.index(where_to) + 1:]
except ValueError:
ticket.append(where_to)
request.session['ticket'] = ticket
return redirect(where_to)
else:
form = QuestionForm(question)
return render(request, "quiz/question_detail.html", locals())
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(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 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 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 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 _render_form_():
form = QuestionForm()
return render_template('add_question.html', form=form)
def setup_method(self, method):
self.form = QuestionForm()
def show_new_question(request):
context = RequestContext(request)
if not QuizProfile.objects.all().filter(user=request.user):
quiz_profile = QuizProfile(user=request.user, total_score = 0.0, fb_share_key = ''.join(random.choice(string.letters) for i in xrange(300)))
quiz_profile.save()
else:
quiz_profile = get_object_or_404(QuizProfile, user=request.user)
if request.method == 'POST': # If the form has been submitted...
form = QuestionForm(request.POST)
if form.is_valid():
submitted_option = form.cleaned_data['correct_option']
submitted_question = get_object_or_404(Question, pk= int(request.POST['question']))
attempted_question = get_object_or_404(AttemptedQuestion, player = quiz_profile, question = submitted_question,)
if attempted_question.answered:
return HttpResponseRedirect("/quiz/")
time_taken = float(request.POST['time_taken'])
marks = 0.0
if submitted_question.correct_option == int(submitted_option):
success = True
if time_taken <= submitted_question.max_time and time_taken >= submitted_question.min_time:
marks = submitted_question.max_marks*submitted_question.min_time/time_taken
elif time_taken < submitted_question.min_time:
marks = submitted_question.max_marks
else:
success = False
marks = round(marks,2)
alert = False
attempted_question.time_taken = time_taken
attempted_question.server_time_taken = calc_time(attempted_question.time, datetime.datetime.now())
if attempted_question.server_time_taken - attempted_question.time_taken > 10:
marks = 0.0
alert = True
attempted_question.marks_obtained = marks
attempted_question.answered = True
attempted_question.save()
quiz_profile.update()
return render_to_response( "quiz/submit_done.html", {"opt":submitted_option, "success":success,"question": submitted_question, "marks":marks, "time":time_taken, "alert":alert, }, context_instance = context)
else:
form = QuestionForm()
questions = Question.objects.all()
attempted_questions = AttemptedQuestion.objects.all().filter(player__user = request.user)
limit_exceeded = False
aqs_today = AttemptedQuestion.objects.filter(player__user= request.user, time__day=datetime.datetime.now().day)
aqs = []
daily_limit = 30
if len(questions) == len(attempted_questions) or len(questions) == 0 or aqs_today.count() >= daily_limit :
if aqs_today.count() >= daily_limit:
limit_exceeded = True
return render_to_response( "quiz/no_active_question.html",{"limit_exceeded":limit_exceeded, "daily_limit":daily_limit}, context_instance = context)
for a in attempted_questions:
try:
aqs.append(a.question)
except:
continue
while True:
q = questions[random.randint(0, len(questions)-1)]
if q in aqs:
continue
else:
break
attempted_question = AttemptedQuestion(question = q, player = quiz_profile)
attempted_question.save()
quiz_profile.update()
return render_to_response( "quiz/show_new_question.html", {"question":q, "form":form }, context_instance = context)
