models.py

   1 # encoding: utf-8
   2 from django.utils.translation import ugettext_lazy as _
   3 from django.contrib.auth.models import User, Group
   4 from django.contrib.contenttypes import generic
   5 from django.contrib.contenttypes.models import ContentType
   6 from django.db import models
   7 from django.contrib.sites.models import Site
   8 from philo.utils import fattr
   9 from django.template import add_to_builtins as register_templatetags
  10 from django.template import Template as DjangoTemplate
  11 from django.template import TemplateDoesNotExist
  12 from django.template import Context, RequestContext
  13 from django.core.exceptions import ObjectDoesNotExist
  14 from django.utils import simplejson as json
  15 from UserDict import DictMixin
  16 from philo.templatetags.containers import ContainerNode
  17 from django.template.loader_tags import ExtendsNode, ConstantIncludeNode, IncludeNode
  18 from django.template.loader import get_template
  19 from django.http import Http404, HttpResponse, HttpResponseServerError, HttpResponseRedirect
  20 from django.core.servers.basehttp import FileWrapper
  21 from django.conf import settings
  22
  23
  24 def register_value_model(model):
  25         pass
  26
  27
  28 def unregister_value_model(model):
  29         pass
  30
  31
  32 class Attribute(models.Model):
  33         entity_content_type = models.ForeignKey(ContentType, verbose_name='Entity type')
  34         entity_object_id = models.PositiveIntegerField(verbose_name='Entity ID')
  35         entity = generic.GenericForeignKey('entity_content_type', 'entity_object_id')
  36         key = models.CharField(max_length=255)
  37         json_value = models.TextField(verbose_name='Value (JSON)', help_text='This value must be valid JSON.')
  38
  39         def get_value(self):
  40                 return json.loads(self.json_value)
  41
  42         def set_value(self, value):
  43                 self.json_value = json.dumps(value)
  44
  45         def delete_value(self):
  46                 self.json_value = json.dumps(None)
  47
  48         value = property(get_value, set_value, delete_value)
  49
  50         def __unicode__(self):
  51                 return u'"%s": %s' % (self.key, self.value)
  52
  53
  54 class Relationship(models.Model):
  55         entity_content_type = models.ForeignKey(ContentType, related_name='relationship_entity_set', verbose_name='Entity type')
  56         entity_object_id = models.PositiveIntegerField(verbose_name='Entity ID')
  57         entity = generic.GenericForeignKey('entity_content_type', 'entity_object_id')
  58         key = models.CharField(max_length=255)
  59         value_content_type = models.ForeignKey(ContentType, related_name='relationship_value_set', verbose_name='Value type')
  60         value_object_id = models.PositiveIntegerField(verbose_name='Value ID')
  61         value = generic.GenericForeignKey('value_content_type', 'value_object_id')
  62
  63         def __unicode__(self):
  64                 return u'"%s": %s' % (self.key, self.value)
  65
  66
  67 class QuerySetMapper(object, DictMixin):
  68         def __init__(self, queryset, passthrough=None):
  69                 self.queryset = queryset
  70                 self.passthrough = passthrough
  71         def __getitem__(self, key):
  72                 try:
  73                         return self.queryset.get(key__exact=key).value
  74                 except ObjectDoesNotExist:
  75                         if self.passthrough:
  76                                 return self.passthrough.__getitem__(key)
  77                         raise KeyError
  78         def keys(self):
  79                 keys = set(self.queryset.values_list('key', flat=True).distinct())
  80                 if self.passthrough:
  81                         keys += set(self.passthrough.keys())
  82                 return list(keys)
  83
  84
  85 class Entity(models.Model):
  86         attribute_set = generic.GenericRelation(Attribute, content_type_field='entity_content_type', object_id_field='entity_object_id')
  87         relationship_set = generic.GenericRelation(Relationship, content_type_field='entity_content_type', object_id_field='entity_object_id')
  88
  89         @property
  90         def attributes(self):
  91                 return QuerySetMapper(self.attribute_set)
  92
  93         @property
  94         def relationships(self):
  95                 return QuerySetMapper(self.relationship_set)
  96
  97         class Meta:
  98                 abstract = True
  99
 100
 101 class Collection(models.Model):
 102         name = models.CharField(max_length=255)
 103         description = models.TextField(blank=True, null=True)
 104
 105         @fattr(short_description='Members')
 106         def get_count(self):
 107                 return self.members.count()
 108
 109         def __unicode__(self):
 110                 return self.name
 111
 112
 113 class CollectionMemberManager(models.Manager):
 114         use_for_related_fields = True
 115
 116         def with_model(self, model):
 117                 return model._default_manager.filter(pk__in=self.filter(member_content_type=ContentType.objects.get_for_model(model)).values_list('member_object_id', flat=True))
 118
 119
 120 class CollectionMember(models.Model):
 121         objects = CollectionMemberManager()
 122         collection = models.ForeignKey(Collection, related_name='members')
 123         index = models.PositiveIntegerField(verbose_name='Index', help_text='This will determine the ordering of the item within the collection. (Optional)', null=True, blank=True)
 124         member_content_type = models.ForeignKey(ContentType, verbose_name='Member type')
 125         member_object_id = models.PositiveIntegerField(verbose_name='Member ID')
 126         member = generic.GenericForeignKey('member_content_type', 'member_object_id')
 127
 128         def __unicode__(self):
 129                 return u'%s - %s' % (self.collection, self.member)
 130
 131
 132 class TreeManager(models.Manager):
 133         use_for_related_fields = True
 134
 135         def roots(self):
 136                 return self.filter(parent__isnull=True)
 137
 138         def get_with_path(self, path, root=None, absolute_result=True, pathsep='/'):
 139                 """
 140                 Returns the object with the path, or None if there is no object with that path,
 141                 unless absolute_result is set to False, in which case it returns a tuple containing
 142                 the deepest object found along the path, and the remainder of the path after that
 143                 object as a string (or None in the case that there is no remaining path).
 144                 """
 145                 slugs = path.split(pathsep)
 146                 obj = root
 147                 remaining_slugs = list(slugs)
 148                 remainder = None
 149                 for slug in slugs:
 150                         remaining_slugs.remove(slug)
 151                         if slug: # ignore blank slugs, handles for multiple consecutive pathseps
 152                                 try:
 153                                         obj = self.get(slug__exact=slug, parent__exact=obj)
 154                                 except self.model.DoesNotExist:
 155                                         if absolute_result:
 156                                                 obj = None
 157                                         remaining_slugs.insert(0, slug)
 158                                         remainder = pathsep.join(remaining_slugs)
 159                                         break
 160                 if obj:
 161                         if absolute_result:
 162                                 return obj
 163                         else:
 164                                 return (obj, remainder)
 165                 raise self.model.DoesNotExist('%s matching query does not exist.' % self.model._meta.object_name)
 166
 167
 168 class TreeModel(models.Model):
 169         objects = TreeManager()
 170         parent = models.ForeignKey('self', related_name='children', null=True, blank=True)
 171         slug = models.SlugField()
 172
 173         def get_path(self, pathsep='/', field='slug'):
 174                 path = getattr(self, field, '?')
 175                 parent = self.parent
 176                 while parent:
 177                         path = getattr(parent, field, '?') + pathsep + path
 178                         parent = parent.parent
 179                 return path
 180         path = property(get_path)
 181
 182         def __unicode__(self):
 183                 return self.path
 184
 185         class Meta:
 186                 abstract = True
 187
 188
 189 class TreeEntity(TreeModel, Entity):
 190         @property
 191         def attributes(self):
 192                 if self.parent:
 193                         return QuerySetMapper(self.attribute_set, passthrough=self.parent.attributes)
 194                 return super(TreeEntity, self).attributes
 195
 196         @property
 197         def relationships(self):
 198                 if self.parent:
 199                         return QuerySetMapper(self.relationship_set, passthrough=self.parent.relationships)
 200                 return super(TreeEntity, self).relationships
 201
 202         class Meta:
 203                 abstract = True
 204
 205
 206 class InheritableTreeEntity(TreeEntity):
 207         instance_type = models.ForeignKey(ContentType, editable=False)
 208
 209         def save(self, force_insert=False, force_update=False):
 210                 if not hasattr(self, 'instance_type_ptr'):
 211                         self.instance_type = ContentType.objects.get_for_model(self.__class__)
 212                 super(InheritableTreeEntity, self).save(force_insert, force_update)
 213
 214         @property
 215         def instance(self):
 216                 return self.instance_type.get_object_for_this_type(id=self.id)
 217
 218         def get_path(self, pathsep='/', field='slug'):
 219                 path = getattr(self.instance, field, '?')
 220                 parent = self.parent
 221                 while parent:
 222                         path = getattr(parent.instance, field, '?') + pathsep + path
 223                         parent = parent.parent
 224                 return path
 225         path = property(get_path)
 226
 227         @property
 228         def attributes(self):
 229                 if self.parent:
 230                         return QuerySetMapper(self.instance.attribute_set, passthrough=self.parent.instance.attributes)
 231                 return QuerySetMapper(self.instance.attribute_set)
 232
 233         @property
 234         def relationships(self):
 235                 if self.parent:
 236                         return QuerySetMapper(self.instance.relationship_set, passthrough=self.parent.instance.relationships)
 237                 return QuerySetMapper(self.instance.relationship_set)
 238
 239         class Meta:
 240                 abstract = True
 241
 242
 243 class Node(InheritableTreeEntity):
 244         accepts_subpath = False
 245
 246         def render_to_response(self, request, path=None, subpath=None):
 247                 return HttpResponseServerError()
 248
 249         class Meta:
 250                 unique_together = (('parent', 'slug'),)
 251
 252
 253 class MultiNode(Node):
 254         accepts_subpath = True
 255
 256         urlpatterns = []
 257
 258         def render_to_response(self, request, path=None, subpath=None):
 259                 if not subpath:
 260                         subpath = ""
 261                 subpath = "/" + subpath
 262                 from django.core.urlresolvers import resolve
 263                 view, args, kwargs = resolve(subpath, urlconf=self)
 264                 return view(request, *args, **kwargs)
 265
 266         class Meta:
 267                 abstract = True
 268
 269
 270 class Redirect(Node):
 271         STATUS_CODES = (
 272                 (302, 'Temporary'),
 273                 (301, 'Permanent'),
 274         )
 275         target = models.URLField(help_text='Must be a valid, absolute URL (i.e. http://)')
 276         status_code = models.IntegerField(choices=STATUS_CODES, default=302, verbose_name='redirect type')
 277
 278         def render_to_response(self, request, path=None, subpath=None):
 279                 response = HttpResponseRedirect(self.target)
 280                 response.status_code = self.status_code
 281                 return response
 282
 283
 284 class File(Node):
 285         """ For storing arbitrary files """
 286         mimetype = models.CharField(max_length=255)
 287         file = models.FileField(upload_to='philo/files/%Y/%m/%d')
 288
 289         def render_to_response(self, request, path=None, subpath=None):
 290                 wrapper = FileWrapper(self.file)
 291                 response = HttpResponse(wrapper, content_type=self.mimetype)
 292                 response['Content-Length'] = self.file.size
 293                 return response
 294
 295
 296 class Template(TreeModel):
 297         name = models.CharField(max_length=255)
 298         documentation = models.TextField(null=True, blank=True)
 299         mimetype = models.CharField(max_length=255, null=True, blank=True, help_text='Default: %s' % settings.DEFAULT_CONTENT_TYPE)
 300         code = models.TextField(verbose_name='django template code')
 301
 302         @property
 303         def origin(self):
 304                 return 'philo.models.Template: ' + self.path
 305
 306         @property
 307         def django_template(self):
 308                 return DjangoTemplate(self.code)
 309
 310         @property
 311         def containers(self):
 312                 """
 313                 Returns a tuple where the first item is a list of names of contentlets referenced by containers,
 314                 and the second item is a list of tuples of names and contenttypes of contentreferences referenced by containers.
 315                 This will break if there is a recursive extends or includes in the template code.
 316                 Due to the use of an empty Context, any extends or include tags with dynamic arguments probably won't work.
 317                 """
 318                 def container_nodes(template):
 319                         def nodelist_container_nodes(nodelist):
 320                                 nodes = []
 321                                 for node in nodelist:
 322                                         try:
 323                                                 for nodelist_name in ('nodelist', 'nodelist_loop', 'nodelist_empty', 'nodelist_true', 'nodelist_false', 'nodelist_main'):
 324                                                         if hasattr(node, nodelist_name):
 325                                                                 nodes.extend(nodelist_container_nodes(getattr(node, nodelist_name)))
 326                                                 if isinstance(node, ContainerNode):
 327                                                         nodes.append(node)
 328                                                 elif isinstance(node, ExtendsNode):
 329                                                         extended_template = node.get_parent(Context())
 330                                                         if extended_template:
 331                                                                 nodes.extend(container_nodes(extended_template))
 332                                                 elif isinstance(node, ConstantIncludeNode):
 333                                                         included_template = node.template
 334                                                         if included_template:
 335                                                                 nodes.extend(container_nodes(included_template))
 336                                                 elif isinstance(node, IncludeNode):
 337                                                         included_template = get_template(node.template_name.resolve(Context()))
 338                                                         if included_template:
 339                                                                 nodes.extend(container_nodes(included_template))
 340                                         except:
 341                                                 pass # fail for this node
 342                                 return nodes
 343                         return nodelist_container_nodes(template.nodelist)
 344                 all_nodes = container_nodes(self.django_template)
 345                 contentlet_node_names = set([node.name for node in all_nodes if not node.references])
 346                 contentreference_node_names = []
 347                 contentreference_node_specs = []
 348                 for node in all_nodes:
 349                         if node.references and node.name not in contentreference_node_names:
 350                                 contentreference_node_specs.append((node.name, node.references))
 351                                 contentreference_node_names.append(node.name)
 352                 return contentlet_node_names, contentreference_node_specs
 353
 354         def __unicode__(self):
 355                 return self.get_path(u' › ', 'name')
 356
 357         @staticmethod
 358         @fattr(is_usable=True)
 359         def loader(template_name, template_dirs=None): # load_template_source
 360                 try:
 361                         template = Template.objects.get_with_path(template_name)
 362                 except Template.DoesNotExist:
 363                         raise TemplateDoesNotExist(template_name)
 364                 return (template.code, template.origin)
 365
 366
 367 class Page(Node):
 368         """
 369         Represents a page - something which is rendered according to a template. The page will have a number of related Contentlets depending on the template selected - but these will appear only after the page has been saved with that template.
 370         """
 371         template = models.ForeignKey(Template, related_name='pages')
 372         title = models.CharField(max_length=255)
 373
 374         def render_to_response(self, request, path=None, subpath=None):
 375                 return HttpResponse(self.template.django_template.render(RequestContext(request, {'page': self})), mimetype=self.template.mimetype)
 376
 377         def __unicode__(self):
 378                 return self.get_path(u' › ', 'title')
 379
 380
 381 # the following line enables the selection of a node as the root for a given django.contrib.sites Site object
 382 models.ForeignKey(Node, related_name='sites', null=True, blank=True).contribute_to_class(Site, 'root_node')
 383
 384
 385 class Contentlet(models.Model):
 386         page = models.ForeignKey(Page, related_name='contentlets')
 387         name = models.CharField(max_length=255)
 388         content = models.TextField()
 389         dynamic = models.BooleanField(default=False)
 390
 391         def __unicode__(self):
 392                 return self.name
 393
 394
 395 class ContentReference(models.Model):
 396         page = models.ForeignKey(Page, related_name='contentreferences')
 397         name = models.CharField(max_length=255)
 398         content_type = models.ForeignKey(ContentType, verbose_name='Content type')
 399         content_id = models.PositiveIntegerField(verbose_name='Content ID')
 400         content = generic.GenericForeignKey('content_type', 'content_id')
 401
 402         def __unicode__(self):
 403                 return self.name
 404
 405
 406 register_templatetags('philo.templatetags.containers')
 407
 408
 409 register_value_model(User)
 410 register_value_model(Group)
 411 register_value_model(Site)
 412 register_value_model(Collection)
 413 register_value_model(Template)
 414 register_value_model(Page)