Made DateTimeField implementation for Gilbert more naive to avoid confusing autofill...
[philo.git] / models / pages.py
1 # encoding: utf-8
2 from django.conf import settings
3 from django.contrib.contenttypes.models import ContentType
4 from django.contrib.contenttypes import generic
5 from django.core.exceptions import ValidationError
6 from django.db import models
7 from django.http import HttpResponse
8 from django.template import TemplateDoesNotExist, Context, RequestContext, Template as DjangoTemplate, add_to_builtins as register_templatetags, TextNode, VariableNode
9 from django.template.loader_tags import BlockNode, ExtendsNode, BlockContext
10 from django.utils.datastructures import SortedDict
11 from philo.models.base import TreeModel, register_value_model
12 from philo.models.fields import TemplateField
13 from philo.models.nodes import View
14 from philo.templatetags.containers import ContainerNode
15 from philo.utils import fattr
16 from philo.validators import LOADED_TEMPLATE_ATTR
17 from philo.signals import page_about_to_render_to_string, page_finished_rendering_to_string
18
19
20 class LazyContainerFinder(object):
21         def __init__(self, nodes, extends=False):
22                 self.nodes = nodes
23                 self.initialized = False
24                 self.contentlet_specs = set()
25                 self.contentreference_specs = SortedDict()
26                 self.blocks = {}
27                 self.block_super = False
28                 self.extends = extends
29         
30         def process(self, nodelist):
31                 for node in nodelist:
32                         if self.extends:
33                                 if isinstance(node, BlockNode):
34                                         self.blocks[node.name] = block = LazyContainerFinder(node.nodelist)
35                                         block.initialize()
36                                         self.blocks.update(block.blocks)
37                                 continue
38                         
39                         if isinstance(node, ContainerNode):
40                                 if not node.references:
41                                         self.contentlet_specs.add(node.name)
42                                 else:
43                                         if node.name not in self.contentreference_specs.keys():
44                                                 self.contentreference_specs[node.name] = node.references
45                                 continue
46                         
47                         if isinstance(node, VariableNode):
48                                 if node.filter_expression.var.lookups == (u'block', u'super'):
49                                         self.block_super = True
50                         
51                         if hasattr(node, 'child_nodelists'):
52                                 for nodelist_name in node.child_nodelists:
53                                         if hasattr(node, nodelist_name):
54                                                 nodelist = getattr(node, nodelist_name)
55                                                 self.process(nodelist)
56                         
57                         # LOADED_TEMPLATE_ATTR contains the name of an attribute philo uses to declare a
58                         # node as rendering an additional template. Philo monkeypatches the attribute onto
59                         # the relevant default nodes and declares it on any native nodes.
60                         if hasattr(node, LOADED_TEMPLATE_ATTR):
61                                 loaded_template = getattr(node, LOADED_TEMPLATE_ATTR)
62                                 if loaded_template:
63                                         nodelist = loaded_template.nodelist
64                                         self.process(nodelist)
65         
66         def initialize(self):
67                 if not self.initialized:
68                         self.process(self.nodes)
69                         self.initialized = True
70
71
72 class Template(TreeModel):
73         name = models.CharField(max_length=255)
74         documentation = models.TextField(null=True, blank=True)
75         mimetype = models.CharField(max_length=255, default=getattr(settings, 'DEFAULT_CONTENT_TYPE', 'text/html'))
76         code = TemplateField(secure=False, verbose_name='django template code')
77         
78         @property
79         def containers(self):
80                 """
81                 Returns a tuple where the first item is a list of names of contentlets referenced by containers,
82                 and the second item is a list of tuples of names and contenttypes of contentreferences referenced by containers.
83                 This will break if there is a recursive extends or includes in the template code.
84                 Due to the use of an empty Context, any extends or include tags with dynamic arguments probably won't work.
85                 """
86                 template = DjangoTemplate(self.code)
87                 
88                 def build_extension_tree(nodelist):
89                         nodelists = []
90                         extends = None
91                         for node in nodelist:
92                                 if not isinstance(node, TextNode):
93                                         if isinstance(node, ExtendsNode):
94                                                 extends = node
95                                         break
96                         
97                         if extends:
98                                 if extends.nodelist:
99                                         nodelists.append(LazyContainerFinder(extends.nodelist, extends=True))
100                                 loaded_template = getattr(extends, LOADED_TEMPLATE_ATTR)
101                                 nodelists.extend(build_extension_tree(loaded_template.nodelist))
102                         else:
103                                 # Base case: root.
104                                 nodelists.append(LazyContainerFinder(nodelist))
105                         return nodelists
106                 
107                 # Build a tree of the templates we're using, placing the root template first.
108                 levels = build_extension_tree(template.nodelist)[::-1]
109                 
110                 contentlet_specs = set()
111                 contentreference_specs = SortedDict()
112                 blocks = {}
113                 
114                 for level in levels:
115                         level.initialize()
116                         contentlet_specs |= level.contentlet_specs
117                         contentreference_specs.update(level.contentreference_specs)
118                         for name, block in level.blocks.items():
119                                 if block.block_super:
120                                         blocks.setdefault(name, []).append(block)
121                                 else:
122                                         blocks[name] = [block]
123                 
124                 for block_list in blocks.values():
125                         for block in block_list:
126                                 block.initialize()
127                                 contentlet_specs |= block.contentlet_specs
128                                 contentreference_specs.update(block.contentreference_specs)
129                 
130                 return contentlet_specs, contentreference_specs
131         
132         def __unicode__(self):
133                 return self.name
134         
135         class Meta:
136                 app_label = 'philo'
137
138
139 class Page(View):
140         """
141         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.
142         """
143         template = models.ForeignKey(Template, related_name='pages')
144         title = models.CharField(max_length=255)
145         
146         def get_containers(self):
147                 if not hasattr(self, '_containers'):
148                         self._containers = self.template.containers
149                 return self._containers
150         containers = property(get_containers)
151         
152         def render_to_string(self, request=None, extra_context=None):
153                 context = {}
154                 context.update(extra_context or {})
155                 context.update({'page': self, 'attributes': self.attributes})
156                 template = DjangoTemplate(self.template.code)
157                 if request:
158                         context.update({'node': request.node, 'attributes': self.attributes_with_node(request.node)})
159                         page_about_to_render_to_string.send(sender=self, request=request, extra_context=context)
160                         string = template.render(RequestContext(request, context))
161                 else:
162                         page_about_to_render_to_string.send(sender=self, request=request, extra_context=context)
163                         string = template.render(Context(context))
164                 page_finished_rendering_to_string.send(sender=self, string=string)
165                 return string
166         
167         def actually_render_to_response(self, request, extra_context=None):
168                 return HttpResponse(self.render_to_string(request, extra_context), mimetype=self.template.mimetype)
169         
170         def __unicode__(self):
171                 return self.title
172         
173         def clean_fields(self, exclude=None):
174                 try:
175                         super(Page, self).clean_fields(exclude)
176                 except ValidationError, e:
177                         errors = e.message_dict
178                 else:
179                         errors = {}
180                 
181                 if 'template' not in errors and 'template' not in exclude:
182                         try:
183                                 self.template.clean_fields()
184                                 self.template.clean()
185                         except ValidationError, e:
186                                 errors['template'] = e.messages
187                 
188                 if errors:
189                         raise ValidationError(errors)
190         
191         class Meta:
192                 app_label = 'philo'
193
194
195 class Contentlet(models.Model):
196         page = models.ForeignKey(Page, related_name='contentlets')
197         name = models.CharField(max_length=255, db_index=True)
198         content = TemplateField()
199         
200         def __unicode__(self):
201                 return self.name
202         
203         class Meta:
204                 app_label = 'philo'
205
206
207 class ContentReference(models.Model):
208         page = models.ForeignKey(Page, related_name='contentreferences')
209         name = models.CharField(max_length=255, db_index=True)
210         content_type = models.ForeignKey(ContentType, verbose_name='Content type')
211         content_id = models.PositiveIntegerField(verbose_name='Content ID', blank=True, null=True)
212         content = generic.GenericForeignKey('content_type', 'content_id')
213         
214         def __unicode__(self):
215                 return self.name
216         
217         class Meta:
218                 app_label = 'philo'
219
220
221 register_templatetags('philo.templatetags.containers')
222
223
224 register_value_model(Template)
225 register_value_model(Page)