Ticket #16174: cbv-formpreview1.diff

django/contrib/formtools/preview.py

@@ -1 +1 @@
 """
 Formtools Preview application.
 """
-
-try:
-    import cPickle as pickle
-except ImportError:
-    import pickle
-
 from django.conf import settings
-from django.http import Http404
 from django.shortcuts import render_to_response
-from django.template.context import RequestContext
 from django.utils.crypto import constant_time_compare
 from django.contrib.formtools.utils import form_hmac
+from django.views.generic import FormView
 
 AUTO_ID = 'formtools_%s' # Each form here uses this as its auto_id parameter.
+STAGE_FIELD = 'stage'
+HASH_FIELD = 'hash'
 
-class FormPreview(object):
+class FormPreview(FormView):
     preview_template = 'formtools/preview.html'
     form_template = 'formtools/form.html'
 
     # METHODS SUBCLASSES SHOULDN'T OVERRIDE ###################################
 
-    def __init__(self, form):
+    def __init__(self, form_class, *args, **kwargs):
+        super(FormPreview, self).__init__(*args, **kwargs)
         # form should be a Form class, not an instance.
-        self.form, self.state = form, {}
+        self.form_class = form_class
+        # A relic from the past; override get_context_data to pass extra context
+        # to the template. Left in for backwards compatibility.
+        self.state = {}
 
     def __call__(self, request, *args, **kwargs):
-        stage = {'1': 'preview', '2': 'post'}.get(request.POST.get(self.unused_name('stage')), 'preview')
+        return self.dispatch(request, *args, **kwargs)
+
+    def dispatch(self, request, *args, **kwargs):
+        self.preview_stage = 'preview'
+        self.post_stage = 'post'
+        stages = {'1': self.preview_stage, '2': self.post_stage}
+
+        posted_stage = request.POST.get(self.unused_name(STAGE_FIELD))
+        self.stage = stages.get(posted_stage, self.preview_stage)
+
+        # For backwards compatiblity
         self.parse_params(*args, **kwargs)
-        try:
-            method = getattr(self, stage + '_' + request.method.lower())
-        except AttributeError:
-            raise Http404
-        return method(request)
+
+        return super(FormPreview, self).dispatch(request, *args, **kwargs)
 
     def unused_name(self, name):
         """
@@ -45 +51 @@
         """
         while 1:
             try:
-                f = self.form.base_fields[name]
+                self.form_class.base_fields[name]
             except KeyError:
                 break # This field name isn't being used by the form.
             name += '_'
         return name
 
-    def preview_get(self, request):
+    def _get_context_data(self, form):
+        """ For backwards compatiblity. """
+        context = self.get_context_data()
+        context.update(self.get_context(self.request, form))
+        return context
+
+    def get(self, request, *args, **kwargs):
         "Displays the form"
-        f = self.form(auto_id=self.get_auto_id(), initial=self.get_initial(request))
-        return render_to_response(self.form_template,
-            self.get_context(request, f),
-            context_instance=RequestContext(request))
+        form_class = self.get_form_class()
+        form = self.get_form(form_class)
+        context = self._get_context_data(form)
+        self.template_name = self.form_template
+        return self.render_to_response(context)
+
+    def _check_security_hash(self, token, form):
+        expected = self.security_hash(self.request, form)
+        return constant_time_compare(token, expected)
 
     def preview_post(self, request):
-        "Validates the POST data. If valid, displays the preview page. Else, redisplays form."
-        f = self.form(request.POST, auto_id=self.get_auto_id())
-        context = self.get_context(request, f)
-        if f.is_valid():
-            self.process_preview(request, f, context)
-            context['hash_field'] = self.unused_name('hash')
-            context['hash_value'] = self.security_hash(request, f)
-            return render_to_response(self.preview_template, context, context_instance=RequestContext(request))
+        """ For backwards compatibility. failed_hash calls this method by
+        default. """
+        self.stage = self.preview_stage
+        return self.post(request)
+
+    def form_valid(self, form):
+        context = self._get_context_data(form)
+        if self.stage == self.preview_stage:
+            self.process_preview(self.request, form, context)
+            context['hash_field'] = self.unused_name(HASH_FIELD)
+            context['hash_value'] = self.security_hash(self.request, form)
+            self.template_name = self.preview_template
+            return self.render_to_response(context)
         else:
-            return render_to_response(self.form_template, context, context_instance=RequestContext(request))
-
-    def _check_security_hash(self, token, request, form):
-        expected = self.security_hash(request, form)
-        return constant_time_compare(token, expected)
+            form_hash = self.request.POST.get(self.unused_name(HASH_FIELD), '')
+            if not self._check_security_hash(form_hash, form):
+                return self.failed_hash(self.request) # Security hash failed.
+            return self.done(self.request, form.cleaned_data)
 
-    def post_post(self, request):
-        "Validates the POST data. If valid, calls done(). Else, redisplays form."
-        f = self.form(request.POST, auto_id=self.get_auto_id())
-        if f.is_valid():
-            if not self._check_security_hash(request.POST.get(self.unused_name('hash'), ''),
-                                             request, f):
-                return self.failed_hash(request) # Security hash failed.
-            return self.done(request, f.cleaned_data)
-        else:
-            return render_to_response(self.form_template,
-                self.get_context(request, f),
-                context_instance=RequestContext(request))
+    def form_invalid(self, form):
+        context = self._get_context_data(form)
+        self.template_name = self.form_template
+        return render_to_response(context)
 
     # METHODS SUBCLASSES MIGHT OVERRIDE IF APPROPRIATE ########################
 
@@ -96 +109 @@
         """
         return AUTO_ID
 
-    def get_initial(self, request):
+    def get_initial(self, request=None):
         """
         Takes a request argument and returns a dictionary to pass to the form's
         ``initial`` kwarg when the form is being created from an HTTP get.
         """
-        return {}
+        return self.initial
 
     def get_context(self, request, form):
         "Context for template rendering."
-        return {'form': form, 'stage_field': self.unused_name('stage'), 'state': self.state}
-
+        context = {
+            'form': form,
+            'stage_field': self.unused_name(STAGE_FIELD),
+            'state': self.state
+        }
+        return context
+
+    def get_form_kwargs(self):
+        """ This is overriden to maintain backward compatibility and pass
+        the request to get_initial. """
+        kwargs = {
+            'initial': self.get_initial(self.request),
+            'auto_id': self.get_auto_id()
+        }
+        if self.request.method in ('POST', 'PUT'):
+            kwargs.update({
+                'data': self.request.POST,
+                'files': self.request.FILES,
+            })
+        return kwargs
 
     def parse_params(self, *args, **kwargs):
         """
-        Given captured args and kwargs from the URLconf, saves something in
-        self.state and/or raises Http404 if necessary.
+        Called in dispatch() prior to delegating the request to get() or post().
+        Given captured args and kwargs from the URLconf, allows the ability to
+        save something on the instance and/or raises Http404 if necessary.
 
         For example, this URLconf captures a user_id variable:
 

django/contrib/formtools/tests/__init__.py

@@ -17 +17 @@
 
 success_string = "Done was called!"
 
+
 class TestFormPreview(preview.FormPreview):
     def get_context(self, request, form):
         context = super(TestFormPreview, self).get_context(request, form)
         context.update({'custom_context': True})
         return context
 
+    def get_context_data(self, **kwargs):
+        context = super(TestFormPreview, self).get_context_data(**kwargs)
+        context['more_custom_context'] = True
+        return context
+
     def get_initial(self, request):
         return {'field1': 'Works!'}
 
@@ -67 +73 @@
         stage = self.input % 1
         self.assertContains(response, stage, 1)
         self.assertEqual(response.context['custom_context'], True)
+        self.assertEqual(response.context['more_custom_context'], True)
         self.assertEqual(response.context['form'].initial, {'field1': 'Works!'})
 
     def test_form_preview(self):
@@ -86 +93 @@
         stage = self.input % 2
         self.assertContains(response, stage, 1)
 
+        # Check that the correct context was passed to the template
+        self.assertEqual(response.context['custom_context'], True)
+        self.assertEqual(response.context['more_custom_context'], True)
+
     def test_form_submit(self):
         """
         Test contrib.formtools.preview form submittal.
@@ -140 +151 @@
         response = self.client.post('/preview/', self.test_data)
         self.assertEqual(response.content, success_string)
 
-
     def test_form_submit_bad_hash(self):
         """
         Test contrib.formtools.preview form submittal does not proceed
@@ -154 +164 @@
         self.assertNotEqual(response.content, success_string)
         hash = utils.form_hmac(TestForm(self.test_data)) + "bad"
         self.test_data.update({'hash': hash})
-        response = self.client.post('/previewpreview/', self.test_data)
+        response = self.client.post('/preview/', self.test_data)
+        self.assertTemplateUsed(response, 'formtools/preview.html')
         self.assertNotEqual(response.content, success_string)