+++ /dev/null
-# encoding: utf-8
-from django.conf import settings
-from django.contrib.contenttypes.models import ContentType
-from django.contrib.contenttypes import generic
-from django.core.exceptions import ValidationError
-from django.db import models
-from django.http import HttpResponse
-from django.template import TemplateDoesNotExist, Context, RequestContext, Template as DjangoTemplate, add_to_builtins as register_templatetags, TextNode, VariableNode
-from django.template.loader_tags import BlockNode, ExtendsNode, BlockContext
-from django.utils.datastructures import SortedDict
-from philo.models.base import TreeModel, register_value_model
-from philo.models.fields import TemplateField
-from philo.models.nodes import View
-from philo.templatetags.containers import ContainerNode
-from philo.utils import fattr
-from philo.validators import LOADED_TEMPLATE_ATTR
-from philo.signals import page_about_to_render_to_string, page_finished_rendering_to_string
-
-
-class LazyContainerFinder(object):
- def __init__(self, nodes, extends=False):
- self.nodes = nodes
- self.initialized = False
- self.contentlet_specs = set()
- self.contentreference_specs = SortedDict()
- self.blocks = {}
- self.block_super = False
- self.extends = extends
-
- def process(self, nodelist):
- for node in nodelist:
- if self.extends:
- if isinstance(node, BlockNode):
- self.blocks[node.name] = block = LazyContainerFinder(node.nodelist)
- block.initialize()
- self.blocks.update(block.blocks)
- continue
-
- if isinstance(node, ContainerNode):
- if not node.references:
- self.contentlet_specs.add(node.name)
- else:
- if node.name not in self.contentreference_specs.keys():
- self.contentreference_specs[node.name] = node.references
- continue
-
- if isinstance(node, VariableNode):
- if node.filter_expression.var.lookups == (u'block', u'super'):
- self.block_super = True
-
- if hasattr(node, 'child_nodelists'):
- for nodelist_name in node.child_nodelists:
- if hasattr(node, nodelist_name):
- nodelist = getattr(node, nodelist_name)
- self.process(nodelist)
-
- # LOADED_TEMPLATE_ATTR contains the name of an attribute philo uses to declare a
- # node as rendering an additional template. Philo monkeypatches the attribute onto
- # the relevant default nodes and declares it on any native nodes.
- if hasattr(node, LOADED_TEMPLATE_ATTR):
- loaded_template = getattr(node, LOADED_TEMPLATE_ATTR)
- if loaded_template:
- nodelist = loaded_template.nodelist
- self.process(nodelist)
-
- def initialize(self):
- if not self.initialized:
- self.process(self.nodes)
- self.initialized = True
-
-
-class Template(TreeModel):
- name = models.CharField(max_length=255)
- documentation = models.TextField(null=True, blank=True)
- mimetype = models.CharField(max_length=255, default=getattr(settings, 'DEFAULT_CONTENT_TYPE', 'text/html'))
- code = TemplateField(secure=False, verbose_name='django template code')
-
- @property
- def containers(self):
- """
- Returns a tuple where the first item is a list of names of contentlets referenced by containers,
- and the second item is a list of tuples of names and contenttypes of contentreferences referenced by containers.
- This will break if there is a recursive extends or includes in the template code.
- Due to the use of an empty Context, any extends or include tags with dynamic arguments probably won't work.
- """
- template = DjangoTemplate(self.code)
-
- def build_extension_tree(nodelist):
- nodelists = []
- extends = None
- for node in nodelist:
- if not isinstance(node, TextNode):
- if isinstance(node, ExtendsNode):
- extends = node
- break
-
- if extends:
- if extends.nodelist:
- nodelists.append(LazyContainerFinder(extends.nodelist, extends=True))
- loaded_template = getattr(extends, LOADED_TEMPLATE_ATTR)
- nodelists.extend(build_extension_tree(loaded_template.nodelist))
- else:
- # Base case: root.
- nodelists.append(LazyContainerFinder(nodelist))
- return nodelists
-
- # Build a tree of the templates we're using, placing the root template first.
- levels = build_extension_tree(template.nodelist)[::-1]
-
- contentlet_specs = set()
- contentreference_specs = SortedDict()
- blocks = {}
-
- for level in levels:
- level.initialize()
- contentlet_specs |= level.contentlet_specs
- contentreference_specs.update(level.contentreference_specs)
- for name, block in level.blocks.items():
- if block.block_super:
- blocks.setdefault(name, []).append(block)
- else:
- blocks[name] = [block]
-
- for block_list in blocks.values():
- for block in block_list:
- block.initialize()
- contentlet_specs |= block.contentlet_specs
- contentreference_specs.update(block.contentreference_specs)
-
- return contentlet_specs, contentreference_specs
-
- def __unicode__(self):
- return self.name
-
- class Meta:
- app_label = 'philo'
-
-
-class Page(View):
- """
- 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.
- """
- template = models.ForeignKey(Template, related_name='pages')
- title = models.CharField(max_length=255)
-
- def get_containers(self):
- if not hasattr(self, '_containers'):
- self._containers = self.template.containers
- return self._containers
- containers = property(get_containers)
-
- def render_to_string(self, request=None, extra_context=None):
- context = {}
- context.update(extra_context or {})
- context.update({'page': self, 'attributes': self.attributes})
- template = DjangoTemplate(self.template.code)
- if request:
- context.update({'node': request.node, 'attributes': self.attributes_with_node(request.node)})
- page_about_to_render_to_string.send(sender=self, request=request, extra_context=context)
- string = template.render(RequestContext(request, context))
- else:
- page_about_to_render_to_string.send(sender=self, request=request, extra_context=context)
- string = template.render(Context(context))
- page_finished_rendering_to_string.send(sender=self, string=string)
- return string
-
- def actually_render_to_response(self, request, extra_context=None):
- return HttpResponse(self.render_to_string(request, extra_context), mimetype=self.template.mimetype)
-
- def __unicode__(self):
- return self.title
-
- def clean_fields(self, exclude=None):
- if exclude is None:
- exclude = []
-
- try:
- super(Page, self).clean_fields(exclude)
- except ValidationError, e:
- errors = e.message_dict
- else:
- errors = {}
-
- if 'template' not in errors and 'template' not in exclude:
- try:
- self.template.clean_fields()
- self.template.clean()
- except ValidationError, e:
- errors['template'] = e.messages
-
- if errors:
- raise ValidationError(errors)
-
- class Meta:
- app_label = 'philo'
-
-
-class Contentlet(models.Model):
- page = models.ForeignKey(Page, related_name='contentlets')
- name = models.CharField(max_length=255, db_index=True)
- content = TemplateField()
-
- def __unicode__(self):
- return self.name
-
- class Meta:
- app_label = 'philo'
-
-
-class ContentReference(models.Model):
- page = models.ForeignKey(Page, related_name='contentreferences')
- name = models.CharField(max_length=255, db_index=True)
- content_type = models.ForeignKey(ContentType, verbose_name='Content type')
- content_id = models.PositiveIntegerField(verbose_name='Content ID', blank=True, null=True)
- content = generic.GenericForeignKey('content_type', 'content_id')
-
- def __unicode__(self):
- return self.name
-
- class Meta:
- app_label = 'philo'
-
-
-register_templatetags('philo.templatetags.containers')
-
-
-register_value_model(Template)
-register_value_model(Page)
\ No newline at end of file
git.ithinksw.org / philo.git / blobdiff