Added a custom QuerySet subclass to handle cache clearing for Navigation mass updates...

[philo.git] / contrib / navigation / models.py

diff --git a/contrib/navigation/models.py b/contrib/navigation/models.py
index 40f8c07..e43e8d9 100644 (file)
--- 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.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 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
 
 
 
 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 = {}
        
 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
                """
                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):
                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:
                
                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):
                
                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):
                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.
                """
                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]
                """
                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):
 
 
 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.")
        
        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:
        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)
        
                        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']
        
        class Meta:
                ordering = ['order']