-import datetime\r
-import hashlib\r
-from urllib import quote_plus, urlencode\r
-from django.db import models, IntegrityError, connection, transaction\r
-from django.utils.http import urlquote as django_urlquote\r
-from django.utils.html import strip_tags\r
-from django.core.urlresolvers import reverse\r
-from django.contrib.auth.models import User\r
-from django.contrib.contenttypes import generic\r
-from django.contrib.contenttypes.models import ContentType\r
-from django.template.defaultfilters import slugify\r
-from django.db.models.signals import post_delete, post_save, pre_save\r
-from django.utils.translation import ugettext as _\r
-from django.utils.safestring import mark_safe\r
-from django.contrib.sitemaps import ping_google\r
-import django.dispatch\r
-from django.conf import settings\r
-import logging\r
-\r
-if settings.USE_SPHINX_SEARCH == True:\r
- from djangosphinx.models import SphinxSearch\r
-\r
-from forum.const import *\r
-\r
-class MetaContent(models.Model):\r
- """\r
- Base class for Vote, Comment and FlaggedItem\r
- """\r
- content_type = models.ForeignKey(ContentType)\r
- object_id = models.PositiveIntegerField()\r
- content_object = generic.GenericForeignKey('content_type', 'object_id')\r
- user = models.ForeignKey(User, related_name='%(class)ss')\r
-\r
- class Meta:\r
- abstract = True\r
- app_label = 'forum'\r
-\r
-\r
-class DeletableContent(models.Model):\r
- deleted = models.BooleanField(default=False)\r
- deleted_at = models.DateTimeField(null=True, blank=True)\r
- deleted_by = models.ForeignKey(User, null=True, blank=True, related_name='deleted_%(class)ss')\r
-\r
- class Meta:\r
- abstract = True\r
- app_label = 'forum'\r
-\r
-\r
-class ContentRevision(models.Model):\r
- """\r
- Base class for QuestionRevision and AnswerRevision\r
- """\r
- revision = models.PositiveIntegerField()\r
- author = models.ForeignKey(User, related_name='%(class)ss')\r
- revised_at = models.DateTimeField()\r
- summary = models.CharField(max_length=300, blank=True)\r
- text = models.TextField()\r
-\r
- class Meta:\r
- abstract = True\r
- app_label = 'forum'\r
-\r
-\r
-class AnonymousContent(models.Model):\r
- """\r
- Base class for AnonymousQuestion and AnonymousAnswer\r
- """\r
- session_key = models.CharField(max_length=40) #session id for anonymous questions\r
- wiki = models.BooleanField(default=False)\r
- added_at = models.DateTimeField(default=datetime.datetime.now)\r
- ip_addr = models.IPAddressField(max_length=21) #allow high port numbers\r
- author = models.ForeignKey(User,null=True)\r
- text = models.TextField()\r
- summary = models.CharField(max_length=180)\r
-\r
- class Meta:\r
- abstract = True\r
- app_label = 'forum'\r
-\r
-\r
-from meta import Comment, Vote, FlaggedItem\r
-\r
-class Content(models.Model):\r
- """\r
- Base class for Question and Answer\r
- """\r
- author = models.ForeignKey(User, related_name='%(class)ss')\r
- added_at = models.DateTimeField(default=datetime.datetime.now)\r
-\r
- wiki = models.BooleanField(default=False)\r
- wikified_at = models.DateTimeField(null=True, blank=True)\r
-\r
- locked = models.BooleanField(default=False)\r
- locked_by = models.ForeignKey(User, null=True, blank=True, related_name='locked_%(class)ss')\r
- locked_at = models.DateTimeField(null=True, blank=True)\r
-\r
- score = models.IntegerField(default=0)\r
- vote_up_count = models.IntegerField(default=0)\r
- vote_down_count = models.IntegerField(default=0)\r
-\r
- comment_count = models.PositiveIntegerField(default=0)\r
- offensive_flag_count = models.SmallIntegerField(default=0)\r
-\r
- last_edited_at = models.DateTimeField(null=True, blank=True)\r
- last_edited_by = models.ForeignKey(User, null=True, blank=True, related_name='last_edited_%(class)ss')\r
-\r
- html = models.TextField()\r
- comments = generic.GenericRelation(Comment)\r
- votes = generic.GenericRelation(Vote)\r
- flagged_items = generic.GenericRelation(FlaggedItem)\r
-\r
- class Meta:\r
- abstract = True\r
- app_label = 'forum'\r
-\r
- def save(self,**kwargs):\r
- super(Content,self).save(**kwargs)\r
- try:\r
- ping_google()\r
- except Exception:\r
- logging.debug('problem pinging google did you register you sitemap with google?')\r
-\r
- def get_object_comments(self):\r
- comments = self.comments.all().order_by('id')\r
- return comments\r
-\r
- def post_get_last_update_info(self):\r
- when = self.added_at\r
- who = self.author\r
- if self.last_edited_at and self.last_edited_at > when:\r
- when = self.last_edited_at\r
- who = self.last_edited_by\r
- comments = self.comments.all()\r
- if len(comments) > 0:\r
- for c in comments:\r
- if c.added_at > when:\r
- when = c.added_at\r
- who = c.user\r
- return when, who
\ No newline at end of file
+import datetime
+import re
+try:
+ from hashlib import md5
+except:
+ from md5 import new as md5
+from urllib import quote_plus, urlencode
+from django.db import models, IntegrityError, connection, transaction
+from django.utils.http import urlquote as django_urlquote
+from django.utils.html import strip_tags
+from django.conf import settings as django_settings
+from django.core.urlresolvers import reverse
+from django.contrib.contenttypes import generic
+from django.contrib.contenttypes.models import ContentType
+from django.core.cache import cache
+from django.template.defaultfilters import slugify
+from django.db.models.signals import post_delete, post_save, pre_save, pre_delete
+from django.utils.translation import ugettext as _
+from django.utils.safestring import mark_safe
+from django.utils.encoding import force_unicode
+from django.contrib.sitemaps import ping_google
+import django.dispatch
+from forum import settings
+import logging
+
+
+if not hasattr(cache, 'get_many'):
+ #put django 1.2 code here
+ pass
+
+class LazyQueryList(object):
+ def __init__(self, model, items):
+ self.items = items
+ self.model = model
+
+ def __getitem__(self, k):
+ return self.model.objects.get(id=self.items[k][0])
+
+ def __iter__(self):
+ for id in self.items:
+ yield self.model.objects.get(id=id[0])
+
+ def __len__(self):
+ return len(self.items)
+
+class ToFetch(unicode):
+ pass
+
+class CachedQuerySet(models.query.QuerySet):
+
+ def lazy(self):
+ if not len(self.query.aggregates):
+ values_list = ['id']
+
+ if len(self.query.extra):
+ extra_keys = self.query.extra.keys()
+ values_list += extra_keys
+
+ return LazyQueryList(self.model, list(self.values_list(*values_list)))
+ else:
+ return self
+
+ def obj_from_datadict(self, datadict):
+ obj = self.model()
+ obj.__dict__.update(datadict)
+
+ if hasattr(obj, '_state'):
+ obj._state.db = 'default'
+
+ return obj
+
+ def _base_clone(self):
+ return self._clone(klass=models.query.QuerySet)
+
+ def get(self, *args, **kwargs):
+ key = self.model.infer_cache_key(kwargs)
+
+ if key is not None:
+ obj = cache.get(key)
+
+ if obj is None:
+ obj = self._base_clone().get(*args, **kwargs)
+ obj.cache()
+ else:
+ obj = self.obj_from_datadict(obj)
+
+ obj.reset_original_state()
+
+ return obj
+
+ return self._base_clone().get(*args, **kwargs)
+
+ def _fetch_from_query_cache(self, key):
+ invalidation_key = self.model._get_cache_query_invalidation_key()
+ cached_result = cache.get_many([invalidation_key, key])
+
+ if not invalidation_key in cached_result:
+ self.model._set_query_cache_invalidation_timestamp()
+ return None
+
+ if (key in cached_result) and(cached_result[invalidation_key] < cached_result[key][0]):
+ return cached_result[key][1]
+
+ return None
+
+ def count(self):
+ cache_key = self.model._generate_cache_key("CNT:%s" % self._get_query_hash())
+ result = self._fetch_from_query_cache(cache_key)
+
+ if result is not None:
+ return result
+
+ result = super(CachedQuerySet, self).count()
+ cache.set(cache_key, (datetime.datetime.now(), result), 60 * 60)
+ return result
+
+ def iterator(self):
+ cache_key = self.model._generate_cache_key("QUERY:%s" % self._get_query_hash())
+ on_cache_query_attr = self.model.value_to_list_on_cache_query()
+
+ to_return = None
+ to_cache = {}
+
+ with_aggregates = len(self.query.aggregates) > 0
+ key_list = self._fetch_from_query_cache(cache_key)
+
+ if key_list is None:
+ if not with_aggregates:
+ values_list = [on_cache_query_attr]
+
+ if len(self.query.extra):
+ values_list += self.query.extra.keys()
+
+ key_list = [v[0] for v in self.values_list(*values_list)]
+ to_cache[cache_key] = (datetime.datetime.now(), key_list)
+ else:
+ to_return = list(super(CachedQuerySet, self).iterator())
+ to_cache[cache_key] = (datetime.datetime.now(), [
+ (row.__dict__[on_cache_query_attr], dict([(k, row.__dict__[k]) for k in self.query.aggregates.keys()]))
+ for row in to_return])
+ elif with_aggregates:
+ tmp = key_list
+ key_list = [k[0] for k in tmp]
+ with_aggregates = [k[1] for k in tmp]
+ del tmp
+
+ if (not to_return) and key_list:
+ row_keys = [self.model.infer_cache_key({on_cache_query_attr: attr}) for attr in key_list]
+ cached = cache.get_many(row_keys)
+
+ to_return = [
+ (ck in cached) and self.obj_from_datadict(cached[ck]) or ToFetch(force_unicode(key_list[i])) for i, ck in enumerate(row_keys)
+ ]
+
+ if len(cached) != len(row_keys):
+ to_fetch = [unicode(tr) for tr in to_return if isinstance(tr, ToFetch)]
+
+ fetched = dict([(force_unicode(r.__dict__[on_cache_query_attr]), r) for r in
+ models.query.QuerySet(self.model).filter(**{"%s__in" % on_cache_query_attr: to_fetch})])
+
+ to_return = [(isinstance(tr, ToFetch) and fetched[unicode(tr)] or tr) for tr in to_return]
+ to_cache.update(dict([(self.model.infer_cache_key({on_cache_query_attr: attr}), r._as_dict()) for attr, r in fetched.items()]))
+
+ if with_aggregates:
+ for i, r in enumerate(to_return):
+ r.__dict__.update(with_aggregates[i])
+
+
+ if len(to_cache):
+ cache.set_many(to_cache, 60 * 60)
+
+ if to_return:
+ for row in to_return:
+ if hasattr(row, 'leaf'):
+ row = row.leaf
+
+ row.reset_original_state()
+ yield row
+
+ def _get_query_hash(self):
+ try:
+ return md5(unicode(self.query).encode("utf-8")).hexdigest()
+ except:
+ try:
+ return md5(self.query).hexdigest()
+ except:
+ return md5(str(self.query)).hexdigest()
+
+
+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:
+ return self.get(*args, **kwargs)
+ except:
+ return super(CachedManager, self).get_or_create(*args, **kwargs)
+
+
+class DenormalizedField(object):
+ def __init__(self, manager, *args, **kwargs):
+ self.manager = manager
+ self.filter = (args, kwargs)
+
+ def setup_class(self, cls, name):
+ dict_name = '_%s_dencache_' % name
+
+ def getter(inst):
+ val = inst.__dict__.get(dict_name, None)
+
+ if val is None:
+ val = getattr(inst, self.manager).filter(*self.filter[0], **self.filter[1]).count()
+ inst.__dict__[dict_name] = val
+ inst.cache()
+
+ return val
+
+ def reset_cache(inst):
+ inst.__dict__.pop(dict_name, None)
+ inst.uncache()
+
+ cls.add_to_class(name, property(getter))
+ cls.add_to_class("reset_%s_cache" % name, reset_cache)
+
+
+class BaseMetaClass(models.Model.__metaclass__):
+ to_denormalize = []
+
+ def __new__(cls, *args, **kwargs):
+ new_cls = super(BaseMetaClass, cls).__new__(cls, *args, **kwargs)
+
+ BaseMetaClass.to_denormalize.extend(
+ [(new_cls, name, field) for name, field in new_cls.__dict__.items() if isinstance(field, DenormalizedField)]
+ )
+
+ return new_cls
+
+ @classmethod
+ def setup_denormalizes(cls):
+ for new_cls, name, field in BaseMetaClass.to_denormalize:
+ field.setup_class(new_cls, name)
+
+
+class BaseModel(models.Model):
+ __metaclass__ = BaseMetaClass
+
+ objects = CachedManager()
+
+ class Meta:
+ abstract = True
+ app_label = 'forum'
+
+ def __init__(self, *args, **kwargs):
+ super(BaseModel, self).__init__(*args, **kwargs)
+ self.reset_original_state(kwargs.keys())
+
+ 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]]
+
+ 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]
+ ])
+
+ 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 hasattr(self, '_state'):
+ self._state.db = 'default'
+
+ if self.id and not full_save:
+ self.__class__.objects.filter(id=self.id).update(**self._get_update_kwargs())
+ else:
+ super(BaseModel, self).save()
+
+ 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()
+
+ self.reset_original_state()
+ self._set_query_cache_invalidation_timestamp()
+ self.cache()
+
+ @classmethod
+ def _get_cache_query_invalidation_key(cls):
+ return cls._generate_cache_key("INV_TS")
+
+ @classmethod
+ def _set_query_cache_invalidation_timestamp(cls):
+ cache.set(cls._get_cache_query_invalidation_key(), datetime.datetime.now(), 60 * 60 * 24)
+
+ for base in filter(lambda c: issubclass(c, BaseModel) and (not c is BaseModel), cls.__bases__):
+ base._set_query_cache_invalidation_timestamp()
+
+ @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 value_to_list_on_cache_query(cls):
+ return '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]
+
+ cache_key = cls._generate_cache_key(pk)
+
+ if len(cache_key) > django_settings.CACHE_MAX_KEY_LENGTH:
+ cache_key = cache_key[:django_settings.CACHE_MAX_KEY_LENGTH]
+
+ return cache_key
+ except:
+ return None
+
+ def cache(self):
+ cache.set(self.cache_key(), self._as_dict(), 60 * 60)
+
+ def uncache(self):
+ cache.delete(self.cache_key())
+
+ def delete(self):
+ self.uncache()
+ self._set_query_cache_invalidation_timestamp()
+ super(BaseModel, self).delete()
+
+
+from user import User
+from node import Node, NodeRevision, NodeManager
+from action import Action
+
+
+
+
+
projects / osqa.git / blobdiff