philo/models/nodes.py

   1 from inspect import getargspec
   2
   3 from django.contrib.contenttypes import generic
   4 from django.contrib.contenttypes.models import ContentType
   5 from django.contrib.sites.models import Site, RequestSite
   6 from django.core.exceptions import ValidationError
   7 from django.core.servers.basehttp import FileWrapper
   8 from django.core.urlresolvers import resolve, clear_url_caches, reverse, NoReverseMatch
   9 from django.db import models
  10 from django.http import HttpResponse, HttpResponseServerError, HttpResponseRedirect, Http404
  11 from django.template import add_to_builtins as register_templatetags
  12 from django.utils.encoding import smart_str
  13
  14 from philo.exceptions import MIDDLEWARE_NOT_CONFIGURED, ViewCanNotProvideSubpath, ViewDoesNotProvideSubpaths
  15 from philo.models.base import TreeEntity, Entity, QuerySetMapper, register_value_model
  16 from philo.models.fields import JSONField
  17 from philo.utils import ContentTypeSubclassLimiter
  18 from philo.validators import RedirectValidator
  19 from philo.signals import view_about_to_render, view_finished_rendering
  20
  21
  22 _view_content_type_limiter = ContentTypeSubclassLimiter(None)
  23
  24
  25 class Node(TreeEntity):
  26         view_content_type = models.ForeignKey(ContentType, related_name='node_view_set', limit_choices_to=_view_content_type_limiter)
  27         view_object_id = models.PositiveIntegerField()
  28         view = generic.GenericForeignKey('view_content_type', 'view_object_id')
  29
  30         @property
  31         def accepts_subpath(self):
  32                 if self.view:
  33                         return self.view.accepts_subpath
  34                 return False
  35
  36         def handles_subpath(self, subpath):
  37                 return self.view.handles_subpath(subpath)
  38
  39         def render_to_response(self, request, extra_context=None):
  40                 return self.view.render_to_response(request, extra_context)
  41
  42         def get_absolute_url(self, request=None, with_domain=False, secure=False):
  43                 return self.construct_url(request=request, with_domain=with_domain, secure=secure)
  44
  45         def construct_url(self, subpath="/", request=None, with_domain=False, secure=False):
  46                 """
  47                 This method will construct a URL based on the Node's location.
  48                 If a request is passed in, that will be used as a backup in case
  49                 the Site lookup fails. The Site lookup takes precedence because
  50                 it's what's used to find the root node. This will raise:
  51                 - NoReverseMatch if philo-root is not reverseable
  52                 - Site.DoesNotExist if a domain is requested but not buildable.
  53                 - AncestorDoesNotExist if the root node of the site isn't an
  54                   ancestor of this instance.
  55                 """
  56                 # Try reversing philo-root first, since we can't do anything if that fails.
  57                 root_url = reverse('philo-root')
  58
  59                 try:
  60                         current_site = Site.objects.get_current()
  61                 except Site.DoesNotExist:
  62                         if request is not None:
  63                                 current_site = RequestSite(request)
  64                         elif with_domain:
  65                                 # If they want a domain and we can't figure one out,
  66                                 # best to reraise the error to let them know.
  67                                 raise
  68                         else:
  69                                 current_site = None
  70
  71                 root = getattr(current_site, 'root_node', None)
  72                 path = self.get_path(root=root)
  73
  74                 if current_site and with_domain:
  75                         domain = "http%s://%s" % (secure and "s" or "", current_site.domain)
  76                 else:
  77                         domain = ""
  78
  79                 if not path or subpath == "/":
  80                         subpath = subpath[1:]
  81
  82                 return '%s%s%s%s' % (domain, root_url, path, subpath)
  83
  84         class Meta:
  85                 app_label = 'philo'
  86
  87
  88 # the following line enables the selection of a node as the root for a given django.contrib.sites Site object
  89 models.ForeignKey(Node, related_name='sites', null=True, blank=True).contribute_to_class(Site, 'root_node')
  90
  91
  92 class View(Entity):
  93         nodes = generic.GenericRelation(Node, content_type_field='view_content_type', object_id_field='view_object_id')
  94
  95         accepts_subpath = False
  96
  97         def handles_subpath(self, subpath):
  98                 if not self.accepts_subpath and subpath != "/":
  99                         return False
 100                 return True
 101
 102         def reverse(self, view_name=None, args=None, kwargs=None, node=None, obj=None):
 103                 """Shortcut method to handle the common pattern of getting the
 104                 absolute url for a view's subpaths."""
 105                 if not self.accepts_subpath:
 106                         raise ViewDoesNotProvideSubpaths
 107
 108                 if obj is not None:
 109                         # Perhaps just override instead of combining?
 110                         obj_view_name, obj_args, obj_kwargs = self.get_reverse_params(obj)
 111                         if view_name is None:
 112                                 view_name = obj_view_name
 113                         args = list(obj_args) + list(args or [])
 114                         obj_kwargs.update(kwargs or {})
 115                         kwargs = obj_kwargs
 116
 117                 try:
 118                         subpath = reverse(view_name, urlconf=self, args=args or [], kwargs=kwargs or {})
 119                 except NoReverseMatch, e:
 120                         raise ViewCanNotProvideSubpath(e.message)
 121
 122                 if node is not None:
 123                         return node.construct_url(subpath)
 124                 return subpath
 125
 126         def get_reverse_params(self, obj):
 127                 """This method should return a view_name, args, kwargs tuple suitable for reversing a url for the given obj using self as the urlconf."""
 128                 raise NotImplementedError("View subclasses must implement get_reverse_params to support subpaths.")
 129
 130         def attributes_with_node(self, node):
 131                 return QuerySetMapper(self.attribute_set, passthrough=node.attributes)
 132
 133         def render_to_response(self, request, extra_context=None):
 134                 if not hasattr(request, 'node'):
 135                         raise MIDDLEWARE_NOT_CONFIGURED
 136
 137                 extra_context = extra_context or {}
 138                 view_about_to_render.send(sender=self, request=request, extra_context=extra_context)
 139                 response = self.actually_render_to_response(request, extra_context)
 140                 view_finished_rendering.send(sender=self, response=response)
 141                 return response
 142
 143         def actually_render_to_response(self, request, extra_context=None):
 144                 raise NotImplementedError('View subclasses must implement actually_render_to_response.')
 145
 146         class Meta:
 147                 abstract = True
 148
 149
 150 _view_content_type_limiter.cls = View
 151
 152
 153 class MultiView(View):
 154         accepts_subpath = True
 155
 156         @property
 157         def urlpatterns(self):
 158                 raise NotImplementedError("MultiView subclasses must implement urlpatterns.")
 159
 160         def handles_subpath(self, subpath):
 161                 if not super(MultiView, self).handles_subpath(subpath):
 162                         return False
 163                 try:
 164                         resolve(subpath, urlconf=self)
 165                 except Http404:
 166                         return False
 167                 return True
 168
 169         def actually_render_to_response(self, request, extra_context=None):
 170                 clear_url_caches()
 171                 subpath = request.node.subpath
 172                 view, args, kwargs = resolve(subpath, urlconf=self)
 173                 view_args = getargspec(view)
 174                 if extra_context is not None and ('extra_context' in view_args[0] or view_args[2] is not None):
 175                         if 'extra_context' in kwargs:
 176                                 extra_context.update(kwargs['extra_context'])
 177                         kwargs['extra_context'] = extra_context
 178                 return view(request, *args, **kwargs)
 179
 180         def get_context(self):
 181                 """Hook for providing instance-specific context - such as the value of a Field - to all views."""
 182                 return {}
 183
 184         def basic_view(self, field_name):
 185                 """
 186                 Given the name of a field on ``self``, accesses the value of
 187                 that field and treats it as a ``View`` instance. Creates a
 188                 basic context based on self.get_context() and any extra_context
 189                 that was passed in, then calls the ``View`` instance's
 190                 render_to_response() method. This method is meant to be called
 191                 to return a view function appropriate for urlpatterns.
 192                 """
 193                 field = self._meta.get_field(field_name)
 194                 view = getattr(self, field.name, None)
 195
 196                 def inner(request, extra_context=None, **kwargs):
 197                         if not view:
 198                                 raise Http404
 199                         context = self.get_context()
 200                         context.update(extra_context or {})
 201                         return view.render_to_response(request, extra_context=context)
 202
 203                 return inner
 204
 205         class Meta:
 206                 abstract = True
 207
 208
 209 class TargetURLModel(models.Model):
 210         target_node = models.ForeignKey(Node, blank=True, null=True, related_name="%(app_label)s_%(class)s_related")
 211         url_or_subpath = models.CharField(max_length=200, validators=[RedirectValidator()], blank=True, help_text="Point to this url or, if a node is defined and accepts subpaths, this subpath of the node.")
 212         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.")
 213
 214         def clean(self):
 215                 if not self.target_node and not self.url_or_subpath:
 216                         raise ValidationError("Either a target node or a url must be defined.")
 217
 218                 if self.reversing_parameters and not (self.url_or_subpath or self.target_node):
 219                         raise ValidationError("Reversing parameters require either a view name or a target node.")
 220
 221                 try:
 222                         self.get_target_url()
 223                 except (NoReverseMatch, ViewCanNotProvideSubpath), e:
 224                         raise ValidationError(e.message)
 225
 226                 super(TargetURLModel, self).clean()
 227
 228         def get_reverse_params(self):
 229                 params = self.reversing_parameters
 230                 args = kwargs = None
 231                 if isinstance(params, list):
 232                         args = params
 233                 elif isinstance(params, dict):
 234                         # Convert unicode keys to strings for Python < 2.6.5. Compare
 235                         # http://stackoverflow.com/questions/4598604/how-to-pass-unicode-keywords-to-kwargs
 236                         kwargs = dict([(smart_str(k, 'ascii'), v) for k, v in params.items()])
 237                 return self.url_or_subpath, args, kwargs
 238
 239         def get_target_url(self):
 240                 node = self.target_node
 241                 if node is not None and node.accepts_subpath and self.url_or_subpath:
 242                         if self.reversing_parameters is not None:
 243                                 view_name, args, kwargs = self.get_reverse_params()
 244                                 subpath = node.view.reverse(view_name, args=args, kwargs=kwargs)
 245                         else:
 246                                 subpath = self.url_or_subpath
 247                                 if subpath[0] != '/':
 248                                         subpath = '/' + subpath
 249                         return node.construct_url(subpath)
 250                 elif node is not None:
 251                         return node.get_absolute_url()
 252                 else:
 253                         if self.reversing_parameters is not None:
 254                                 view_name, args, kwargs = self.get_reverse_params()
 255                                 return reverse(view_name, args=args, kwargs=kwargs)
 256                         return self.url_or_subpath
 257         target_url = property(get_target_url)
 258
 259         class Meta:
 260                 abstract = True
 261
 262
 263 class Redirect(TargetURLModel, View):
 264         STATUS_CODES = (
 265                 (302, 'Temporary'),
 266                 (301, 'Permanent'),
 267         )
 268         status_code = models.IntegerField(choices=STATUS_CODES, default=302, verbose_name='redirect type')
 269
 270         def actually_render_to_response(self, request, extra_context=None):
 271                 response = HttpResponseRedirect(self.target_url)
 272                 response.status_code = self.status_code
 273                 return response
 274
 275         class Meta:
 276                 app_label = 'philo'
 277
 278
 279 class File(View):
 280         """ For storing arbitrary files """
 281
 282         mimetype = models.CharField(max_length=255)
 283         file = models.FileField(upload_to='philo/files/%Y/%m/%d')
 284
 285         def actually_render_to_response(self, request, extra_context=None):
 286                 wrapper = FileWrapper(self.file)
 287                 response = HttpResponse(wrapper, content_type=self.mimetype)
 288                 response['Content-Length'] = self.file.size
 289                 return response
 290
 291         class Meta:
 292                 app_label = 'philo'
 293
 294         def __unicode__(self):
 295                 return self.file.name
 296
 297
 298 register_templatetags('philo.templatetags.nodes')
 299 register_value_model(Node)