forum/models/node.py

   1 from base import *
   2 import re
   3 from tag import Tag
   4
   5 import markdown
   6 from django.utils.translation import ugettext as _
   7 from django.utils.safestring import mark_safe
   8 from django.utils.html import strip_tags
   9 from forum.utils.html import sanitize_html
  10 from forum.settings import SUMMARY_LENGTH
  11 from forum.modules import MODULES_PACKAGE
  12 from utils import PickledObjectField
  13
  14 class NodeContent(models.Model):
  15     title      = models.CharField(max_length=300)
  16     tagnames   = models.CharField(max_length=125)
  17     author     = models.ForeignKey(User, related_name='%(class)ss')
  18     body       = models.TextField()
  19
  20     @property
  21     def user(self):
  22         return self.author
  23
  24     @property
  25     def html(self):
  26         return self.body
  27
  28     @classmethod
  29     def _as_markdown(cls, content, *extensions):
  30         try:
  31             return mark_safe(sanitize_html(markdown.markdown(content, extensions=extensions)))
  32         except Exception, e:
  33             import traceback
  34             logging.error("Caught exception %s in markdown parser rendering %s %s:\s %s" % (
  35                 str(e), cls.__name__, str(e), traceback.format_exc()))
  36             return ''
  37
  38     def as_markdown(self, *extensions):
  39         return self._as_markdown(self.body, *extensions)
  40
  41     @property
  42     def headline(self):
  43         return self.title
  44
  45     def tagname_list(self):
  46         if self.tagnames:
  47             t = [name.strip() for name in self.tagnames.split(u' ') if name]
  48             return [name.strip() for name in self.tagnames.split(u' ') if name]
  49         else:
  50             return []
  51
  52     def tagname_meta_generator(self):
  53         return u','.join([tag for tag in self.tagname_list()])
  54
  55     class Meta:
  56         abstract = True
  57         app_label = 'forum'
  58
  59 class NodeMetaClass(BaseMetaClass):
  60     types = {}
  61
  62     def __new__(cls, *args, **kwargs):
  63         new_cls = super(NodeMetaClass, cls).__new__(cls, *args, **kwargs)
  64
  65         if not new_cls._meta.abstract and new_cls.__name__ is not 'Node':
  66             NodeMetaClass.types[new_cls.get_type()] = new_cls
  67
  68         return new_cls
  69
  70     @classmethod
  71     def setup_relations(cls):
  72         for node_cls in NodeMetaClass.types.values():
  73             NodeMetaClass.setup_relation(node_cls)
  74
  75     @classmethod
  76     def setup_relation(cls, node_cls):
  77         name = node_cls.__name__.lower()
  78
  79         def children(self):
  80             return node_cls.objects.filter(parent=self)
  81
  82         def parent(self):
  83             if (self.parent is not None) and self.parent.node_type == name:
  84                 return self.parent.leaf
  85
  86             return None
  87
  88         Node.add_to_class(name + 's', property(children))
  89         Node.add_to_class(name, property(parent))
  90
  91
  92 class NodeQuerySet(CachedQuerySet):
  93     def obj_from_datadict(self, datadict):
  94         cls = NodeMetaClass.types.get(datadict.get("node_type", ""), None)
  95         if cls:
  96             obj = cls()
  97             obj.__dict__.update(datadict)
  98             return obj
  99         else:
 100             return super(NodeQuerySet, self).obj_from_datadict(datadict)
 101
 102     def get(self, *args, **kwargs):
 103         node = super(NodeQuerySet, self).get(*args, **kwargs).leaf
 104
 105         if not isinstance(node, self.model):
 106             raise self.model.DoesNotExist()
 107
 108         return node
 109
 110     def any_state(self, *args):
 111         filter = None
 112
 113         for s in args:
 114             s_filter = models.Q(state_string__contains="(%s)" % s)
 115             filter = filter and (filter | s_filter) or s_filter
 116
 117         if filter:
 118             return self.filter(filter)
 119         else:
 120             return self
 121
 122     def all_states(self, *args):
 123         filter = None
 124
 125         for s in args:
 126             s_filter = models.Q(state_string__contains="(%s)" % s)
 127             filter = filter and (filter & s_filter) or s_filter
 128
 129         if filter:
 130             return self.filter(filter)
 131         else:
 132             return self
 133
 134     def filter_state(self, **kwargs):
 135         apply_bool = lambda q, b: b and q or ~q
 136         return self.filter(*[apply_bool(models.Q(state_string__contains="(%s)" % s), b) for s, b in kwargs.items()])
 137
 138     def children_count(self, child_type):
 139         return NodeMetaClass.types[child_type].objects.filter_state(deleted=False).filter(parent__in=self).count()
 140
 141
 142 class NodeManager(CachedManager):
 143     use_for_related_fields = True
 144
 145     def get_query_set(self):
 146         qs = NodeQuerySet(self.model)
 147
 148         if self.model is not Node:
 149             return qs.filter(node_type=self.model.get_type())
 150         else:
 151             return qs
 152
 153     def get_for_types(self, types, *args, **kwargs):
 154         kwargs['node_type__in'] = [t.get_type() for t in types]
 155         return self.get(*args, **kwargs)
 156
 157     def filter_state(self, **kwargs):
 158         return self.all().filter_state(**kwargs)
 159
 160
 161 class NodeStateDict(object):
 162     def __init__(self, node):
 163         self.__dict__['_node'] = node
 164
 165     def __getattr__(self, name):
 166         if self.__dict__.get(name, None):
 167             return self.__dict__[name]
 168
 169         try:
 170             node = self.__dict__['_node']
 171             action = NodeState.objects.get(node=node, state_type=name).action
 172             self.__dict__[name] = action
 173             return action
 174         except:
 175             return None
 176
 177     def __setattr__(self, name, value):
 178         current = self.__getattr__(name)
 179
 180         if value:
 181             if current:
 182                 current.action = value
 183                 current.save()
 184             else:
 185                 node = self.__dict__['_node']
 186                 state = NodeState(node=node, action=value, state_type=name)
 187                 state.save()
 188                 self.__dict__[name] = value
 189
 190                 if not "(%s)" % name in node.state_string:
 191                     node.state_string = "%s(%s)" % (node.state_string, name)
 192                     node.save()
 193         else:
 194             if current:
 195                 node = self.__dict__['_node']
 196                 node.state_string = "".join("(%s)" % s for s in re.findall('\w+', node.state_string) if s != name)
 197                 node.save()
 198                 current.node_state.delete()
 199                 del self.__dict__[name]
 200
 201
 202 class NodeStateQuery(object):
 203     def __init__(self, node):
 204         self.__dict__['_node'] = node
 205
 206     def __getattr__(self, name):
 207         node = self.__dict__['_node']
 208         return "(%s)" % name in node.state_string
 209
 210
 211 class Node(BaseModel, NodeContent):
 212     __metaclass__ = NodeMetaClass
 213
 214     node_type            = models.CharField(max_length=16, default='node')
 215     parent               = models.ForeignKey('Node', related_name='children', null=True)
 216     abs_parent           = models.ForeignKey('Node', related_name='all_children', null=True)
 217
 218     added_at             = models.DateTimeField(default=datetime.datetime.now)
 219     score                 = models.IntegerField(default=0)
 220
 221     state_string          = models.TextField(default='')
 222     last_edited           = models.ForeignKey('Action', null=True, unique=True, related_name="edited_node")
 223
 224     last_activity_by       = models.ForeignKey(User, null=True)
 225     last_activity_at       = models.DateTimeField(null=True, blank=True)
 226
 227     tags                 = models.ManyToManyField('Tag', related_name='%(class)ss')
 228     active_revision       = models.OneToOneField('NodeRevision', related_name='active', null=True)
 229
 230     extra = PickledObjectField()
 231     extra_ref = models.ForeignKey('Node', null=True)
 232     extra_count = models.IntegerField(default=0)
 233
 234     marked = models.BooleanField(default=False)
 235
 236     comment_count = DenormalizedField("children", node_type="comment", canceled=False)
 237     flag_count = DenormalizedField("flags")
 238
 239     friendly_name = _("post")
 240
 241     objects = NodeManager()
 242
 243     def __unicode__(self):
 244         return self.headline
 245
 246     @classmethod
 247     def _generate_cache_key(cls, key, group="node"):
 248         return super(Node, cls)._generate_cache_key(key, group)
 249
 250     @classmethod
 251     def get_type(cls):
 252         return cls.__name__.lower()
 253
 254     @property
 255     def leaf(self):
 256         leaf_cls = NodeMetaClass.types.get(self.node_type, None)
 257
 258         if leaf_cls is None:
 259             return self
 260
 261         leaf = leaf_cls()
 262         leaf.__dict__ = self.__dict__
 263         return leaf
 264
 265     @property
 266     def nstate(self):
 267         state = self.__dict__.get('_nstate', None)
 268
 269         if state is None:
 270             state = NodeStateDict(self)
 271             self._nstate = state
 272
 273         return state
 274
 275     @property
 276     def nis(self):
 277         nis = self.__dict__.get('_nis', None)
 278
 279         if nis is None:
 280             nis = NodeStateQuery(self)
 281             self._nis = nis
 282
 283         return nis
 284
 285     @property
 286     def last_activity(self):
 287         try:
 288             return self.actions.order_by('-action_date')[0].action_date
 289         except:
 290             return self.last_seen
 291
 292     @property
 293     def state_list(self):
 294         return [s.state_type for s in self.states.all()]
 295
 296     @property
 297     def deleted(self):
 298         return self.nis.deleted
 299
 300     @property
 301     def absolute_parent(self):
 302         if not self.abs_parent_id:
 303             return self
 304
 305         return self.abs_parent
 306
 307     @property
 308     def summary(self):
 309         return strip_tags(self.html)[:SUMMARY_LENGTH]
 310
 311     @models.permalink
 312     def get_revisions_url(self):
 313         return ('revisions', (), {'id': self.id})
 314
 315     def update_last_activity(self, user, save=False, time=None):
 316         if not time:
 317             time = datetime.datetime.now()
 318
 319         self.last_activity_by = user
 320         self.last_activity_at = time
 321
 322         if self.parent:
 323             self.parent.update_last_activity(user, save=True, time=time)
 324
 325         if save:
 326             self.save()
 327
 328     def _create_revision(self, user, number, **kwargs):
 329         revision = NodeRevision(author=user, revision=number, node=self, **kwargs)
 330         revision.save()
 331         return revision
 332
 333     def create_revision(self, user, **kwargs):
 334         number = self.revisions.aggregate(last=models.Max('revision'))['last'] + 1
 335         revision = self._create_revision(user, number, **kwargs)
 336         self.activate_revision(user, revision, extensions=['urlize'])
 337         return revision
 338
 339     def activate_revision(self, user, revision, extensions=['urlize']):
 340         self.title = revision.title
 341         self.tagnames = revision.tagnames
 342
 343         from forum.utils.userlinking import auto_user_link
 344
 345         self.body = auto_user_link(self, self._as_markdown(revision.body, *extensions))
 346
 347         self.active_revision = revision
 348         self.update_last_activity(user)
 349
 350         self.save()
 351
 352     def _list_changes_in_tags(self):
 353         dirty = self.get_dirty_fields()
 354
 355         if not 'tagnames' in dirty:
 356             return None
 357         else:
 358             if self._original_state['tagnames']:
 359                 old_tags = set(name for name in self._original_state['tagnames'].split(u' '))
 360             else:
 361                 old_tags = set()
 362             new_tags = set(name for name in self.tagnames.split(u' ') if name)
 363
 364             return dict(
 365                     current=list(new_tags),
 366                     added=list(new_tags - old_tags),
 367                     removed=list(old_tags - new_tags)
 368                     )
 369
 370     def _last_active_user(self):
 371         return self.last_edited and self.last_edited.by or self.author
 372
 373     def _process_changes_in_tags(self):
 374         tag_changes = self._list_changes_in_tags()
 375
 376         if tag_changes is not None:
 377             for name in tag_changes['added']:
 378                 try:
 379                     tag = Tag.objects.get(name=name)
 380                 except:
 381                     tag = Tag.objects.create(name=name, created_by=self._last_active_user())
 382
 383                 if not self.nis.deleted:
 384                     tag.add_to_usage_count(1)
 385                     tag.save()
 386
 387             if not self.nis.deleted:
 388                 for name in tag_changes['removed']:
 389                     try:
 390                         tag = Tag.objects.get(name=name)
 391                         tag.add_to_usage_count(-1)
 392                         tag.save()
 393                     except:
 394                         pass
 395
 396             return True
 397
 398         return False
 399
 400     def mark_deleted(self, action):
 401         self.nstate.deleted = action
 402         self.save()
 403
 404         if action:
 405             for tag in self.tags.all():
 406                 tag.add_to_usage_count(-1)
 407                 tag.save()
 408         else:
 409             for tag in Tag.objects.filter(name__in=self.tagname_list()):
 410                 tag.add_to_usage_count(1)
 411                 tag.save()
 412
 413     def delete(self, *args, **kwargs):
 414         self.active_revision = None
 415         self.save()
 416
 417         for n in self.children.all():
 418             n.delete()
 419
 420         for a in self.actions.all():
 421             a.cancel()
 422
 423         super(Node, self).delete(*args, **kwargs)
 424
 425     def save(self, *args, **kwargs):
 426         if not self.id:
 427             self.node_type = self.get_type()
 428             super(BaseModel, self).save(*args, **kwargs)
 429             self.active_revision = self._create_revision(self.author, 1, title=self.title, tagnames=self.tagnames,
 430                                                          body=self.body)
 431             self.activate_revision(self.author, self.active_revision)
 432             self.update_last_activity(self.author, time=self.added_at)
 433
 434         if self.parent_id and not self.abs_parent_id:
 435             self.abs_parent = self.parent.absolute_parent
 436
 437         tags_changed = self._process_changes_in_tags()
 438
 439         super(Node, self).save(*args, **kwargs)
 440
 441         if tags_changed: self.tags = list(Tag.objects.filter(name__in=self.tagname_list()))
 442
 443     class Meta:
 444         app_label = 'forum'
 445
 446
 447 class NodeRevision(BaseModel, NodeContent):
 448     node       = models.ForeignKey(Node, related_name='revisions')
 449     summary    = models.CharField(max_length=300)
 450     revision   = models.PositiveIntegerField()
 451     revised_at = models.DateTimeField(default=datetime.datetime.now)
 452
 453     class Meta:
 454         unique_together = ('node', 'revision')
 455         app_label = 'forum'
 456
 457
 458 class NodeState(models.Model):
 459     node       = models.ForeignKey(Node, related_name='states')
 460     state_type = models.CharField(max_length=16)
 461     action     = models.OneToOneField('Action', related_name="node_state")
 462
 463     class Meta:
 464         unique_together = ('node', 'state_type')
 465         app_label = 'forum'
 466
 467