rejigged the quiz processing view - now its class based!

diff --git a/multichoice/models.py b/multichoice/models.py
index ffaf41a75e412482988a34f809aa94343f6f57bc..54ccb53b4062da3211b670b36e7a699d24f84d6f 100644 (file)
--- a/multichoice/models.py
+++ b/multichoice/models.py
@@ -15,6 +15,10 @@ class MCQuestion(Question):
     def get_answers(self):
         return Answer.objects.filter(question=self)
 
+    def get_answers_list(self):
+        return [(answer.id, answer.content) for answer in
+                Answer.objects.filter(question=self)]
+
     class Meta:
         verbose_name = "Multiple Choice Question"
         verbose_name_plural = "Multiple Choice Questions"

diff --git a/quiz/forms.py b/quiz/forms.py
index 18fd282b6a621f8aacc5fa7edc9224dbfcb96896..5bd8550ee2cfa9259373b9b8c42cc0005bab6a12 100644 (file)
--- a/quiz/forms.py
+++ b/quiz/forms.py
@@ -5,7 +5,6 @@ from django.forms.widgets import RadioSelect
 class QuestionForm(forms.Form):
     def __init__(self, question, *args, **kwargs):
         super(QuestionForm, self).__init__(*args, **kwargs)
-        self.fields["answers"] = forms.ModelChoiceField(
-            queryset=question.get_answers(),
-            empty_label=None,
-            widget=RadioSelect)
+        choice_list = [x for x in question.get_answers_list()]
+        self.fields["answers"] = forms.ChoiceField(choices=choice_list,
+                                                   widget=RadioSelect)

diff --git a/quiz/templates/question.html b/quiz/templates/question.html
index eac58dbce474e6c9e7d2f684855d7bbd87e4042c..8044515e9bc373af38b7bf974ae5739368aedb27 100644 (file)
--- a/quiz/templates/question.html
+++ b/quiz/templates/question.html
@@ -51,28 +51,24 @@
 
 <p class="lead">{{ question.content }}</p>
 
-<form action="" method="get">{% csrf_token %}
+<form action="" method="POST">{% csrf_token %}
   <input type=hidden name="question_id" value="{{ question.id }}">
 
-  <table class="table table-hover table-bordered" id="answerchoice">
-       <tbody>
+  <ul class="list-group">
 
-         {% if question_type.TF_Question %}
-           {% include 'answers_for_tf_question.html' %}
-         {% endif %}
+       {% for answer in form.answers %}
+         <li class="list-group-item">
+         {{ answer }}
+         </li>
+       {% endfor %}
 
-         {% if question_type.MCQuestion %}
-           {% include 'answers_for_mc_question.html' %}
-         {% endif %}
-
-       </tbody>
-  </table>
+  </ul>
   <input type="submit" value="Check" class="btn btn-large btn-block btn-warning" >
 </form>
 
 {% endif %}
 
 <hr>
-</div>
+       </div>
 
 {% endblock %}

diff --git a/quiz/urls.py b/quiz/urls.py
index de6e2311c815563d7065ae7773a620eb545665c5..c3438847fbda5dc4d382c9ab27d22cd58c280933 100644 (file)
--- a/quiz/urls.py
+++ b/quiz/urls.py
@@ -28,10 +28,6 @@ urlpatterns = patterns('quiz.views',
                            name='quiz_start_page'),
 
                        url(regex=r'^(?P<quiz_name>[\w-]+)/take/$',
-                           view='quiz_take',
-                           name='quiz_question'),
-
-                       url(regex=r'^x/(?P<quiz_name>[\w-]+)/take/$',
                            view=QuizTake.as_view(),
                            name='quiz_question'),
                        )

diff --git a/quiz/views.py b/quiz/views.py
index 0a92b354ab4142ac352659e6826463bb049e42d4..577da90c9e994681dc1566cf18262f42c0c2a1e1 100644 (file)
--- a/quiz/views.py
+++ b/quiz/views.py
@@ -61,17 +61,51 @@ class QuizUserProgressView(TemplateView):
         return context
 
 
-def quiz_take(request, quiz_name):
-    quiz = Quiz.objects.get(url=quiz_name.lower())
+class QuizTake(FormView):
+    form_class = QuestionForm
+    template_name = 'question.html'
+
+    def dispatch(self, request, *args, **kwargs):
+        self.quiz = get_object_or_404(Quiz, url=self.kwargs['quiz_name'])
 
-    if request.user.is_authenticated() is True:
-        return user_load_sitting(request, quiz)
+        if request.user.is_authenticated() is True:
+            self.sitting = user_sitting(self.request, self.quiz)
+        else:
+            anon_load_sitting(self.request, self.quiz)
+
+        return super(QuizTake, self).dispatch(request, *args, **kwargs)
+
+    def get_form_kwargs(self):
+        if self.request.user.is_authenticated() is True:
+            self.question = self.sitting.get_first_question()
+        else:
+            self.question = anon_next_question(self)
+        kwargs = super(QuizTake, self).get_form_kwargs()
+        return dict(kwargs, question=self.question)
 
-    else:  # anon user
-        return anon_load_sitting(request, quiz)
+    def form_valid(self, form):
+        if self.request.user.is_authenticated() is True:
+            form_valid_user(self, form)
+            if self.sitting.get_first_question() is False:
+                return final_result_user(self.request, self.sitting,
+                                         self.quiz, self.previous)
+        else:
+            form_valid_anon(self, form)
+            if not self.request.session[self.quiz.anon_q_list()]:
+                return final_result_anon(self.request,
+                                         self.quiz, self.previous)
 
+        return super(QuizTake, self).get(self, self.request)
 
-def user_load_sitting(request, quiz):
+    def get_context_data(self, **kwargs):
+        context = super(QuizTake, self).get_context_data(**kwargs)
+        context['question'] = self.question
+        if hasattr(self, 'previous'):
+            context['previous'] = self.previous
+        return context
+
+
+def user_sitting(request, quiz):
     if quiz.single_attempt is True and\
        Sitting.objects.filter(user=request.user,
                               quiz=quiz,
@@ -94,47 +128,34 @@ def user_load_sitting(request, quiz):
                                          complete=False)[0]
 
     finally:
-        return user_load_next_question(request, sitting, quiz)
-
-
-def user_load_next_question(request, sitting, quiz):
-    previous = False
-    if 'guess' in request.GET:
-        progress, created = Progress.objects.get_or_create(user=request.user)
-        guess = request.GET['guess']
-        question = sitting.get_first_question()
-        is_correct = question.check_if_correct(guess)
+        return sitting
 
-        if is_correct is True:
-            sitting.add_to_score(1)
-            progress.update_score(question.category, 1, 1)
 
-        else:
-            sitting.add_incorrect_question(question)
-            progress.update_score(question.category, 0, 1)
-
-        if quiz.answers_at_end is not True:
-            previous = {'previous_answer': guess,
-                        'previous_outcome': is_correct,
-                        'previous_question': question,
-                        'answers': question.get_answers(),
-                        'question_type': {question.__class__.__name__: True}}
+def form_valid_user(self, form):
+    progress, created = Progress.objects.get_or_create(
+        user=self.request.user)
+    guess = form.cleaned_data['answers']
+    is_correct = self.question.check_if_correct(guess)
 
-        sitting.remove_first_question()
+    if is_correct is True:
+        self.sitting.add_to_score(1)
+        progress.update_score(self.question.category, 1, 1)
 
-    next_q = sitting.get_first_question()
-    if next_q is False:
-        #  no questions left
-        return final_result_user(request, sitting, quiz, previous)
+    else:
+        self.sitting.add_incorrect_question(self.question)
+        progress.update_score(self.question.category, 0, 1)
+
+    if self.quiz.answers_at_end is not True:
+        self.previous = {'previous_answer': guess,
+                         'previous_outcome': is_correct,
+                         'previous_question': self.question,
+                         'answers': self.question.get_answers(),
+                         'question_type': {self.question
+                                           .__class__.__name__: True}}
+    else:
+        self.previous = {}
 
-    return render_to_response('question.html',
-                              {'quiz': quiz,
-                               'question': next_q,
-                               'question_type': {next_q.__class__.__name__:
-                                                 True},
-                               'answers': next_q.get_answers(),
-                               'previous': previous},
-                              context_instance=RequestContext(request))
+    self.sitting.remove_first_question()
 
 
 def final_result_user(request, sitting, quiz, previous):
@@ -173,7 +194,7 @@ def anon_load_sitting(request, quiz):
         return render(request, 'single_complete.html')
 
     if quiz.anon_q_list() in request.session:
-        return load_anon_next_question(request, quiz)
+        return request.session[quiz.anon_q_list()]
     else:
         return new_anon_quiz_session(request, quiz)
 
@@ -194,47 +215,35 @@ def new_anon_quiz_session(request, quiz):
     # session list of questions
     request.session[quiz.anon_q_list()] = question_list
 
-    return load_anon_next_question(request, quiz)
-
-
-def load_anon_next_question(request, quiz):
-    previous = False
-
-    if 'guess' in request.GET:
-        previous = question_check_anon(request, quiz)
-        request.session[quiz.anon_q_list()] = (request.
-                                               session[quiz.anon_q_list()][1:])
+    return request.session[quiz.anon_q_list()]
 
-    if not request.session[quiz.anon_q_list()]:
-        return final_result_anon(request, quiz, previous)
 
-    next_question_id = request.session[quiz.anon_q_list()][0]
-    next_question = Question.objects.get_subclass(id=next_question_id)
-    question_type = {next_question.__class__.__name__: True}
-    return render_to_response('question.html',
-                              {'quiz': quiz,
-                               'question': next_question,
-                               'question_type': question_type,
-                               'previous': previous},
-                              context_instance=RequestContext(request))
+def anon_next_question(self):
+    next_question_id = self.request.session[self.quiz.anon_q_list()][0]
+    return Question.objects.get_subclass(id=next_question_id)
 
 
-def question_check_anon(request, quiz):
-    question = Question.objects.get_subclass(id=request.GET['question_id'])
-    is_correct = question.check_if_correct(request.GET['guess'])
+def form_valid_anon(self, form):
+    guess = form.cleaned_data['answers']
+    is_correct = self.question.check_if_correct(guess)
 
     if is_correct is True:
-        request.session[quiz.anon_score_id()] += 1
-        anon_session_score(request, 1, 1)
+        self.request.session[self.quiz.anon_score_id()] += 1
+        anon_session_score(self.request, 1, 1)
     else:
-        anon_session_score(request, 0, 1)
-
-    if quiz.answers_at_end is not True:
-        return {'previous_answer': request.GET['guess'],
-                'previous_outcome': is_correct,
-                'previous_question': question}
+        anon_session_score(self.request, 0, 1)
+
+    if self.quiz.answers_at_end is not True:
+        self.previous = {'previous_answer': guess,
+                         'previous_outcome': is_correct,
+                         'previous_question': self.question,
+                         'answers': self.question.get_answers(),
+                         'question_type': {self.question
+                                           .__class__.__name__: True}}
     else:
-        return {}
+        self.previous = {}
+    self.request.session[self.quiz.anon_q_list()] =\
+        (self.request.session[self.quiz.anon_q_list()][1:])
 
 
 def anon_session_score(request, to_add=0, possible=0):
@@ -293,54 +302,3 @@ def final_result_anon(request, quiz, previous):
                                    'session': session_score,
                                    'possible': session_possible},
                                   context_instance=RequestContext(request))
-
-
-def form_test(request, quiz_name):
-    quiz = Quiz.objects.get(url=quiz_name.lower())
-    try:
-        sitting = Sitting.objects.get(user=request.user,
-                                      quiz=quiz,
-                                      complete=False)
-
-    except Sitting.DoesNotExist:
-        sitting = Sitting.objects.new_sitting(request.user, quiz)
-
-    except Sitting.MultipleObjectsReturned:
-        sitting = Sitting.objects.filter(user=request.user,
-                                         quiz=quiz,
-                                         complete=False)[0]
-
-    question = sitting.get_first_question()
-    form = QuestionForm(question=question)
-    return render_to_response('q_test.html', {'form': form,
-                                              'question': question})
-
-
-class QuizTake(FormView):
-    form_class = QuestionForm
-    template_name = 'q_test.html'
-
-    def get_context_data(self, **kwargs):
-        context = super(QuizTake, self).get_context_data(**kwargs)
-        context['question'] = self.question
-        return context
-
-    def get_form_kwargs(self):
-        kwargs = super(QuizTake, self).get_form_kwargs()
-        quiz = get_object_or_404(Quiz, url=self.kwargs['quiz_name'])
-
-        try:
-            sitting = Sitting.objects.get(user=self.request.user,
-                                          quiz=quiz,
-                                          complete=False)
-
-        except Sitting.DoesNotExist:
-            sitting = Sitting.objects.new_sitting(self.request.user, quiz)
-
-        except Sitting.MultipleObjectsReturned:
-            sitting = Sitting.objects.filter(user=self.request.user,
-                                             quiz=quiz,
-                                             complete=False)[0]
-
-        self.question = sitting.get_first_question()
-        return dict(kwargs, question=self.question)

diff --git a/true_false/models.py b/true_false/models.py
index bca63f5425474e769d01ea095e5f0a086b0d6082..fee27347467da973e4909caf011e35dc723c5314 100644 (file)
--- a/true_false/models.py
+++ b/true_false/models.py
@@ -10,9 +10,9 @@ class TF_Question(Question):
                                             " false.")
 
     def check_if_correct(self, guess):
-        if guess == "T":
+        if guess == "True":
             guess_bool = True
-        elif guess == "F":
+        elif guess == "False":
             guess_bool = False
         else:
             return False
@@ -28,6 +28,9 @@ class TF_Question(Question):
                 {'correct': self.check_if_correct('F'),
                  'content': 'False'}]
 
+    def get_answers_list(self):
+        return [(True, True), (False, False)]
+
     class Meta:
         verbose_name = "True/False Question"
         verbose_name_plural = "True/False Questions"