# encoding: utf-8
-from django.db import models
+from django.conf import settings
from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes import generic
-from django.conf import settings
-from django.template import add_to_builtins as register_templatetags
-from django.template import Template as DjangoTemplate
-from django.template import TemplateDoesNotExist
-from django.template import Context, RequestContext
-from django.template.loader import get_template
-from django.template.loader_tags import ExtendsNode, ConstantIncludeNode, IncludeNode
+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
from philo.models.base import TreeModel, register_value_model
+from philo.models.fields import TemplateField
from philo.models.nodes import View
-from philo.utils import fattr
from philo.templatetags.containers import ContainerNode
+from philo.utils import fattr, nodelist_crawl
+from philo.validators import LOADED_TEMPLATE_ATTR
+from philo.signals import page_about_to_render_to_string, page_finished_rendering_to_string
class Template(TreeModel):
name = models.CharField(max_length=255)
documentation = models.TextField(null=True, blank=True)
- mimetype = models.CharField(max_length=255, null=True, blank=True, help_text='Default: %s' % settings.DEFAULT_CONTENT_TYPE)
- code = models.TextField(verbose_name='django template code')
-
- @property
- def origin(self):
- return 'philo.models.Template: ' + self.path
-
- @property
- def django_template(self):
- return DjangoTemplate(self.code)
+ 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):
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.
"""
- def container_nodes(template):
- def nodelist_container_nodes(nodelist):
- nodes = []
- for node in nodelist:
- try:
- if hasattr(node, 'child_nodelists'):
- for nodelist_name in node.child_nodelists:
- if hasattr(node, nodelist_name):
- nodes.extend(nodelist_container_nodes(getattr(node, nodelist_name)))
- if isinstance(node, ContainerNode):
- nodes.append(node)
- elif isinstance(node, ExtendsNode):
- extended_template = node.get_parent(Context())
- if extended_template:
- nodes.extend(container_nodes(extended_template))
- elif isinstance(node, ConstantIncludeNode):
- included_template = node.template
- if included_template:
- nodes.extend(container_nodes(included_template))
- elif isinstance(node, IncludeNode):
- included_template = get_template(node.template_name.resolve(Context()))
- if included_template:
- nodes.extend(container_nodes(included_template))
- except:
- raise # fail for this node
- return nodes
- return nodelist_container_nodes(template.nodelist)
- all_nodes = container_nodes(self.django_template)
+ def process_node(node, nodes):
+ if isinstance(node, ContainerNode):
+ nodes.append(node)
+
+ all_nodes = nodelist_crawl(DjangoTemplate(self.code).nodelist, process_node)
contentlet_node_names = set([node.name for node in all_nodes if not node.references])
contentreference_node_names = []
contentreference_node_specs = []
return contentlet_node_names, contentreference_node_specs
def __unicode__(self):
- return self.get_path(u' › ', 'name')
-
- @staticmethod
- @fattr(is_usable=True)
- def loader(template_name, template_dirs=None): # load_template_source
- try:
- template = Template.objects.get_with_path(template_name)
- except Template.DoesNotExist:
- raise TemplateDoesNotExist(template_name)
- return (template.code, template.origin)
+ return self.get_path(pathsep=u' › ', field='name')
class Meta:
app_label = 'philo'
template = models.ForeignKey(Template, related_name='pages')
title = models.CharField(max_length=255)
- def render_to_response(self, node, request, path=None, subpath=None, extra_context=None):
+ 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_with_node(node), 'relationships': self.relationships_with_node(node)})
- return HttpResponse(self.template.django_template.render(RequestContext(request, context)), mimetype=self.template.mimetype)
+ 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):
+ 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)
+
+ def get_navigation(self, node, depth, current_depth):
+ return {
+ 'url': node.get_absolute_url(),
+ 'title': self.title
+ }
+
class Meta:
app_label = 'philo'
class Contentlet(models.Model):
page = models.ForeignKey(Page, related_name='contentlets')
name = models.CharField(max_length=255)
- content = models.TextField()
- dynamic = models.BooleanField(default=False)
+ content = TemplateField()
def __unicode__(self):
return self.name
git.ithinksw.org / philo.git / blobdiff