forum/models/base.py

   1 import datetime
   2 import re
   3 from urllib import quote_plus, urlencode
   4 from django.db import models, IntegrityError, connection, transaction
   5 from django.utils.http import urlquote  as django_urlquote
   6 from django.utils.html import strip_tags
   7 from django.core.urlresolvers import reverse
   8 from django.contrib.contenttypes import generic
   9 from django.contrib.contenttypes.models import ContentType
  10 from django.core.cache import cache
  11 from django.template.defaultfilters import slugify
  12 from django.db.models.signals import post_delete, post_save, pre_save, pre_delete
  13 from django.utils.translation import ugettext as _
  14 from django.utils.safestring import mark_safe
  15 from django.contrib.sitemaps import ping_google
  16 import django.dispatch
  17 from forum import settings
  18 import logging
  19
  20
  21 class LazyQueryList(object):
  22     def __init__(self, model, items):
  23         self.model = model
  24         self.items = items
  25
  26     def __getitem__(self, k):
  27         return self.model.objects.get(id=self.items[k])
  28
  29     def __iter__(self):
  30         for id in self.items:
  31             yield self.model.objects.get(id=id)
  32
  33     def __len__(self):
  34         return len(self.items)
  35
  36 class CachedQuerySet(models.query.QuerySet):
  37     def lazy(self):
  38         if len(self.query.extra) == 0:
  39             return LazyQueryList(self.model, list(self.values_list('id', flat=True)))
  40         else:
  41             return self
  42
  43     def obj_from_datadict(self, datadict):
  44         obj = self.model()
  45         obj.__dict__.update(datadict)
  46         return obj
  47
  48     def get(self, *args, **kwargs):
  49         try:
  50             pk = [v for (k,v) in kwargs.items() if k in ('pk', 'pk__exact', 'id', 'id__exact'
  51                             ) or k.endswith('_ptr__pk') or k.endswith('_ptr__id')][0]
  52         except:
  53             pk = None
  54
  55         if pk is not None:
  56             key = self.model.cache_key(pk)
  57             obj = cache.get(key)
  58
  59             if obj is None:
  60                 obj = super(CachedQuerySet, self).get(*args, **kwargs)
  61                 obj.cache()
  62             else:
  63                 obj = self.obj_from_datadict(obj)
  64                 obj.reset_original_state()
  65
  66             return obj
  67
  68         return super(CachedQuerySet, self).get(*args, **kwargs)
  69
  70 class CachedManager(models.Manager):
  71     use_for_related_fields = True
  72
  73     def get_query_set(self):
  74         return CachedQuerySet(self.model)
  75
  76     def get_or_create(self, *args, **kwargs):
  77         try:
  78             return self.get(*args, **kwargs)
  79         except:
  80             return super(CachedManager, self).get_or_create(*args, **kwargs)
  81
  82
  83 class DenormalizedField(object):
  84     def __init__(self, manager, **kwargs):
  85         self.manager = manager
  86         self.filter = kwargs
  87
  88     def setup_class(self, cls, name):
  89         dict_name = '_%s_dencache_' % name
  90
  91         def getter(inst):
  92             val = inst.__dict__.get(dict_name, None)
  93
  94             if val is None:
  95                 val = getattr(inst, self.manager).filter(**self.filter).count()
  96                 inst.__dict__[dict_name] = val
  97                 inst.cache()
  98
  99             return val
 100
 101         def reset_cache(inst):
 102             inst.__dict__.pop(dict_name, None)
 103             inst.uncache()
 104
 105         cls.add_to_class(name, property(getter))
 106         cls.add_to_class("reset_%s_cache" % name, reset_cache)
 107
 108
 109 class BaseMetaClass(models.Model.__metaclass__):
 110     to_denormalize = []
 111
 112     def __new__(cls, *args, **kwargs):
 113         new_cls = super(BaseMetaClass, cls).__new__(cls, *args, **kwargs)
 114
 115         BaseMetaClass.to_denormalize.extend(
 116             [(new_cls, name, field) for name, field in new_cls.__dict__.items() if isinstance(field, DenormalizedField)]
 117         )
 118
 119         return new_cls
 120
 121     @classmethod
 122     def setup_denormalizes(cls):
 123         for new_cls, name, field in BaseMetaClass.to_denormalize:
 124             field.setup_class(new_cls, name)
 125
 126
 127 class BaseModel(models.Model):
 128     __metaclass__ = BaseMetaClass
 129
 130     objects = CachedManager()
 131
 132     class Meta:
 133         abstract = True
 134         app_label = 'forum'
 135
 136     def __init__(self, *args, **kwargs):
 137         super(BaseModel, self).__init__(*args, **kwargs)
 138         self.reset_original_state()
 139
 140     @classmethod
 141     def cache_key(cls, pk):
 142         return '%s:%s:%s' % (settings.APP_URL, cls.__name__, pk)
 143
 144     def reset_original_state(self):
 145         self._original_state = self._as_dict()
 146
 147     def get_dirty_fields(self):
 148         return [f.name for f in self._meta.fields if self._original_state[f.attname] != self.__dict__[f.attname]]
 149
 150     def _as_dict(self):
 151         return dict([(name, getattr(self, name)) for name in
 152                      ([f.attname for f in self._meta.fields] + [k for k in self.__dict__.keys() if k.endswith('_dencache_')])
 153         ])
 154
 155     def _get_update_kwargs(self):
 156         return dict([
 157             (f.name, getattr(self, f.name)) for f in self._meta.fields if self._original_state[f.attname] != self.__dict__[f.attname]
 158         ])
 159
 160     def save(self, *args, **kwargs):
 161         put_back = [k for k, v in self.__dict__.items() if isinstance(v, models.expressions.ExpressionNode)]
 162
 163         if self.id:
 164             self.__class__.objects.filter(id=self.id).update(**self._get_update_kwargs())
 165         else:
 166             super(BaseModel, self).save()
 167
 168         if put_back:
 169             try:
 170                 self.__dict__.update(
 171                     self.__class__.objects.filter(id=self.id).values(*put_back)[0]
 172                 )
 173             except:
 174                 logging.error("Unable to read %s from %s" % (", ".join(put_back), self.__class__.__name__))
 175                 self.uncache()
 176
 177         self.reset_original_state()
 178         self.cache()
 179
 180     def cache(self):
 181         cache.set(self.cache_key(self.id), self._as_dict(), 60 * 60)
 182
 183     def uncache(self):
 184         cache.delete(self.cache_key(self.id))
 185
 186     def delete(self):
 187         self.uncache()
 188         super(BaseModel, self).delete()
 189
 190
 191 from user import User
 192 from node import Node, NodeRevision, NodeManager
 193 from action import Action
 194
 195
 196
 197
 198