Finished with node bulk management, although only option for now is to delete nodes.

[osqa.git] / forum / models / base.py

diff --git a/forum/models/base.py b/forum/models/base.py
index dfdf989fa305fa2fc41b30b277b44e2977ab6ff5..2f934a916f349be0eca77c9c56d0347d7b3944fa 100644 (file)
--- a/forum/models/base.py
+++ b/forum/models/base.py
@@ -35,7 +35,7 @@ class LazyQueryList(object):
 
 class CachedQuerySet(models.query.QuerySet):
     def lazy(self):
-        if len(self.query.extra) == 0:
+        if (not len(self.query.extra)) and (not len(self.query.aggregates)):
             return LazyQueryList(self.model, list(self.values_list('id', flat=True)))
         else:
             return self
@@ -46,14 +46,9 @@ class CachedQuerySet(models.query.QuerySet):
         return obj
 
     def get(self, *args, **kwargs):
-        try:
-            pk = [v for (k,v) in kwargs.items() if k in ('pk', 'pk__exact', 'id', 'id__exact'
-                            ) or k.endswith('_ptr__pk') or k.endswith('_ptr__id')][0]
-        except:
-            pk = None
+        key = self.model.infer_cache_key(kwargs)
 
-        if pk is not None:
-            key = self.model.cache_key(pk)
+        if key is not None:
             obj = cache.get(key)
 
             if obj is None:
@@ -81,9 +76,9 @@ class CachedManager(models.Manager):
 
 
 class DenormalizedField(object):
-    def __init__(self, manager, **kwargs):
+    def __init__(self, manager, *args, **kwargs):
         self.manager = manager
-        self.filter = kwargs
+        self.filter = (args, kwargs)
 
     def setup_class(self, cls, name):
         dict_name = '_%s_dencache_' % name
@@ -92,7 +87,7 @@ class DenormalizedField(object):
             val = inst.__dict__.get(dict_name, None)
 
             if val is None:
-                val = getattr(inst, self.manager).filter(**self.filter).count()
+                val = getattr(inst, self.manager).filter(*self.filter[0], **self.filter[1]).count()
                 inst.__dict__[dict_name] = val
                 inst.cache()
 
@@ -135,14 +130,13 @@ class BaseModel(models.Model):
 
     def __init__(self, *args, **kwargs):
         super(BaseModel, self).__init__(*args, **kwargs)
-        self.reset_original_state()
+        self.reset_original_state(kwargs.keys())
 
-    @classmethod
-    def cache_key(cls, pk):
-        return '%s:%s:%s' % (settings.APP_URL, cls.__name__, pk)
-
-    def reset_original_state(self):
+    def reset_original_state(self, reset_fields=None):
         self._original_state = self._as_dict()
+        
+        if reset_fields:
+            self._original_state.update(dict([(f, None) for f in reset_fields]))
 
     def get_dirty_fields(self):
         return [f.name for f in self._meta.fields if self._original_state[f.attname] != self.__dict__[f.attname]]
@@ -157,10 +151,10 @@ class BaseModel(models.Model):
             (f.name, getattr(self, f.name)) for f in self._meta.fields if self._original_state[f.attname] != self.__dict__[f.attname]
         ])
 
-    def save(self, *args, **kwargs):
+    def save(self, full_save=False, *args, **kwargs):
         put_back = [k for k, v in self.__dict__.items() if isinstance(v, models.expressions.ExpressionNode)]
 
-        if self.id:
+        if self.id and not full_save:
             self.__class__.objects.filter(id=self.id).update(**self._get_update_kwargs())
         else:
             super(BaseModel, self).save()
@@ -177,11 +171,31 @@ class BaseModel(models.Model):
         self.reset_original_state()
         self.cache()
 
+    @classmethod
+    def _generate_cache_key(cls, key, group=None):
+        if group is None:
+            group = cls.__name__
+
+        return '%s:%s:%s' % (settings.APP_URL, group, key)
+
+    def cache_key(self):
+        return self._generate_cache_key(self.id)
+
+    @classmethod
+    def infer_cache_key(cls, querydict):
+        try:
+            pk = [v for (k,v) in querydict.items() if k in ('pk', 'pk__exact', 'id', 'id__exact'
+                            ) or k.endswith('_ptr__pk') or k.endswith('_ptr__id')][0]
+
+            return cls._generate_cache_key(pk)
+        except:
+            return None
+
     def cache(self):
-        cache.set(self.cache_key(self.id), self._as_dict(), 60 * 60)
+        cache.set(self.cache_key(), self._as_dict(), 60 * 60)
 
     def uncache(self):
-        cache.delete(self.cache_key(self.id))
+        cache.delete(self.cache_key())
 
     def delete(self):
         self.uncache()