|
1 from django.forms.models import ModelFormMetaclass, ModelForm |
|
2 from django.template import RequestContext, loader |
|
3 from django.http import Http404, HttpResponse, HttpResponseRedirect |
|
4 from django.core.xheaders import populate_xheaders |
|
5 from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured |
|
6 from django.utils.translation import ugettext |
|
7 from django.contrib.auth.views import redirect_to_login |
|
8 from django.views.generic import GenericViewError |
|
9 from django.contrib import messages |
|
10 |
|
11 |
|
12 def apply_extra_context(extra_context, context): |
|
13 """ |
|
14 Adds items from extra_context dict to context. If a value in extra_context |
|
15 is callable, then it is called and the result is added to context. |
|
16 """ |
|
17 for key, value in extra_context.iteritems(): |
|
18 if callable(value): |
|
19 context[key] = value() |
|
20 else: |
|
21 context[key] = value |
|
22 |
|
23 def get_model_and_form_class(model, form_class): |
|
24 """ |
|
25 Returns a model and form class based on the model and form_class |
|
26 parameters that were passed to the generic view. |
|
27 |
|
28 If ``form_class`` is given then its associated model will be returned along |
|
29 with ``form_class`` itself. Otherwise, if ``model`` is given, ``model`` |
|
30 itself will be returned along with a ``ModelForm`` class created from |
|
31 ``model``. |
|
32 """ |
|
33 if form_class: |
|
34 return form_class._meta.model, form_class |
|
35 if model: |
|
36 # The inner Meta class fails if model = model is used for some reason. |
|
37 tmp_model = model |
|
38 # TODO: we should be able to construct a ModelForm without creating |
|
39 # and passing in a temporary inner class. |
|
40 class Meta: |
|
41 model = tmp_model |
|
42 class_name = model.__name__ + 'Form' |
|
43 form_class = ModelFormMetaclass(class_name, (ModelForm,), {'Meta': Meta}) |
|
44 return model, form_class |
|
45 raise GenericViewError("Generic view must be called with either a model or" |
|
46 " form_class argument.") |
|
47 |
|
48 def redirect(post_save_redirect, obj): |
|
49 """ |
|
50 Returns a HttpResponseRedirect to ``post_save_redirect``. |
|
51 |
|
52 ``post_save_redirect`` should be a string, and can contain named string- |
|
53 substitution place holders of ``obj`` field names. |
|
54 |
|
55 If ``post_save_redirect`` is None, then redirect to ``obj``'s URL returned |
|
56 by ``get_absolute_url()``. If ``obj`` has no ``get_absolute_url`` method, |
|
57 then raise ImproperlyConfigured. |
|
58 |
|
59 This function is meant to handle the post_save_redirect parameter to the |
|
60 ``create_object`` and ``update_object`` views. |
|
61 """ |
|
62 if post_save_redirect: |
|
63 return HttpResponseRedirect(post_save_redirect % obj.__dict__) |
|
64 elif hasattr(obj, 'get_absolute_url'): |
|
65 return HttpResponseRedirect(obj.get_absolute_url()) |
|
66 else: |
|
67 raise ImproperlyConfigured( |
|
68 "No URL to redirect to. Either pass a post_save_redirect" |
|
69 " parameter to the generic view or define a get_absolute_url" |
|
70 " method on the Model.") |
|
71 |
|
72 def lookup_object(model, object_id, slug, slug_field): |
|
73 """ |
|
74 Return the ``model`` object with the passed ``object_id``. If |
|
75 ``object_id`` is None, then return the object whose ``slug_field`` |
|
76 equals the passed ``slug``. If ``slug`` and ``slug_field`` are not passed, |
|
77 then raise Http404 exception. |
|
78 """ |
|
79 lookup_kwargs = {} |
|
80 if object_id: |
|
81 lookup_kwargs['%s__exact' % model._meta.pk.name] = object_id |
|
82 elif slug and slug_field: |
|
83 lookup_kwargs['%s__exact' % slug_field] = slug |
|
84 else: |
|
85 raise GenericViewError( |
|
86 "Generic view must be called with either an object_id or a" |
|
87 " slug/slug_field.") |
|
88 try: |
|
89 return model.objects.get(**lookup_kwargs) |
|
90 except ObjectDoesNotExist: |
|
91 raise Http404("No %s found for %s" |
|
92 % (model._meta.verbose_name, lookup_kwargs)) |
|
93 |
|
94 def create_object(request, model=None, template_name=None, |
|
95 template_loader=loader, extra_context=None, post_save_redirect=None, |
|
96 login_required=False, context_processors=None, form_class=None): |
|
97 """ |
|
98 Generic object-creation function. |
|
99 |
|
100 Templates: ``<app_label>/<model_name>_form.html`` |
|
101 Context: |
|
102 form |
|
103 the form for the object |
|
104 """ |
|
105 if extra_context is None: extra_context = {} |
|
106 if login_required and not request.user.is_authenticated(): |
|
107 return redirect_to_login(request.path) |
|
108 |
|
109 model, form_class = get_model_and_form_class(model, form_class) |
|
110 if request.method == 'POST': |
|
111 form = form_class(request.POST, request.FILES) |
|
112 if form.is_valid(): |
|
113 new_object = form.save() |
|
114 |
|
115 msg = ugettext("The %(verbose_name)s was created successfully.") %\ |
|
116 {"verbose_name": model._meta.verbose_name} |
|
117 messages.success(request, msg, fail_silently=True) |
|
118 return redirect(post_save_redirect, new_object) |
|
119 else: |
|
120 form = form_class() |
|
121 |
|
122 # Create the template, context, response |
|
123 if not template_name: |
|
124 template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower()) |
|
125 t = template_loader.get_template(template_name) |
|
126 c = RequestContext(request, { |
|
127 'form': form, |
|
128 }, context_processors) |
|
129 apply_extra_context(extra_context, c) |
|
130 return HttpResponse(t.render(c)) |
|
131 |
|
132 def update_object(request, model=None, object_id=None, slug=None, |
|
133 slug_field='slug', template_name=None, template_loader=loader, |
|
134 extra_context=None, post_save_redirect=None, login_required=False, |
|
135 context_processors=None, template_object_name='object', |
|
136 form_class=None): |
|
137 """ |
|
138 Generic object-update function. |
|
139 |
|
140 Templates: ``<app_label>/<model_name>_form.html`` |
|
141 Context: |
|
142 form |
|
143 the form for the object |
|
144 object |
|
145 the original object being edited |
|
146 """ |
|
147 if extra_context is None: extra_context = {} |
|
148 if login_required and not request.user.is_authenticated(): |
|
149 return redirect_to_login(request.path) |
|
150 |
|
151 model, form_class = get_model_and_form_class(model, form_class) |
|
152 obj = lookup_object(model, object_id, slug, slug_field) |
|
153 |
|
154 if request.method == 'POST': |
|
155 form = form_class(request.POST, request.FILES, instance=obj) |
|
156 if form.is_valid(): |
|
157 obj = form.save() |
|
158 msg = ugettext("The %(verbose_name)s was updated successfully.") %\ |
|
159 {"verbose_name": model._meta.verbose_name} |
|
160 messages.success(request, msg, fail_silently=True) |
|
161 return redirect(post_save_redirect, obj) |
|
162 else: |
|
163 form = form_class(instance=obj) |
|
164 |
|
165 if not template_name: |
|
166 template_name = "%s/%s_form.html" % (model._meta.app_label, model._meta.object_name.lower()) |
|
167 t = template_loader.get_template(template_name) |
|
168 c = RequestContext(request, { |
|
169 'form': form, |
|
170 template_object_name: obj, |
|
171 }, context_processors) |
|
172 apply_extra_context(extra_context, c) |
|
173 response = HttpResponse(t.render(c)) |
|
174 populate_xheaders(request, response, model, getattr(obj, obj._meta.pk.attname)) |
|
175 return response |
|
176 |
|
177 def delete_object(request, model, post_delete_redirect, object_id=None, |
|
178 slug=None, slug_field='slug', template_name=None, |
|
179 template_loader=loader, extra_context=None, login_required=False, |
|
180 context_processors=None, template_object_name='object'): |
|
181 """ |
|
182 Generic object-delete function. |
|
183 |
|
184 The given template will be used to confirm deletetion if this view is |
|
185 fetched using GET; for safty, deletion will only be performed if this |
|
186 view is POSTed. |
|
187 |
|
188 Templates: ``<app_label>/<model_name>_confirm_delete.html`` |
|
189 Context: |
|
190 object |
|
191 the original object being deleted |
|
192 """ |
|
193 if extra_context is None: extra_context = {} |
|
194 if login_required and not request.user.is_authenticated(): |
|
195 return redirect_to_login(request.path) |
|
196 |
|
197 obj = lookup_object(model, object_id, slug, slug_field) |
|
198 |
|
199 if request.method == 'POST': |
|
200 obj.delete() |
|
201 msg = ugettext("The %(verbose_name)s was deleted.") %\ |
|
202 {"verbose_name": model._meta.verbose_name} |
|
203 messages.success(request, msg, fail_silently=True) |
|
204 return HttpResponseRedirect(post_delete_redirect) |
|
205 else: |
|
206 if not template_name: |
|
207 template_name = "%s/%s_confirm_delete.html" % (model._meta.app_label, model._meta.object_name.lower()) |
|
208 t = template_loader.get_template(template_name) |
|
209 c = RequestContext(request, { |
|
210 template_object_name: obj, |
|
211 }, context_processors) |
|
212 apply_extra_context(extra_context, c) |
|
213 response = HttpResponse(t.render(c)) |
|
214 populate_xheaders(request, response, model, getattr(obj, obj._meta.pk.attname)) |
|
215 return response |