Merge branch 'develop' into gilbert-ext4
[philo.git] / philo / models / nodes.py
1 from inspect import getargspec
2 import mimetypes
3 from os.path import basename
4
5 from django.conf import settings
6 from django.contrib.contenttypes import generic
7 from django.contrib.contenttypes.models import ContentType
8 from django.contrib.sites.models import Site, RequestSite
9 from django.core.cache import cache
10 from django.core.exceptions import ValidationError
11 from django.core.servers.basehttp import FileWrapper
12 from django.core.urlresolvers import resolve, clear_url_caches, reverse, NoReverseMatch
13 from django.db import models
14 from django.http import HttpResponse, HttpResponseServerError, HttpResponseRedirect, Http404
15 from django.utils.encoding import smart_str
16
17 from philo.exceptions import MIDDLEWARE_NOT_CONFIGURED, ViewCanNotProvideSubpath, ViewDoesNotProvideSubpaths
18 from philo.models.base import SlugTreeEntity, Entity, register_value_model
19 from philo.models.fields import JSONField
20 from philo.utils import ContentTypeSubclassLimiter
21 from philo.utils.entities import LazyPassthroughAttributeMapper
22 from philo.signals import view_about_to_render, view_finished_rendering
23
24
25 __all__ = ('Node', 'View', 'MultiView', 'Redirect', 'File')
26
27
28 _view_content_type_limiter = ContentTypeSubclassLimiter(None)
29 CACHE_PHILO_ROOT = getattr(settings, "PHILO_CACHE_PHILO_ROOT", True)
30
31
32 class Node(SlugTreeEntity):
33         """
34         :class:`Node`\ s are the basic building blocks of a website using Philo. They define the URL hierarchy and connect each URL to a :class:`View` subclass instance which is used to generate an HttpResponse.
35         
36         """
37         view_content_type = models.ForeignKey(ContentType, related_name='node_view_set', limit_choices_to=_view_content_type_limiter, blank=True, null=True)
38         view_object_id = models.PositiveIntegerField(blank=True, null=True)
39         #: :class:`GenericForeignKey` to a non-abstract subclass of :class:`View`
40         view = generic.GenericForeignKey('view_content_type', 'view_object_id')
41         
42         @property
43         def accepts_subpath(self):
44                 """A property shortcut for :attr:`self.view.accepts_subpath <View.accepts_subpath>`"""
45                 if self.view_object_id and self.view_content_type_id:
46                         return ContentType.objects.get_for_id(self.view_content_type_id).model_class().accepts_subpath
47                 return False
48         
49         def handles_subpath(self, subpath):
50                 if self.view_object_id and self.view_content_type_id:
51                         return ContentType.objects.get_for_id(self.view_content_type_id).model_class().handles_subpath(subpath)
52                 return False
53         
54         def render_to_response(self, request, extra_context=None):
55                 """This is a shortcut method for :meth:`View.render_to_response`"""
56                 if self.view_object_id and self.view_content_type_id:
57                         view_model = ContentType.objects.get_for_id(self.view_content_type_id).model_class()
58                         self.view = view_model._default_manager.get(pk=self.view_object_id)
59                         return self.view.render_to_response(request, extra_context)
60                 raise Http404
61         
62         def get_absolute_url(self, request=None, with_domain=False, secure=False):
63                 """
64                 This is essentially a shortcut for calling :meth:`construct_url` without a subpath.
65                 
66                 :returns: The absolute url of the node on the current site.
67                 
68                 """
69                 return self.construct_url(request=request, with_domain=with_domain, secure=secure)
70         
71         def construct_url(self, subpath="/", request=None, with_domain=False, secure=False):
72                 """
73                 This method will do its best to construct a URL based on the Node's location. If with_domain is True, that URL will include a domain and a protocol; if secure is True as well, the protocol will be https. The request will be used to construct a domain in cases where a call to :meth:`Site.objects.get_current` fails.
74                 
75                 Node urls will not contain a trailing slash unless a subpath is provided which ends with a trailing slash. Subpaths are expected to begin with a slash, as if returned by :func:`django.core.urlresolvers.reverse`.
76                 
77                 Because this method will be called frequently and will always try to reverse ``philo-root``, the results of that reversal will be cached by default. This can be disabled by setting :setting:`PHILO_CACHE_PHILO_ROOT` to ``False``.
78                 
79                 :meth:`construct_url` may raise the following exceptions:
80                 
81                 - :class:`NoReverseMatch` if "philo-root" is not reversable -- for example, if :mod:`philo.urls` is not included anywhere in your urlpatterns.
82                 - :class:`Site.DoesNotExist <ObjectDoesNotExist>` if with_domain is True but no :class:`Site` or :class:`RequestSite` can be built.
83                 - :class:`~philo.exceptions.AncestorDoesNotExist` if the root node of the site isn't an ancestor of the node constructing the URL.
84                 
85                 :param string subpath: The subpath to be constructed beyond beyond the node's URL.
86                 :param request: :class:`HttpRequest` instance. Will be used to construct a :class:`RequestSite` if :meth:`Site.objects.get_current` fails.
87                 :param with_domain: Whether the constructed URL should include a domain name and protocol.
88                 :param secure: Whether the protocol, if included, should be http:// or https://.
89                 :returns: A constructed url for accessing the given subpath of the current node instance.
90                 
91                 """
92                 # Try reversing philo-root first, since we can't do anything if that fails.
93                 if CACHE_PHILO_ROOT:
94                         key = "CACHE_PHILO_ROOT__" + settings.ROOT_URLCONF
95                         root_url = cache.get(key)
96                         if root_url is None:
97                                 root_url = reverse('philo-root')
98                                 cache.set(key, root_url)
99                 else:
100                         root_url = reverse('philo-root')
101                 
102                 try:
103                         current_site = Site.objects.get_current()
104                 except Site.DoesNotExist:
105                         if request is not None:
106                                 current_site = RequestSite(request)
107                         elif with_domain:
108                                 # If they want a domain and we can't figure one out,
109                                 # best to reraise the error to let them know.
110                                 raise
111                         else:
112                                 current_site = None
113                 
114                 root = getattr(current_site, 'root_node', None)
115                 path = self.get_path(root=root)
116                 
117                 if current_site and with_domain:
118                         domain = "http%s://%s" % (secure and "s" or "", current_site.domain)
119                 else:
120                         domain = ""
121                 
122                 if not path or subpath == "/":
123                         subpath = subpath[1:]
124                 
125                 return '%s%s%s%s' % (domain, root_url, path, subpath)
126         
127         class Meta(SlugTreeEntity.Meta):
128                 app_label = 'philo'
129
130
131 # the following line enables the selection of a node as the root for a given django.contrib.sites Site object
132 models.ForeignKey(Node, related_name='sites', null=True, blank=True).contribute_to_class(Site, 'root_node')
133
134
135 class View(Entity):
136         """
137         :class:`View` is an abstract model that represents an item which can be "rendered", generally in response to an :class:`HttpRequest`.
138         
139         """
140         #: A generic relation back to nodes.
141         nodes = generic.GenericRelation(Node, content_type_field='view_content_type', object_id_field='view_object_id')
142         
143         #: An attribute on the class which defines whether this :class:`View` can handle subpaths. Default: ``False``
144         accepts_subpath = False
145         
146         @classmethod
147         def handles_subpath(cls, subpath):
148                 """Returns True if the :class:`View` handles the given subpath, and False otherwise."""
149                 if not cls.accepts_subpath and subpath != "/":
150                         return False
151                 return True
152         
153         def reverse(self, view_name=None, args=None, kwargs=None, node=None, obj=None):
154                 """
155                 If :attr:`accepts_subpath` is True, try to reverse a URL using the given parameters using ``self`` as the urlconf.
156                 
157                 If ``obj`` is provided, :meth:`get_reverse_params` will be called and the results will be combined with any ``view_name``, ``args``, and ``kwargs`` that may have been passed in.
158                 
159                 :param view_name: The name of the view to be reversed.
160                 :param args: Extra args for reversing the view.
161                 :param kwargs: A dictionary of arguments for reversing the view.
162                 :param node: The node whose subpath this is.
163                 :param obj: An object to be passed to :meth:`get_reverse_params` to generate a view_name, args, and kwargs for reversal.
164                 :returns: A subpath beyond the node that reverses the view, or an absolute url that reverses the view if a node was passed in.
165                 :except philo.exceptions.ViewDoesNotProvideSubpaths: if :attr:`accepts_subpath` is False
166                 :except philo.exceptions.ViewCanNotProvideSubpath: if a reversal is not possible.
167                 
168                 """
169                 if not self.accepts_subpath:
170                         raise ViewDoesNotProvideSubpaths
171                 
172                 if obj is not None:
173                         # Perhaps just override instead of combining?
174                         obj_view_name, obj_args, obj_kwargs = self.get_reverse_params(obj)
175                         if view_name is None:
176                                 view_name = obj_view_name
177                         args = list(obj_args) + list(args or [])
178                         obj_kwargs.update(kwargs or {})
179                         kwargs = obj_kwargs
180                 
181                 try:
182                         subpath = reverse(view_name, urlconf=self, args=args or [], kwargs=kwargs or {})
183                 except NoReverseMatch, e:
184                         raise ViewCanNotProvideSubpath(e.message)
185                 
186                 if node is not None:
187                         return node.construct_url(subpath)
188                 return subpath
189         
190         def get_reverse_params(self, obj):
191                 """
192                 This method is not implemented on the base class. It should return a (``view_name``, ``args``, ``kwargs``) tuple suitable for reversing a url for the given ``obj`` using ``self`` as the urlconf. If a reversal will not be possible, this method should raise :class:`~philo.exceptions.ViewCanNotProvideSubpath`.
193                 
194                 """
195                 raise NotImplementedError("View subclasses must implement get_reverse_params to support subpaths.")
196         
197         def attributes_with_node(self, node, mapper=LazyPassthroughAttributeMapper):
198                 """
199                 Returns a :class:`LazyPassthroughAttributeMapper` which can be used to directly retrieve the values of :class:`Attribute`\ s related to the :class:`View`, falling back on the :class:`Attribute`\ s of the passed-in :class:`Node` and its ancestors.
200                 
201                 """
202                 return mapper((self, node))
203         
204         def render_to_response(self, request, extra_context=None):
205                 """
206                 Renders the :class:`View` as an :class:`HttpResponse`. This will raise :const:`~philo.exceptions.MIDDLEWARE_NOT_CONFIGURED` if the `request` doesn't have an attached :class:`Node`. This can happen if the :class:`~philo.middleware.RequestNodeMiddleware` is not in :setting:`settings.MIDDLEWARE_CLASSES` or if it is not functioning correctly.
207                 
208                 :meth:`render_to_response` will send the :data:`~philo.signals.view_about_to_render` signal, then call :meth:`actually_render_to_response`, and finally send the :data:`~philo.signals.view_finished_rendering` signal before returning the ``response``.
209
210                 """
211                 if not hasattr(request, 'node'):
212                         raise MIDDLEWARE_NOT_CONFIGURED
213                 
214                 extra_context = extra_context or {}
215                 view_about_to_render.send(sender=self, request=request, extra_context=extra_context)
216                 response = self.actually_render_to_response(request, extra_context)
217                 view_finished_rendering.send(sender=self, response=response)
218                 return response
219         
220         def actually_render_to_response(self, request, extra_context=None):
221                 """Concrete subclasses must override this method to provide the business logic for turning a ``request`` and ``extra_context`` into an :class:`HttpResponse`."""
222                 raise NotImplementedError('View subclasses must implement actually_render_to_response.')
223         
224         class Meta:
225                 abstract = True
226
227
228 _view_content_type_limiter.cls = View
229
230
231 class MultiView(View):
232         """
233         :class:`MultiView` is an abstract model which represents a section of related pages - for example, a :class:`~philo.contrib.penfield.BlogView` might have a foreign key to :class:`Page`\ s for an index, an entry detail, an entry archive by day, and so on. :class:`!MultiView` subclasses :class:`View`, and defines the following additional methods and attributes:
234         
235         """
236         #: Same as :attr:`View.accepts_subpath`. Default: ``True``
237         accepts_subpath = True
238         
239         @property
240         def urlpatterns(self):
241                 """Returns urlpatterns that point to views (generally methods on the class). :class:`MultiView`\ s can be thought of as "managing" these subpaths."""
242                 raise NotImplementedError("MultiView subclasses must implement urlpatterns.")
243         
244         def actually_render_to_response(self, request, extra_context=None):
245                 """
246                 Resolves the remaining subpath left after finding this :class:`View`'s node using :attr:`self.urlpatterns <urlpatterns>` and renders the view function (or method) found with the appropriate args and kwargs.
247                 
248                 """
249                 clear_url_caches()
250                 subpath = request.node._subpath
251                 view, args, kwargs = resolve(subpath, urlconf=self)
252                 view_args = getargspec(view)
253                 if extra_context is not None and ('extra_context' in view_args[0] or view_args[2] is not None):
254                         if 'extra_context' in kwargs:
255                                 extra_context.update(kwargs['extra_context'])
256                         kwargs['extra_context'] = extra_context
257                 return view(request, *args, **kwargs)
258         
259         def get_context(self):
260                 """Hook for providing instance-specific context - such as the value of a Field - to any view methods on the instance."""
261                 return {}
262         
263         def basic_view(self, field_name):
264                 """
265                 Given the name of a field on the class, accesses the value of
266                 that field and treats it as a ``View`` instance. Creates a
267                 basic context based on self.get_context() and any extra_context
268                 that was passed in, then calls the ``View`` instance's
269                 render_to_response() method. This method is meant to be called
270                 to return a view function appropriate for urlpatterns.
271                 
272                 :param field_name: The name of a field on the instance which contains a :class:`View` subclass instance.
273                 :returns: A simple view function.
274                 
275                 Example::
276                         
277                         class Foo(Multiview):
278                                 page = models.ForeignKey(Page)
279                                 
280                                 @property
281                                 def urlpatterns(self):
282                                         urlpatterns = patterns('',
283                                                 url(r'^$', self.basic_view('page'))
284                                         )
285                                         return urlpatterns
286                 
287                 """
288                 field = self._meta.get_field(field_name)
289                 view = getattr(self, field.name, None)
290                 
291                 def inner(request, extra_context=None, **kwargs):
292                         if not view:
293                                 raise Http404
294                         context = self.get_context()
295                         context.update(extra_context or {})
296                         return view.render_to_response(request, extra_context=context)
297                 
298                 return inner
299         
300         class Meta:
301                 abstract = True
302
303
304 class TargetURLModel(models.Model):
305         """An abstract parent class for models which deal in targeting a url."""
306         #: An optional :class:`ForeignKey` to a :class:`.Node`. If provided, that node will be used as the basis for the redirect.
307         target_node = models.ForeignKey(Node, blank=True, null=True, related_name="%(app_label)s_%(class)s_related")
308         #: A :class:`CharField` which may contain an absolute or relative URL, or the name of a node's subpath.
309         url_or_subpath = models.CharField(max_length=200, blank=True, help_text="Point to this url or, if a node is defined and accepts subpaths, this subpath of the node.")
310         #: A :class:`~philo.models.fields.JSONField` instance. If the value of :attr:`reversing_parameters` is not None, the :attr:`url_or_subpath` will be treated as the name of a view to be reversed. The value of :attr:`reversing_parameters` will be passed into the reversal as args if it is a list or as kwargs if it is a dictionary. Otherwise it will be ignored.
311         reversing_parameters = JSONField(blank=True, help_text="If reversing parameters are defined, url_or_subpath will instead be interpreted as the view name to be reversed.")
312         
313         def clean(self):
314                 if not self.target_node and not self.url_or_subpath:
315                         raise ValidationError("Either a target node or a url must be defined.")
316                 
317                 if self.reversing_parameters and not (self.url_or_subpath or self.target_node):
318                         raise ValidationError("Reversing parameters require either a view name or a target node.")
319                 
320                 try:
321                         self.get_target_url()
322                 except (NoReverseMatch, ViewCanNotProvideSubpath), e:
323                         raise ValidationError(e.message)
324                 
325                 super(TargetURLModel, self).clean()
326         
327         def get_reverse_params(self):
328                 params = self.reversing_parameters
329                 args = kwargs = None
330                 if isinstance(params, list):
331                         args = params
332                 elif isinstance(params, dict):
333                         # Convert unicode keys to strings for Python < 2.6.5. Compare
334                         # http://stackoverflow.com/questions/4598604/how-to-pass-unicode-keywords-to-kwargs
335                         kwargs = dict([(smart_str(k, 'ascii'), v) for k, v in params.items()])
336                 return self.url_or_subpath, args, kwargs
337         
338         def get_target_url(self, memoize=True):
339                 """Calculates and returns the target url based on the :attr:`target_node`, :attr:`url_or_subpath`, and :attr:`reversing_parameters`. The results will be memoized by default; this can be prevented by passing in ``memoize=False``."""
340                 if memoize:
341                         memo_args = (self.target_node_id, self.url_or_subpath, self.reversing_parameters_json)
342                         try:
343                                 return self._target_url_memo[memo_args]
344                         except AttributeError:
345                                 self._target_url_memo = {}
346                         except KeyError:
347                                 pass
348                 
349                 node = self.target_node
350                 if node is not None and node.accepts_subpath and self.url_or_subpath:
351                         if self.reversing_parameters is not None:
352                                 view_name, args, kwargs = self.get_reverse_params()
353                                 subpath = node.view.reverse(view_name, args=args, kwargs=kwargs)
354                         else:
355                                 subpath = self.url_or_subpath
356                                 if subpath[0] != '/':
357                                         subpath = '/' + subpath
358                         target_url = node.construct_url(subpath)
359                 elif node is not None:
360                         target_url = node.get_absolute_url()
361                 else:
362                         if self.reversing_parameters is not None:
363                                 view_name, args, kwargs = self.get_reverse_params()
364                                 target_url = reverse(view_name, args=args, kwargs=kwargs)
365                         else:
366                                 target_url = self.url_or_subpath
367                 
368                 if memoize:
369                         self._target_url_memo[memo_args] = target_url
370                 return target_url
371         target_url = property(get_target_url)
372         
373         class Meta:
374                 abstract = True
375
376
377 class Redirect(TargetURLModel, View):
378         """Represents a 301 or 302 redirect to a different url on an absolute or relative path."""
379         #: A choices tuple of redirect status codes (temporary or permanent).
380         STATUS_CODES = (
381                 (302, 'Temporary'),
382                 (301, 'Permanent'),
383         )
384         #: An :class:`IntegerField` which uses :attr:`STATUS_CODES` as its choices. Determines whether the redirect is considered temporary or permanent.
385         status_code = models.IntegerField(choices=STATUS_CODES, default=302, verbose_name='redirect type')
386         
387         def actually_render_to_response(self, request, extra_context=None):
388                 """Returns an :class:`HttpResponseRedirect` to :attr:`self.target_url`."""
389                 response = HttpResponseRedirect(self.target_url)
390                 response.status_code = self.status_code
391                 return response
392         
393         class Meta:
394                 app_label = 'philo'
395
396
397 class File(View):
398         """Stores an arbitrary file."""
399         #: The name of the uploaded file. This is meant for finding the file again later, not for display.
400         name = models.CharField(max_length=255)
401         #: Defines the mimetype of the uploaded file. This will not be validated. If no mimetype is provided, it will be automatically generated based on the filename.
402         mimetype = models.CharField(max_length=255, blank=True)
403         #: Contains the uploaded file. Files are uploaded to ``philo/files/%Y/%m/%d``.
404         file = models.FileField(upload_to='philo/files/%Y/%m/%d')
405         
406         def clean(self):
407                 if not self.mimetype:
408                         self.mimetype = mimetypes.guess_type(self.file.name, strict=False)[0]
409                         if self.mimetype is None:
410                                 raise ValidationError("Unknown file type.")
411         
412         def actually_render_to_response(self, request, extra_context=None):
413                 wrapper = FileWrapper(self.file)
414                 response = HttpResponse(wrapper, content_type=self.mimetype)
415                 response['Content-Length'] = self.file.size
416                 response['Content-Disposition'] = "inline; filename=%s" % basename(self.file.name)
417                 return response
418         
419         class Meta:
420                 app_label = 'philo'
421         
422         def __unicode__(self):
423                 """Returns the value of :attr:`File.name`."""
424                 return self.name
425
426
427 register_value_model(Node)