Merge branch 'gilbert-ext4-murano' of git://github.com/lapilofu/philo into gilbert...
[philo.git] / philo / contrib / shipherd / models.py
1 #encoding: utf-8
2 from django.core.exceptions import ValidationError
3 from django.core.urlresolvers import NoReverseMatch
4 from django.core.validators import RegexValidator, MinValueValidator
5 from django.db import models
6 from django.forms.models import model_to_dict
7 from philo.models import TreeEntity, Node, TreeManager, Entity, TargetURLModel
8 from philo.validators import RedirectValidator
9 from UserDict import DictMixin
10
11
12 DEFAULT_NAVIGATION_DEPTH = 3
13
14
15 class NavigationQuerySetMapper(object, DictMixin):
16         """This class exists to prevent setting of items in the navigation cache through node.navigation."""
17         def __init__(self, node):
18                 self.node = node
19         
20         def __getitem__(self, key):
21                 return Navigation.objects.get_cache_for(self.node)[key]['root_items']
22         
23         def keys(self):
24                 return Navigation.objects.get_cache_for(self.node).keys()
25
26
27 def navigation(self):
28         if not hasattr(self, '_navigation'):
29                 self._navigation = NavigationQuerySetMapper(self)
30         return self._navigation
31
32
33 Node.navigation = property(navigation)
34
35
36 class NavigationCacheQuerySet(models.query.QuerySet):
37         """
38         This subclass will trigger general cache clearing for Navigation.objects when a mass
39         update or deletion is performed. As there is no convenient way to iterate over the
40         changed or deleted instances, there's no way to be more precise about what gets cleared.
41         """
42         def update(self, *args, **kwargs):
43                 super(NavigationCacheQuerySet, self).update(*args, **kwargs)
44                 Navigation.objects.clear_cache()
45         
46         def delete(self, *args, **kwargs):
47                 super(NavigationCacheQuerySet, self).delete(*args, **kwargs)
48                 Navigation.objects.clear_cache()
49
50
51 class NavigationManager(models.Manager):
52         # Since navigation is going to be hit frequently and changed
53         # relatively infrequently, cache it. Analogous to contenttypes.
54         use_for_related = True
55         _cache = {}
56         
57         def get_queryset(self):
58                 return NavigationCacheQuerySet(self.model, using=self._db)
59         
60         def get_cache_for(self, node, update_targets=True):
61                 created = False
62                 if not self.has_cache_for(node):
63                         self.create_cache_for(node)
64                         created = True
65                 
66                 if update_targets and not created:
67                         self.update_targets_for(node)
68                 
69                 return self.__class__._cache[self.db][node]
70         
71         def has_cache_for(self, node):
72                 return self.db in self.__class__._cache and node in self.__class__._cache[self.db]
73         
74         def create_cache_for(self, node):
75                 "This method loops through the nodes ancestors and caches all unique navigation keys."
76                 ancestors = node.get_ancestors(ascending=True, include_self=True)
77                 
78                 nodes_to_cache = []
79                 
80                 for node in ancestors:
81                         if self.has_cache_for(node):
82                                 cache = self.get_cache_for(node).copy()
83                                 break
84                         else:
85                                 nodes_to_cache.insert(0, node)
86                 else:
87                         cache = {}
88                 
89                 for node in nodes_to_cache:
90                         cache = cache.copy()
91                         cache.update(self._build_cache_for(node))
92                         self.__class__._cache.setdefault(self.db, {})[node] = cache
93         
94         def _build_cache_for(self, node):
95                 cache = {}
96                 tree_id_attr = NavigationItem._mptt_meta.tree_id_attr
97                 level_attr = NavigationItem._mptt_meta.level_attr
98                 
99                 for navigation in node.navigation_set.all():
100                         tree_ids = navigation.roots.values_list(tree_id_attr)
101                         items = list(NavigationItem.objects.filter(**{'%s__in' % tree_id_attr: tree_ids, '%s__lt' % level_attr: navigation.depth}).order_by('order', 'lft'))
102                         
103                         root_items = []
104                         
105                         for item in items:
106                                 item._is_cached = True
107                                 
108                                 if not hasattr(item, '_cached_children'):
109                                         item._cached_children = []
110                                 
111                                 if item.parent:
112                                         # alternatively, if I don't want to force it to a list, I could keep track of
113                                         # instances where the parent hasn't yet been met and do this step later for them.
114                                         # delayed action.
115                                         item.parent = items[items.index(item.parent)]
116                                         if not hasattr(item.parent, '_cached_children'):
117                                                 item.parent._cached_children = []
118                                         item.parent._cached_children.append(item)
119                                 else:
120                                         root_items.append(item)
121                         
122                         cache[navigation.key] = {
123                                 'navigation': navigation,
124                                 'root_items': root_items,
125                                 'items': items
126                         }
127                 
128                 return cache
129         
130         def clear_cache_for(self, node):
131                 # Clear the cache for this node and all its descendants. The
132                 # navigation for this node has probably changed, and for now,
133                 # it isn't worth it to only clear the descendants actually
134                 # affected by this.
135                 if not self.has_cache_for(node):
136                         # Already cleared.
137                         return
138                 
139                 descendants = node.get_descendants(include_self=True)
140                 cache = self.__class__._cache[self.db]
141                 for node in descendants:
142                         cache.pop(node, None)
143         
144         def update_targets_for(self, node):
145                 # Manually update a cache's target nodes in case something's changed there.
146                 # This should be a less complex operation than reloading the models each
147                 # time. Not as good as selective updates... but not much to be done
148                 # about that. TODO: Benchmark it.
149                 caches = self.__class__._cache[self.db][node].values()
150                 
151                 target_pks = set()
152                 
153                 for cache in caches:
154                         target_pks |= set([item.target_node_id for item in cache['items']])
155                 
156                 # A distinct query is not strictly necessary. TODO: benchmark the efficiency
157                 # with/without distinct.
158                 targets = list(Node.objects.filter(pk__in=target_pks).distinct())
159                 
160                 for cache in caches:
161                         for item in cache['items']:
162                                 if item.target_node_id:
163                                         item.target_node = targets[targets.index(item.target_node)]
164         
165         def clear_cache(self):
166                 self.__class__._cache.pop(self.db, None)
167
168
169 class Navigation(Entity):
170         objects = NavigationManager()
171         
172         node = models.ForeignKey(Node, related_name='navigation_set', help_text="Be available as navigation for this node.")
173         key = models.CharField(max_length=255, validators=[RegexValidator("\w+")], help_text="Must contain one or more alphanumeric characters or underscores.", db_index=True)
174         depth = models.PositiveSmallIntegerField(default=DEFAULT_NAVIGATION_DEPTH, validators=[MinValueValidator(1)], help_text="Defines the maximum display depth of this navigation.")
175         
176         def __init__(self, *args, **kwargs):
177                 super(Navigation, self).__init__(*args, **kwargs)
178                 self._initial_data = model_to_dict(self)
179         
180         def __unicode__(self):
181                 return "%s[%s]" % (self.node, self.key)
182         
183         def _has_changed(self):
184                 return self._initial_data != model_to_dict(self)
185         
186         def save(self, *args, **kwargs):
187                 super(Navigation, self).save(*args, **kwargs)
188                 
189                 if self._has_changed():
190                         Navigation.objects.clear_cache_for(self.node)
191                         self._initial_data = model_to_dict(self)
192         
193         def delete(self, *args, **kwargs):
194                 super(Navigation, self).delete(*args, **kwargs)
195                 Navigation.objects.clear_cache_for(self.node)
196         
197         class Meta:
198                 unique_together = ('node', 'key')
199
200
201 class NavigationItemManager(TreeManager):
202         use_for_related = True
203         
204         def get_queryset(self):
205                 return NavigationCacheQuerySet(self.model, using=self._db)
206
207
208 class NavigationItem(TreeEntity, TargetURLModel):
209         objects = NavigationItemManager()
210         
211         navigation = models.ForeignKey(Navigation, blank=True, null=True, related_name='roots', help_text="Be a root in this navigation tree.")
212         text = models.CharField(max_length=50)
213         
214         order = models.PositiveSmallIntegerField(default=0)
215         
216         def __init__(self, *args, **kwargs):
217                 super(NavigationItem, self).__init__(*args, **kwargs)
218                 self._initial_data = model_to_dict(self)
219                 self._is_cached = False
220         
221         def __unicode__(self):
222                 return self.get_path(field='text', pathsep=u' › ')
223         
224         def clean(self):
225                 super(NavigationItem, self).clean()
226                 if bool(self.parent) == bool(self.navigation):
227                         raise ValidationError("Exactly one of `parent` and `navigation` must be defined.")
228         
229         def is_active(self, request):
230                 if self.target_url == request.path:
231                         # Handle the `default` case where the target_url and requested path
232                         # are identical.
233                         return True
234                 
235                 if self.target_node is None and self.url_or_subpath == "http%s://%s%s" % (request.is_secure() and 's' or '', request.get_host(), request.path):
236                         # If there's no target_node, double-check whether it's a full-url
237                         # match.
238                         return True
239                 
240                 if self.target_node and not self.url_or_subpath:
241                         # If there is a target node and it's targeted simply, but the target URL is not
242                         # the same as the request path, check whether the target node is an ancestor
243                         # of the requested node. If so, this is active unless the target node
244                         # is the same as the ``host node`` for this navigation structure.
245                         try:
246                                 host_node = self.get_root().navigation.node
247                         except AttributeError:
248                                 pass
249                         else:
250                                 if self.target_node != host_node and self.target_node.is_ancestor_of(request.node):
251                                         return True
252                 
253                 return False
254         
255         def has_active_descendants(self, request):
256                 for child in self.get_children():
257                         if child.is_active(request) or child.has_active_descendants(request):
258                                 return True
259                 return False
260         
261         def _has_changed(self):
262                 if model_to_dict(self) == self._initial_data:
263                         return False
264                 return True
265         
266         def _clear_cache(self):
267                 try:
268                         root = self.get_root()
269                         if self.get_level() < root.navigation.depth:
270                                 Navigation.objects.clear_cache_for(self.get_root().navigation.node)
271                 except AttributeError:
272                         pass
273         
274         def save(self, *args, **kwargs):
275                 super(NavigationItem, self).save(*args, **kwargs)
276                 
277                 if self._has_changed():
278                         self._clear_cache()
279         
280         def delete(self, *args, **kwargs):
281                 super(NavigationItem, self).delete(*args, **kwargs)
282                 self._clear_cache()