X-Git-Url: http://git.ithinksw.org/philo.git/blobdiff_plain/0adc7822400fb7fa49bc15a13e3e74e997184e80..ae602182bcbeb943d031fbe3c16f2fe464e8e862:/contrib/navigation/models.py?ds=sidebyside diff --git a/contrib/navigation/models.py b/contrib/navigation/models.py index 40f8c07..e43e8d9 100644 --- a/contrib/navigation/models.py +++ b/contrib/navigation/models.py @@ -2,22 +2,40 @@ from django.core.exceptions import ValidationError from django.core.urlresolvers import NoReverseMatch from django.db import models +from django.forms.models import model_to_dict from philo.models import TreeEntity, JSONField, Node, TreeManager from philo.validators import RedirectValidator -#from mptt.templatetags.mptt_tags import cache_tree_children - DEFAULT_NAVIGATION_DEPTH = 3 +class NavigationQuerySet(models.query.QuerySet): + """ + This subclass is necessary to trigger cache clearing for Navigation when a mass update + or deletion is performed. For now, either action will trigger a clearing of the entire + navigation cache, since there's no convenient way to iterate over the changed or + deleted instances. + """ + def update(self, *args, **kwargs): + super(NavigationQuerySet, self).update(*args, **kwargs) + Navigation.objects.clear_cache() + + def delete(self, *args, **kwargs): + super(NavigationQuerySet, self).delete(*args, **kwargs) + Navigation.objects.clear_cache() + + class NavigationManager(TreeManager): # Analagous to contenttypes, cache Navigation to avoid repeated lookups all over the place. # Navigation will probably be used frequently. _cache = {} - def for_node(self, node): + def get_queryset(self): + return NavigationQuerySet(self.model, using=self._db) + + def closest_navigation(self, node): """ Returns the set of Navigation objects for a given node's navigation. This will be the most recent set of defined hosted navigation among the node's @@ -55,19 +73,28 @@ class NavigationManager(TreeManager): return hosted_navigation def _add_to_cache(self, using, node, qs=None): - if node is None or node.pk is None: - qs = self.none() - key = None - else: - key = node.pk + key = getattr(node, 'pk', None) if qs is None: - qs = node.hosted_navigation.select_related('target_node') + if key is None: + roots = self.none() + else: + roots = node.hosted_navigation.select_related('target_node') + + for root in roots: + root_qs = root.get_descendants(include_self=True).complex_filter({'%s__lte' % root._mptt_meta.level_attr: root.get_level() + root.depth}).exclude(depth__isnull=True) + if qs is None: + qs = root_qs + else: + qs |= root_qs + + if qs is None: + qs = self.none() self.__class__._cache.setdefault(using, {})[key] = qs def _get_from_cache(self, using, node): - key = node.pk + key = getattr(node, 'pk', None) return self.__class__._cache[self.db][key] def _is_cached(self, using, node): @@ -81,26 +108,14 @@ class NavigationManager(TreeManager): """ Clear out the navigation cache. This needs to happen during database flushes or if a navigation entry is changed to prevent caching of outdated navigation information. - - TODO: call this method from update() and delete()! """ if navigation is None: self.__class__._cache.clear() else: cache = self.__class__._cache[self.db] - for pk in cache.keys(): - for qs in cache[pk]: - if navigation in qs: - cache.pop(pk) - break - else: - for instance in qs: - if navigation.is_descendant(instance): - cache.pop(pk) - break - # necessary? - if pk not in cache: - break + for pk, qs in cache.items(): + if navigation in qs: + cache.pop(pk) class Navigation(TreeEntity): @@ -116,6 +131,13 @@ class Navigation(TreeEntity): order = models.PositiveSmallIntegerField(blank=True, null=True) depth = models.PositiveSmallIntegerField(blank=True, null=True, default=DEFAULT_NAVIGATION_DEPTH, help_text="For the root of a hosted tree, defines the depth of the tree. A blank depth will hide this section of navigation. Otherwise, depth is ignored.") + def __init__(self, *args, **kwargs): + super(Navigation, self).__init__(*args, **kwargs) + self._initial_data = model_to_dict(self) + + def __unicode__(self): + return self.get_path(field='text', pathsep=u' › ') + def clean(self): # Should this be enforced? Not enforcing it would allow creation of "headers" in the navbar. if not self.target_node and not self.url_or_subpath: @@ -149,10 +171,47 @@ class Navigation(TreeEntity): return self.url_or_subpath target_url = property(get_target_url) - def __unicode__(self): - return self.get_path(field='text', pathsep=u' › ') + def is_active(self, request): + # First check if this particular navigation is active. It is considered active if: + # - the requested node is this instance's target node and its subpath matches the requested path. + # - the requested node is a descendant of this instance's target node and this instance's target + # node is not the hosting node of this navigation structure. + # - this instance has no target node and the url matches either the request path or the full url. + # - any of this instance's children are active. + node = request.node + + if self.target_node == node: + if self.target_url == request.path: + return True + elif self.target_node is None: + if self.url_or_subpath == request.path or self.url_or_subpath == "http%s://%s%s" % (request.is_secure() and 's' or '', request.get_host(), request.path): + return True + elif self.target_node.is_ancestor_of(node) and self.target_node != self.hosting_node: + return True + + # Always fall back to whether the node has active children. + return self.has_active_children(request) + + def has_active_children(self, request): + for child in self.get_children(): + if child.is_active(request): + return True + return False + + def _has_changed(self): + if model_to_dict(self) == self._initial_data: + return False + return True + + def save(self, *args, **kwargs): + super(Navigation, self).save(*args, **kwargs) + if self._has_changed(): + self._initial_data = model_to_dict(self) + Navigation.objects.clear_cache(self) - # TODO: Add delete and save methods to handle cache clearing. + def delete(self, *args, **kwargs): + super(Navigation, self).delete(*args, **kwargs) + Navigation.objects.clear_cache(self) class Meta: ordering = ['order']