--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/django/contrib/comments/models.py Wed Jan 20 00:34:04 2010 +0100
@@ -0,0 +1,191 @@
+import datetime
+from django.contrib.auth.models import User
+from django.contrib.comments.managers import CommentManager
+from django.contrib.contenttypes import generic
+from django.contrib.contenttypes.models import ContentType
+from django.contrib.sites.models import Site
+from django.db import models
+from django.core import urlresolvers
+from django.utils.translation import ugettext_lazy as _
+from django.conf import settings
+
+COMMENT_MAX_LENGTH = getattr(settings,'COMMENT_MAX_LENGTH',3000)
+
+class BaseCommentAbstractModel(models.Model):
+ """
+ An abstract base class that any custom comment models probably should
+ subclass.
+ """
+
+ # Content-object field
+ content_type = models.ForeignKey(ContentType,
+ verbose_name=_('content type'),
+ related_name="content_type_set_for_%(class)s")
+ object_pk = models.TextField(_('object ID'))
+ content_object = generic.GenericForeignKey(ct_field="content_type", fk_field="object_pk")
+
+ # Metadata about the comment
+ site = models.ForeignKey(Site)
+
+ class Meta:
+ abstract = True
+
+ def get_content_object_url(self):
+ """
+ Get a URL suitable for redirecting to the content object.
+ """
+ return urlresolvers.reverse(
+ "comments-url-redirect",
+ args=(self.content_type_id, self.object_pk)
+ )
+
+class Comment(BaseCommentAbstractModel):
+ """
+ A user comment about some object.
+ """
+
+ # Who posted this comment? If ``user`` is set then it was an authenticated
+ # user; otherwise at least user_name should have been set and the comment
+ # was posted by a non-authenticated user.
+ user = models.ForeignKey(User, verbose_name=_('user'),
+ blank=True, null=True, related_name="%(class)s_comments")
+ user_name = models.CharField(_("user's name"), max_length=50, blank=True)
+ user_email = models.EmailField(_("user's email address"), blank=True)
+ user_url = models.URLField(_("user's URL"), blank=True)
+
+ comment = models.TextField(_('comment'), max_length=COMMENT_MAX_LENGTH)
+
+ # Metadata about the comment
+ submit_date = models.DateTimeField(_('date/time submitted'), default=None)
+ ip_address = models.IPAddressField(_('IP address'), blank=True, null=True)
+ is_public = models.BooleanField(_('is public'), default=True,
+ help_text=_('Uncheck this box to make the comment effectively ' \
+ 'disappear from the site.'))
+ is_removed = models.BooleanField(_('is removed'), default=False,
+ help_text=_('Check this box if the comment is inappropriate. ' \
+ 'A "This comment has been removed" message will ' \
+ 'be displayed instead.'))
+
+ # Manager
+ objects = CommentManager()
+
+ class Meta:
+ db_table = "django_comments"
+ ordering = ('submit_date',)
+ permissions = [("can_moderate", "Can moderate comments")]
+ verbose_name = _('comment')
+ verbose_name_plural = _('comments')
+
+ def __unicode__(self):
+ return "%s: %s..." % (self.name, self.comment[:50])
+
+ def save(self, force_insert=False, force_update=False):
+ if self.submit_date is None:
+ self.submit_date = datetime.datetime.now()
+ super(Comment, self).save(force_insert, force_update)
+
+ def _get_userinfo(self):
+ """
+ Get a dictionary that pulls together information about the poster
+ safely for both authenticated and non-authenticated comments.
+
+ This dict will have ``name``, ``email``, and ``url`` fields.
+ """
+ if not hasattr(self, "_userinfo"):
+ self._userinfo = {
+ "name" : self.user_name,
+ "email" : self.user_email,
+ "url" : self.user_url
+ }
+ if self.user_id:
+ u = self.user
+ if u.email:
+ self._userinfo["email"] = u.email
+
+ # If the user has a full name, use that for the user name.
+ # However, a given user_name overrides the raw user.username,
+ # so only use that if this comment has no associated name.
+ if u.get_full_name():
+ self._userinfo["name"] = self.user.get_full_name()
+ elif not self.user_name:
+ self._userinfo["name"] = u.username
+ return self._userinfo
+ userinfo = property(_get_userinfo, doc=_get_userinfo.__doc__)
+
+ def _get_name(self):
+ return self.userinfo["name"]
+ def _set_name(self, val):
+ if self.user_id:
+ raise AttributeError(_("This comment was posted by an authenticated "\
+ "user and thus the name is read-only."))
+ self.user_name = val
+ name = property(_get_name, _set_name, doc="The name of the user who posted this comment")
+
+ def _get_email(self):
+ return self.userinfo["email"]
+ def _set_email(self, val):
+ if self.user_id:
+ raise AttributeError(_("This comment was posted by an authenticated "\
+ "user and thus the email is read-only."))
+ self.user_email = val
+ email = property(_get_email, _set_email, doc="The email of the user who posted this comment")
+
+ def _get_url(self):
+ return self.userinfo["url"]
+ def _set_url(self, val):
+ self.user_url = val
+ url = property(_get_url, _set_url, doc="The URL given by the user who posted this comment")
+
+ def get_absolute_url(self, anchor_pattern="#c%(id)s"):
+ return self.get_content_object_url() + (anchor_pattern % self.__dict__)
+
+ def get_as_text(self):
+ """
+ Return this comment as plain text. Useful for emails.
+ """
+ d = {
+ 'user': self.user or self.name,
+ 'date': self.submit_date,
+ 'comment': self.comment,
+ 'domain': self.site.domain,
+ 'url': self.get_absolute_url()
+ }
+ return _('Posted by %(user)s at %(date)s\n\n%(comment)s\n\nhttp://%(domain)s%(url)s') % d
+
+class CommentFlag(models.Model):
+ """
+ Records a flag on a comment. This is intentionally flexible; right now, a
+ flag could be:
+
+ * A "removal suggestion" -- where a user suggests a comment for (potential) removal.
+
+ * A "moderator deletion" -- used when a moderator deletes a comment.
+
+ You can (ab)use this model to add other flags, if needed. However, by
+ design users are only allowed to flag a comment with a given flag once;
+ if you want rating look elsewhere.
+ """
+ user = models.ForeignKey(User, verbose_name=_('user'), related_name="comment_flags")
+ comment = models.ForeignKey(Comment, verbose_name=_('comment'), related_name="flags")
+ flag = models.CharField(_('flag'), max_length=30, db_index=True)
+ flag_date = models.DateTimeField(_('date'), default=None)
+
+ # Constants for flag types
+ SUGGEST_REMOVAL = "removal suggestion"
+ MODERATOR_DELETION = "moderator deletion"
+ MODERATOR_APPROVAL = "moderator approval"
+
+ class Meta:
+ db_table = 'django_comment_flags'
+ unique_together = [('user', 'comment', 'flag')]
+ verbose_name = _('comment flag')
+ verbose_name_plural = _('comment flags')
+
+ def __unicode__(self):
+ return "%s flag of comment ID %s by %s" % \
+ (self.flag, self.comment_id, self.user.username)
+
+ def save(self, force_insert=False, force_update=False):
+ if self.flag_date is None:
+ self.flag_date = datetime.datetime.now()
+ super(CommentFlag, self).save(force_insert, force_update)