You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
185 lines
7.2 KiB
185 lines
7.2 KiB
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, |
|
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, 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")] |
|
|
|
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, |
|
'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, related_name="comment_flags") |
|
comment = models.ForeignKey(Comment, related_name="flags") |
|
flag = models.CharField(max_length=30, db_index=True) |
|
flag_date = models.DateTimeField(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')] |
|
|
|
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)
|
|
|