forum/models/base.py

   1 import datetime
   2 import hashlib
   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 django.conf import settings
  18 from forum import const
  19 import logging
  20
  21 from forum.const import *
  22
  23 class CachedManager(models.Manager):
  24     use_for_related_fields = True
  25
  26     def get(self, *args, **kwargs):
  27         try:
  28             pk = [v for (k,v) in kwargs.items() if k in ('pk', 'pk__exact', 'id', 'id__exact') or k.endswith('_ptr__pk')][0]
  29         except:
  30             pk = None
  31
  32         if pk is not None:
  33             key = self.model.cache_key(pk)
  34             obj = cache.get(key)
  35
  36             if obj is None:
  37                 obj = super(CachedManager, self).get(*args, **kwargs)
  38                 cache.set(key, obj, 60 * 60)
  39
  40             return obj
  41
  42         return super(CachedManager, self).get(*args, **kwargs)
  43
  44     def get_or_create(self, *args, **kwargs):
  45         try:
  46             return self.get(*args, **kwargs)
  47         except:
  48             return super(CachedManager, self).get_or_create(*args, **kwargs)
  49
  50
  51 class BaseModel(models.Model):
  52     objects = CachedManager()
  53
  54     class Meta:
  55         abstract = True
  56         app_label = 'forum'
  57
  58     def __init__(self, *args, **kwargs):
  59         super(BaseModel, self).__init__(*args, **kwargs)
  60         self._original_state = dict([(k, v) for k,v in self.__dict__.items() if not k in kwargs])
  61
  62     @classmethod
  63     def cache_key(cls, pk):
  64         return '%s.%s:%s' % (settings.APP_URL, cls.__name__, pk)
  65
  66     def get_dirty_fields(self):
  67         missing = object()
  68         return dict([(k, self._original_state.get(k, None)) for k,v in self.__dict__.items()
  69                  if self._original_state.get(k, missing) == missing or self._original_state[k] != v])
  70
  71     def save(self, *args, **kwargs):
  72         super(BaseModel, self).save(*args, **kwargs)
  73         self._original_state = dict(self.__dict__)
  74         cache.set(self.cache_key(self.pk), self, 86400)
  75
  76     def delete(self):
  77         cache.delete(self.cache_key(self.pk))
  78         super(BaseModel, self).delete()
  79
  80
  81 class ActiveObjectManager(models.Manager):
  82     use_for_related_fields = True
  83     def get_query_set(self):
  84         return super(ActiveObjectManager, self).get_query_set().filter(canceled=False)
  85
  86 class UndeletedObjectManager(models.Manager):
  87     def get_query_set(self):
  88         return super(UndeletedObjectManager, self).get_query_set().filter(deleted=False)
  89
  90 class GenericContent(BaseModel):
  91     """
  92         Base class for Vote, Comment and FlaggedItem
  93     """
  94     content_type   = models.ForeignKey(ContentType)
  95     object_id      = models.PositiveIntegerField()
  96     content_object = generic.GenericForeignKey('content_type', 'object_id')
  97
  98     class Meta:
  99         abstract = True
 100         app_label = 'forum'
 101
 102 class MetaContent(BaseModel):
 103     node = models.ForeignKey('Node', null=True, related_name='%(class)ss')
 104
 105     def __init__(self, *args, **kwargs):
 106         if 'content_object' in kwargs:
 107             kwargs['node'] = kwargs['content_object']
 108             del kwargs['content_object']
 109
 110         super (MetaContent, self).__init__(*args, **kwargs)
 111
 112     @property
 113     def content_object(self):
 114         return self.node.leaf
 115
 116     class Meta:
 117         abstract = True
 118         app_label = 'forum'
 119
 120 from user import User
 121
 122 class UserContent(models.Model):
 123     user = models.ForeignKey(User, related_name='%(class)ss')
 124
 125     class Meta:
 126         abstract = True
 127         app_label = 'forum'
 128
 129
 130 marked_deleted = django.dispatch.Signal(providing_args=["instance", "deleted_by"])
 131
 132 class DeletableContent(models.Model):
 133     deleted     = models.BooleanField(default=False)
 134     deleted_at  = models.DateTimeField(null=True, blank=True)
 135     deleted_by  = models.ForeignKey(User, null=True, blank=True, related_name='deleted_%(class)ss')
 136
 137     active = UndeletedObjectManager()
 138
 139     class Meta:
 140         abstract = True
 141         app_label = 'forum'
 142
 143     def mark_deleted(self, user):
 144         if not self.deleted:
 145             self.deleted = True
 146             self.deleted_at = datetime.datetime.now()
 147             self.deleted_by = user
 148             self.save()
 149             marked_deleted.send(sender=self.__class__, instance=self, deleted_by=user)
 150             return True
 151         else:
 152             return False
 153
 154     def unmark_deleted(self):
 155         if self.deleted:
 156             self.deleted = False
 157             self.save()
 158             return True
 159         else:
 160             return False
 161
 162 mark_canceled = django.dispatch.Signal(providing_args=['instance'])
 163
 164 class CancelableContent(models.Model):
 165     canceled = models.BooleanField(default=False)
 166
 167     def cancel(self):
 168         if not self.canceled:
 169             self.canceled = True
 170             self.save()
 171             mark_canceled.send(sender=self.__class__, instance=self)
 172             return True
 173
 174         return False
 175
 176     class Meta:
 177         abstract = True
 178         app_label = 'forum'
 179
 180
 181 from node import Node, NodeRevision
 182
 183 class QandA(Node):
 184     wiki                 = models.BooleanField(default=False)
 185     wikified_at          = models.DateTimeField(null=True, blank=True)
 186
 187     class Meta:
 188         abstract = True
 189         app_label = 'forum'
 190
 191     def wikify(self):
 192         if not self.wiki:
 193             self.wiki = True
 194             self.wikified_at = datetime.datetime.now()
 195             self.save()
 196
 197     def save(self, *args, **kwargs):
 198         self.__dict__['score'] = self.__dict__['vote_up_count'] - self.__dict__['vote_down_count']
 199         super(QandA,self).save(*args, **kwargs)
 200
 201         try:
 202             ping_google()
 203         except Exception:
 204             logging.debug('problem pinging google did you register you sitemap with google?')
 205
 206
 207