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