user_media.views: 193 total statements, 100.0% covered

Generated: Mon 2014-08-04 18:55 CEST

Source file: /home/tobi/Projects/django-user-media/src/user_media/views.py

Stats: 178 executed, 0 missed, 15 excluded, 205 ignored

1. """Views for the ``django-user-media`` app."""
2. from django.conf import settings
3. from django.contrib.auth.decorators import login_required
4. from django.contrib.contenttypes.models import ContentType
5. from django.db.models import ObjectDoesNotExist
6. from django.http import Http404, HttpResponse
7. from django.template import RequestContext
8. from django.template.loader import render_to_string
9. from django.utils.decorators import method_decorator
10. from django.utils.translation import ugettext_lazy as _
11. from django.views.generic import CreateView, DeleteView, FormView, UpdateView
13. from django_libs.views_mixins import AjaxResponseMixin
14. from easy_thumbnails.files import get_thumbnailer
15. from simplejson import dumps
17. from user_media.forms import UserMediaImageForm, UserMediaImageSingleUploadForm
18. from user_media.models import UserMediaImage
21. class UserMediaImageViewMixin(object):
22. """
23. Mixin for views that deal with `UserMediaImage` objects.
25. When using this mixin please make sure that you call `_add_next_and_user()`
26. in your `dispatch()` method.
28. """
29. model = UserMediaImage
31. def _add_next_and_user(self, request):
32. self.next = request.POST.get('next', '') or request.GET.get('next', '')
33. self.user = request.user
35. def get_context_data(self, **kwargs):
36. """
37. Adds `next` to the context.
39. This makes sure that the `next` parameter doesn't get lost if the
40. form was submitted invalid.
42. """
43. ctx = super(UserMediaImageViewMixin, self).get_context_data(**kwargs)
44. ctx.update({
45. 'action': self.action,
46. 'next': self.next,
47. })
48. return ctx
50. def get_success_url(self):
51. """
52. Returns the success URL.
54. This is either the given `next` URL parameter or the content object's
55. `get_absolute_url` method's return value.
57. """
58. if self.next:
59. return self.next
60. if self.object and self.object.content_object:
61. return self.object.content_object.get_absolute_url()
62. raise Exception(
63. 'No content object given. Please provide ``next`` in your POST'
64. ' data')
67. class CreateImageView(AjaxResponseMixin, UserMediaImageViewMixin, CreateView):
68. action = 'create'
69. form_class = UserMediaImageForm
70. ajax_template_prefix = 'partials/ajax_'
72. @method_decorator(login_required)
73. def dispatch(self, request, *args, **kwargs):
74. """Adds useful objects to the class and performs security checks."""
75. self._add_next_and_user(request)
76. self.content_object = None
77. self.content_type = None
78. self.object_id = kwargs.get('object_id', None)
80. if kwargs.get('content_type'):
81. # Check if the user forged the URL and posted a non existant
82. # content type
83. try:
84. self.content_type = ContentType.objects.get(
85. model=kwargs.get('content_type'))
86. except ContentType.DoesNotExist:
87. raise Http404
89. if self.content_type:
90. # Check if the user forged the URL and tries to append the image to
91. # an object that does not exist
92. try:
93. self.content_object = \
94. self.content_type.get_object_for_this_type(
95. pk=self.object_id)
96. except ObjectDoesNotExist:
97. raise Http404
99. if self.content_object and hasattr(self.content_object, 'user'):
100. # Check if the user forged the URL and tries to append the image to
101. # an object that does not belong to him
102. if not self.content_object.user == self.user:
103. raise Http404
105. return super(CreateImageView, self).dispatch(request, *args, **kwargs)
107. def get_context_data(self, **kwargs):
108. ctx = super(CreateImageView, self).get_context_data(**kwargs)
109. ctx.update({
110. 'content_type': self.content_type,
111. 'object_id': self.object_id,
112. })
113. return ctx
115. def get_form_kwargs(self):
116. kwargs = super(CreateImageView, self).get_form_kwargs()
117. kwargs.update({
118. 'user': self.user,
119. 'content_type': self.content_type,
120. 'object_id': self.object_id,
121. })
122. return kwargs
125. class DeleteImageView(AjaxResponseMixin, UserMediaImageViewMixin, DeleteView):
126. """Deletes an `UserMediaImage` object."""
127. action = 'delete'
128. model = UserMediaImage
129. ajax_template_prefix = 'partials/ajax_'
131. @method_decorator(login_required)
132. def dispatch(self, request, *args, **kwargs):
133. """Adds useful objects to the class."""
134. self._add_next_and_user(request)
135. return super(DeleteImageView, self).dispatch(request, *args, **kwargs)
137. def get_context_data(self, **kwargs):
138. ctx = super(DeleteImageView, self).get_context_data(**kwargs)
139. ctx.update({
140. 'image_pk': self.object.pk,
141. })
142. return ctx
144. def get_queryset(self):
145. """
146. Making sure that a user can only delete his own images.
148. Even when he forges the request URL.
150. """
151. queryset = super(DeleteImageView, self).get_queryset()
152. queryset = queryset.filter(user=self.user)
153. return queryset
156. class UpdateImageView(AjaxResponseMixin, UserMediaImageViewMixin, UpdateView):
157. """Updates an existing `UserMediaImage` object."""
158. action = 'update'
159. model = UserMediaImage
160. form_class = UserMediaImageForm
161. ajax_template_prefix = 'partials/ajax_'
163. @method_decorator(login_required)
164. def dispatch(self, request, *args, **kwargs):
165. """Adds useful objects to the class."""
166. self._add_next_and_user(request)
167. return super(UpdateImageView, self).dispatch(request, *args, **kwargs)
169. def get_context_data(self, **kwargs):
170. ctx = super(UpdateImageView, self).get_context_data(**kwargs)
171. ctx.update({
172. 'content_type': self.object.content_type,
173. 'object_id': self.object.object_id,
174. 'image_pk': self.object.pk,
175. })
176. return ctx
178. def get_form_kwargs(self):
179. kwargs = super(UpdateImageView, self).get_form_kwargs()
180. kwargs.update({
181. 'user': self.user,
182. 'content_type': self.object.content_type,
183. 'object_id': self.object.object_id,
184. })
185. return kwargs
187. def get_queryset(self):
188. """
189. Making sure that a user can only edit his own images.
191. Even when he forges the request URL.
193. """
194. queryset = super(UpdateImageView, self).get_queryset()
195. queryset = queryset.filter(user=self.user)
196. return queryset
199. class AJAXMultipleImageUploadView(CreateView):
200. """Ajax view to handle the multiple image upload."""
201. model = UserMediaImage
202. form_class = UserMediaImageForm
204. @method_decorator(login_required)
205. def dispatch(self, request, *args, **kwargs):
206. self.obj_id = kwargs.get('obj_id', None)
207. self.user = request.user
209. if not request.is_ajax():
210. # Since we use a jquery modal and a jquery upload we should only
211. # allow ajax calls
212. raise Http404
214. # Check if the user posted a non existant content type
215. try:
216. self.c_type = ContentType.objects.get(model=kwargs.get('c_type'))
217. except ContentType.DoesNotExist:
218. raise Http404
220. # Check if the content object exists
221. try:
222. self.content_object = self.c_type.get_object_for_this_type(
223. pk=self.obj_id)
224. except ObjectDoesNotExist:
225. raise Http404
227. # Check for permissions
228. # Add a single user to the content object or prepare a user_can_edit
229. # function.
230. if (not hasattr(self.content_object, 'user')
231. or not self.content_object.user == self.user):
232. if (not hasattr(self.content_object, 'user_can_edit')
233. or not self.content_object.user_can_edit(self.user)):
234. raise Http404
235. return super(AJAXMultipleImageUploadView, self).dispatch(
236. request, *args, **kwargs)
238. def get_form_kwargs(self):
239. kwargs = super(AJAXMultipleImageUploadView, self).get_form_kwargs()
240. # Prepare context for UserMediaImage form
241. kwargs.update({
242. 'user': self.user,
243. 'content_type': self.c_type,
244. 'object_id': self.obj_id,
245. })
246. return kwargs
248. def form_valid(self, form):
249. # Check if maximum amount of pictures has been reached
250. try:
251. max_pictures = int(self.request.POST.get('maximum'))
252. except (TypeError, ValueError):
253. max_pictures = getattr(settings, 'USER_MEDIA_UPLOAD_MAXIMUM', 3)
254. stored_images = self.user.usermediaimage_set.filter(
255. object_id=self.obj_id, content_type=self.c_type)
256. if stored_images.count() >= max_pictures:
257. return HttpResponse(_('Maximum amount limit exceeded.'))
259. # Save the UserMediaImage
260. self.object = form.save()
261. f = self.request.FILES.get('image')
263. # Generate and get the thumbnail of the uploaded image
264. thumbnailer = get_thumbnailer(self.object.image.name)
265. thumb = thumbnailer.get_thumbnail({
266. 'crop': True, 'upscale': True,
267. 'size': self.object.small_size(as_string=False),
268. })
270. # Prepare context for the list item html
271. context_data = {
272. 'image': self.object,
273. 'mode': 'multiple',
274. }
275. context = RequestContext(self.request, context_data)
277. # Prepare the json response
278. data = {'files': [{
279. 'name': f.name,
280. 'url': self.object.image.url,
281. 'thumbnail_url': thumb.url,
282. 'list_item_html': render_to_string(
283. 'user_media/partials/image.html', context),
284. }]}
285. response = HttpResponse(dumps(data), mimetype='application/json')
286. response['Content-Disposition'] = 'inline; filename=files.json'
287. return response
290. class AJAXSingleImageUploadView(FormView):
291. """Ajax view to handle the single image upload."""
292. form_class = UserMediaImageSingleUploadForm
293. template_name = 'user_media/partials/image.html'
295. @method_decorator(login_required)
296. def dispatch(self, request, *args, **kwargs):
297. if not request.is_ajax() or not request.method == 'POST':
298. raise Http404
299. self.user = request.user
300. # Check if the user posted a non existant content type
301. try:
302. self.c_type = ContentType.objects.get(model=kwargs.get('c_type'))
303. except ContentType.DoesNotExist:
304. raise Http404
306. # Check if the content object exists
307. try:
308. self.content_object = self.c_type.get_object_for_this_type(
309. pk=kwargs.get('obj_id'))
310. except ObjectDoesNotExist:
311. raise Http404
313. # Check if content_object has the requested image field
314. if hasattr(self.content_object, kwargs.get('field')):
315. self.field_name = kwargs.get('field')
316. else:
317. raise Http404
319. # Check for permissions
320. if (not hasattr(self.content_object, 'user')
321. or not self.content_object.user == self.user):
322. if (not hasattr(self.content_object, 'user_can_edit')
323. or not self.content_object.user_can_edit(self.user)):
324. raise Http404
325. return super(AJAXSingleImageUploadView, self).dispatch(
326. request, *args, **kwargs)
328. def get_form_kwargs(self):
329. kwargs = super(AJAXSingleImageUploadView, self).get_form_kwargs()
330. kwargs.update({
331. 'instance': self.content_object,
332. 'image_field': self.field_name,
333. })
334. return kwargs
336. def form_valid(self, form):
337. # Save the image
338. self.content_object = form.save()
339. f = self.request.FILES.get(self.field_name)
340. image = getattr(self.content_object, self.field_name)
341. size = getattr(settings, 'USER_MEDIA_THUMB_SIZE_LARGE', (150, 150))
343. # Generate and get the thumbnail of the uploaded image
344. thumbnailer = get_thumbnailer(image.name)
345. thumb = thumbnailer.get_thumbnail({
346. 'crop': True, 'upscale': True,
347. 'size': size,
348. })
350. # Prepare context for the list item html
351. context_data = {
352. 'image': image,
353. 'mode': 'single',
354. 'size': (self.request.POST.get('size')
355. or u'{}x{}'.format(size[0], size[1])),
356. }
357. context = RequestContext(self.request, context_data)
359. # Prepare the json response
360. data = {'files': [{
361. 'name': f.name,
362. 'url': image.url,
363. 'thumbnail_url': thumb.url,
364. 'list_item_html': render_to_string(self.template_name, context),
365. }]}
366. response = HttpResponse(dumps(data), mimetype='application/json')
367. response['Content-Disposition'] = 'inline; filename=files.json'
368. return response
371. class AJAXImageCropView(UserMediaImageViewMixin, UpdateView):
372. """Ajax view to update an image's crop attributes."""
373. @method_decorator(login_required)
374. def dispatch(self, request, *args, **kwargs):
375. if not request.is_ajax() or not request.method == 'POST':
376. raise Http404
377. self.user = request.user
378. self.kwargs = kwargs
379. self.object = self.get_object()
380. if not self.object.user == self.user:
381. raise Http404
382. for field in ['x', 'x2', 'y', 'y2', 'w', 'h']:
383. # Save the Jcrop values to the image
384. setattr(self.object, 'thumb_' + field, request.POST.get(field))
385. self.object.save()
387. box = (
388. int(self.object.thumb_x),
389. int(self.object.thumb_y),
390. int(self.object.thumb_x2),
391. int(self.object.thumb_y2),
392. )
393. thumbnailer = get_thumbnailer(self.object.image.name)
394. thumb = thumbnailer.get_thumbnail({
395. 'box': box,
396. 'size': self.object.small_size(as_string=False),
397. })
398. return HttpResponse(thumb.url)