X-Git-Url: https://git.openstreetmap.org./osqa.git/blobdiff_plain/fa803e983501c159302c30e87f7f82ef8c03746b..303b118d8ffc0ed2285166e362a91774f64ad807:/forum/models/base.py diff --git a/forum/models/base.py b/forum/models/base.py index 43668d9..3d54d75 100644 --- a/forum/models/base.py +++ b/forum/models/base.py @@ -14,44 +14,59 @@ from django.utils.translation import ugettext as _ from django.utils.safestring import mark_safe from django.contrib.sitemaps import ping_google import django.dispatch -from django.conf import settings -from forum import const +from forum import settings import logging -from forum.const import * -class CachedManager(models.Manager): - use_for_related_fields = True - int_cache_re = re.compile('^_[\w_]+cache$') +class LazyQueryList(object): + def __init__(self, model, items): + self.model = model + self.items = items + + def __getitem__(self, k): + return self.model.objects.get(id=self.items[k]) - def cache_obj(self, obj): - int_cache_keys = [k for k in obj.__dict__.keys() if self.int_cache_re.match(k)] + def __iter__(self): + for id in self.items: + yield self.model.objects.get(id=id) - for k in int_cache_keys: - del obj.__dict__[k] + def __len__(self): + return len(self.items) + +class CachedQuerySet(models.query.QuerySet): + def lazy(self): + if len(self.query.extra) == 0: + return LazyQueryList(self.model, list(self.values_list('id', flat=True))) + else: + return self - cache.set(self.model.cache_key(obj.id), obj, 60 * 60) + def obj_from_datadict(self, datadict): + obj = self.model() + obj.__dict__.update(datadict) + 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: - obj = super(CachedManager, self).get(*args, **kwargs) - self.cache_obj(obj) + obj = super(CachedQuerySet, self).get(*args, **kwargs) + obj.cache() else: - d = obj.__dict__ + obj = self.obj_from_datadict(obj) + obj.reset_original_state() return obj - - return super(CachedManager, self).get(*args, **kwargs) + + return super(CachedQuerySet, self).get(*args, **kwargs) + +class CachedManager(models.Manager): + use_for_related_fields = True + + def get_query_set(self): + return CachedQuerySet(self.model) def get_or_create(self, *args, **kwargs): try: @@ -59,183 +74,138 @@ class CachedManager(models.Manager): except: return super(CachedManager, self).get_or_create(*args, **kwargs) -denorm_update = django.dispatch.Signal(providing_args=["instance", "field", "old", "new"]) -class DenormalizedField(models.IntegerField): - __metaclass__ = models.SubfieldBase - - def contribute_to_class(self, cls, name): - super (DenormalizedField, self).contribute_to_class(cls, name) - if not hasattr(cls, '_denormalizad_fields'): - cls._denormalizad_fields = [] - - cls._denormalizad_fields.append(name) - -class BaseModel(models.Model): - objects = CachedManager() +class DenormalizedField(object): + def __init__(self, manager, *args, **kwargs): + self.manager = manager + self.filter = (args, kwargs) - class Meta: - abstract = True - app_label = 'forum' + def setup_class(self, cls, name): + dict_name = '_%s_dencache_' % name - def __init__(self, *args, **kwargs): - super(BaseModel, self).__init__(*args, **kwargs) - self._original_state = dict([(k, v) for k,v in self.__dict__.items() if not k in kwargs]) + def getter(inst): + val = inst.__dict__.get(dict_name, None) - @classmethod - def cache_key(cls, pk): - return '%s.%s:%s' % (settings.APP_URL, cls.__name__, pk) + if val is None: + val = getattr(inst, self.manager).filter(*self.filter[0], **self.filter[1]).count() + inst.__dict__[dict_name] = val + inst.cache() - def get_dirty_fields(self): - missing = object() - return dict([(k, self._original_state.get(k, None)) for k,v in self.__dict__.items() - if self._original_state.get(k, missing) == missing or self._original_state[k] != v]) + return val - def save(self, *args, **kwargs): - put_back = None + def reset_cache(inst): + inst.__dict__.pop(dict_name, None) + inst.uncache() - if hasattr(self.__class__, '_denormalizad_fields'): - dirty = self.get_dirty_fields() - put_back = [f for f in self.__class__._denormalizad_fields if f in dirty] + cls.add_to_class(name, property(getter)) + cls.add_to_class("reset_%s_cache" % name, reset_cache) - if put_back: - for n in put_back: - self.__dict__[n] = models.F(n) + (self.__dict__[n] - dirty[n]) - super(BaseModel, self).save(*args, **kwargs) +class BaseMetaClass(models.Model.__metaclass__): + to_denormalize = [] - if put_back: - try: - self.__dict__.update( - self.__class__.objects.filter(id=self.id).values(*put_back)[0] - ) - for f in put_back: - denorm_update.send(sender=self.__class__, instance=self, field=f, - old=self._original_state[f], new=self.__dict__[f]) - except: - #todo: log this properly - pass + def __new__(cls, *args, **kwargs): + new_cls = super(BaseMetaClass, cls).__new__(cls, *args, **kwargs) - self._original_state = dict(self.__dict__) - self.__class__.objects.cache_obj(self) + BaseMetaClass.to_denormalize.extend( + [(new_cls, name, field) for name, field in new_cls.__dict__.items() if isinstance(field, DenormalizedField)] + ) - def delete(self): - cache.delete(self.cache_key(self.pk)) - super(BaseModel, self).delete() + return new_cls + @classmethod + def setup_denormalizes(cls): + for new_cls, name, field in BaseMetaClass.to_denormalize: + field.setup_class(new_cls, name) -class ActiveObjectManager(models.Manager): - use_for_related_fields = True - def get_query_set(self): - return super(ActiveObjectManager, self).get_query_set().filter(canceled=False) -class UndeletedObjectManager(models.Manager): - def get_query_set(self): - return super(UndeletedObjectManager, self).get_query_set().filter(deleted=False) +class BaseModel(models.Model): + __metaclass__ = BaseMetaClass -class GenericContent(models.Model): - content_type = models.ForeignKey(ContentType) - object_id = models.PositiveIntegerField() - content_object = generic.GenericForeignKey('content_type', 'object_id') + objects = CachedManager() class Meta: abstract = True app_label = 'forum' -class MetaContent(BaseModel): - node = models.ForeignKey('Node', null=True, related_name='%(class)ss') - def __init__(self, *args, **kwargs): - if 'content_object' in kwargs: - kwargs['node'] = kwargs['content_object'] - del kwargs['content_object'] - - super (MetaContent, self).__init__(*args, **kwargs) - - @property - def content_object(self): - return self.node.leaf - - class Meta: - abstract = True - app_label = 'forum' + super(BaseModel, self).__init__(*args, **kwargs) + self.reset_original_state(kwargs.keys()) -from user import User + 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])) -class UserContent(models.Model): - user = models.ForeignKey(User, related_name='%(class)ss') + def get_dirty_fields(self): + return [f.name for f in self._meta.fields if self._original_state[f.attname] != self.__dict__[f.attname]] - class Meta: - abstract = True - app_label = 'forum' + def _as_dict(self): + return dict([(name, getattr(self, name)) for name in + ([f.attname for f in self._meta.fields] + [k for k in self.__dict__.keys() if k.endswith('_dencache_')]) + ]) + def _get_update_kwargs(self): + return dict([ + (f.name, getattr(self, f.name)) for f in self._meta.fields if self._original_state[f.attname] != self.__dict__[f.attname] + ]) -marked_deleted = django.dispatch.Signal(providing_args=["instance", "deleted_by"]) + def save(self, full_save=False, *args, **kwargs): + put_back = [k for k, v in self.__dict__.items() if isinstance(v, models.expressions.ExpressionNode)] -class DeletableContent(models.Model): - deleted = models.BooleanField(default=False) - deleted_at = models.DateTimeField(null=True, blank=True) - deleted_by = models.ForeignKey(User, null=True, blank=True, related_name='deleted_%(class)ss') + if self.id and not full_save: + self.__class__.objects.filter(id=self.id).update(**self._get_update_kwargs()) + else: + super(BaseModel, self).save() - active = UndeletedObjectManager() + if put_back: + try: + self.__dict__.update( + self.__class__.objects.filter(id=self.id).values(*put_back)[0] + ) + except: + logging.error("Unable to read %s from %s" % (", ".join(put_back), self.__class__.__name__)) + self.uncache() - class Meta: - abstract = True - app_label = 'forum' + self.reset_original_state() + self.cache() - def mark_deleted(self, user): - if not self.deleted: - self.deleted = True - self.deleted_at = datetime.datetime.now() - self.deleted_by = user - self.save() - marked_deleted.send(sender=self.__class__, instance=self, deleted_by=user) - return True - else: - return False + @classmethod + def _generate_cache_key(cls, key, group=None): + if group is None: + group = cls.__name__ - def unmark_deleted(self): - if self.deleted: - self.deleted = False - self.save() - return True - else: - return False + return '%s:%s:%s' % (settings.APP_URL, group, key) -mark_canceled = django.dispatch.Signal(providing_args=['instance']) + def cache_key(self): + return self._generate_cache_key(self.id) -class CancelableContent(models.Model): - canceled = models.BooleanField(default=False) + @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] - def cancel(self): - if not self.canceled: - self.canceled = True - self.save() - mark_canceled.send(sender=self.__class__, instance=self) - return True - - return False + return cls._generate_cache_key(pk) + except: + return None - class Meta: - abstract = True - app_label = 'forum' + def cache(self): + cache.set(self.cache_key(), self._as_dict(), 60 * 60) + def uncache(self): + cache.delete(self.cache_key()) -from node import Node, NodeRevision + def delete(self): + self.uncache() + super(BaseModel, self).delete() -class QandA(Node): - wiki = models.BooleanField(default=False) - wikified_at = models.DateTimeField(null=True, blank=True) - class Meta: - abstract = True - app_label = 'forum' +from user import User +from node import Node, NodeRevision, NodeManager +from action import Action - def wikify(self): - if not self.wiki: - self.wiki = True - self.wikified_at = datetime.datetime.now() - self.save()