|
1 import datetime |
|
2 from django.contrib.auth.models import User |
|
3 from django.contrib.comments.managers import CommentManager |
|
4 from django.contrib.contenttypes import generic |
|
5 from django.contrib.contenttypes.models import ContentType |
|
6 from django.contrib.sites.models import Site |
|
7 from django.db import models |
|
8 from django.core import urlresolvers |
|
9 from django.utils.translation import ugettext_lazy as _ |
|
10 from django.conf import settings |
|
11 |
|
12 COMMENT_MAX_LENGTH = getattr(settings,'COMMENT_MAX_LENGTH',3000) |
|
13 |
|
14 class BaseCommentAbstractModel(models.Model): |
|
15 """ |
|
16 An abstract base class that any custom comment models probably should |
|
17 subclass. |
|
18 """ |
|
19 |
|
20 # Content-object field |
|
21 content_type = models.ForeignKey(ContentType, |
|
22 verbose_name=_('content type'), |
|
23 related_name="content_type_set_for_%(class)s") |
|
24 object_pk = models.TextField(_('object ID')) |
|
25 content_object = generic.GenericForeignKey(ct_field="content_type", fk_field="object_pk") |
|
26 |
|
27 # Metadata about the comment |
|
28 site = models.ForeignKey(Site) |
|
29 |
|
30 class Meta: |
|
31 abstract = True |
|
32 |
|
33 def get_content_object_url(self): |
|
34 """ |
|
35 Get a URL suitable for redirecting to the content object. |
|
36 """ |
|
37 return urlresolvers.reverse( |
|
38 "comments-url-redirect", |
|
39 args=(self.content_type_id, self.object_pk) |
|
40 ) |
|
41 |
|
42 class Comment(BaseCommentAbstractModel): |
|
43 """ |
|
44 A user comment about some object. |
|
45 """ |
|
46 |
|
47 # Who posted this comment? If ``user`` is set then it was an authenticated |
|
48 # user; otherwise at least user_name should have been set and the comment |
|
49 # was posted by a non-authenticated user. |
|
50 user = models.ForeignKey(User, verbose_name=_('user'), |
|
51 blank=True, null=True, related_name="%(class)s_comments") |
|
52 user_name = models.CharField(_("user's name"), max_length=50, blank=True) |
|
53 user_email = models.EmailField(_("user's email address"), blank=True) |
|
54 user_url = models.URLField(_("user's URL"), blank=True) |
|
55 |
|
56 comment = models.TextField(_('comment'), max_length=COMMENT_MAX_LENGTH) |
|
57 |
|
58 # Metadata about the comment |
|
59 submit_date = models.DateTimeField(_('date/time submitted'), default=None) |
|
60 ip_address = models.IPAddressField(_('IP address'), blank=True, null=True) |
|
61 is_public = models.BooleanField(_('is public'), default=True, |
|
62 help_text=_('Uncheck this box to make the comment effectively ' \ |
|
63 'disappear from the site.')) |
|
64 is_removed = models.BooleanField(_('is removed'), default=False, |
|
65 help_text=_('Check this box if the comment is inappropriate. ' \ |
|
66 'A "This comment has been removed" message will ' \ |
|
67 'be displayed instead.')) |
|
68 |
|
69 # Manager |
|
70 objects = CommentManager() |
|
71 |
|
72 class Meta: |
|
73 db_table = "django_comments" |
|
74 ordering = ('submit_date',) |
|
75 permissions = [("can_moderate", "Can moderate comments")] |
|
76 verbose_name = _('comment') |
|
77 verbose_name_plural = _('comments') |
|
78 |
|
79 def __unicode__(self): |
|
80 return "%s: %s..." % (self.name, self.comment[:50]) |
|
81 |
|
82 def save(self, *args, **kwargs): |
|
83 if self.submit_date is None: |
|
84 self.submit_date = datetime.datetime.now() |
|
85 super(Comment, self).save(*args, **kwargs) |
|
86 |
|
87 def _get_userinfo(self): |
|
88 """ |
|
89 Get a dictionary that pulls together information about the poster |
|
90 safely for both authenticated and non-authenticated comments. |
|
91 |
|
92 This dict will have ``name``, ``email``, and ``url`` fields. |
|
93 """ |
|
94 if not hasattr(self, "_userinfo"): |
|
95 self._userinfo = { |
|
96 "name" : self.user_name, |
|
97 "email" : self.user_email, |
|
98 "url" : self.user_url |
|
99 } |
|
100 if self.user_id: |
|
101 u = self.user |
|
102 if u.email: |
|
103 self._userinfo["email"] = u.email |
|
104 |
|
105 # If the user has a full name, use that for the user name. |
|
106 # However, a given user_name overrides the raw user.username, |
|
107 # so only use that if this comment has no associated name. |
|
108 if u.get_full_name(): |
|
109 self._userinfo["name"] = self.user.get_full_name() |
|
110 elif not self.user_name: |
|
111 self._userinfo["name"] = u.username |
|
112 return self._userinfo |
|
113 userinfo = property(_get_userinfo, doc=_get_userinfo.__doc__) |
|
114 |
|
115 def _get_name(self): |
|
116 return self.userinfo["name"] |
|
117 def _set_name(self, val): |
|
118 if self.user_id: |
|
119 raise AttributeError(_("This comment was posted by an authenticated "\ |
|
120 "user and thus the name is read-only.")) |
|
121 self.user_name = val |
|
122 name = property(_get_name, _set_name, doc="The name of the user who posted this comment") |
|
123 |
|
124 def _get_email(self): |
|
125 return self.userinfo["email"] |
|
126 def _set_email(self, val): |
|
127 if self.user_id: |
|
128 raise AttributeError(_("This comment was posted by an authenticated "\ |
|
129 "user and thus the email is read-only.")) |
|
130 self.user_email = val |
|
131 email = property(_get_email, _set_email, doc="The email of the user who posted this comment") |
|
132 |
|
133 def _get_url(self): |
|
134 return self.userinfo["url"] |
|
135 def _set_url(self, val): |
|
136 self.user_url = val |
|
137 url = property(_get_url, _set_url, doc="The URL given by the user who posted this comment") |
|
138 |
|
139 def get_absolute_url(self, anchor_pattern="#c%(id)s"): |
|
140 return self.get_content_object_url() + (anchor_pattern % self.__dict__) |
|
141 |
|
142 def get_as_text(self): |
|
143 """ |
|
144 Return this comment as plain text. Useful for emails. |
|
145 """ |
|
146 d = { |
|
147 'user': self.user or self.name, |
|
148 'date': self.submit_date, |
|
149 'comment': self.comment, |
|
150 'domain': self.site.domain, |
|
151 'url': self.get_absolute_url() |
|
152 } |
|
153 return _('Posted by %(user)s at %(date)s\n\n%(comment)s\n\nhttp://%(domain)s%(url)s') % d |
|
154 |
|
155 class CommentFlag(models.Model): |
|
156 """ |
|
157 Records a flag on a comment. This is intentionally flexible; right now, a |
|
158 flag could be: |
|
159 |
|
160 * A "removal suggestion" -- where a user suggests a comment for (potential) removal. |
|
161 |
|
162 * A "moderator deletion" -- used when a moderator deletes a comment. |
|
163 |
|
164 You can (ab)use this model to add other flags, if needed. However, by |
|
165 design users are only allowed to flag a comment with a given flag once; |
|
166 if you want rating look elsewhere. |
|
167 """ |
|
168 user = models.ForeignKey(User, verbose_name=_('user'), related_name="comment_flags") |
|
169 comment = models.ForeignKey(Comment, verbose_name=_('comment'), related_name="flags") |
|
170 flag = models.CharField(_('flag'), max_length=30, db_index=True) |
|
171 flag_date = models.DateTimeField(_('date'), default=None) |
|
172 |
|
173 # Constants for flag types |
|
174 SUGGEST_REMOVAL = "removal suggestion" |
|
175 MODERATOR_DELETION = "moderator deletion" |
|
176 MODERATOR_APPROVAL = "moderator approval" |
|
177 |
|
178 class Meta: |
|
179 db_table = 'django_comment_flags' |
|
180 unique_together = [('user', 'comment', 'flag')] |
|
181 verbose_name = _('comment flag') |
|
182 verbose_name_plural = _('comment flags') |
|
183 |
|
184 def __unicode__(self): |
|
185 return "%s flag of comment ID %s by %s" % \ |
|
186 (self.flag, self.comment_id, self.user.username) |
|
187 |
|
188 def save(self, *args, **kwargs): |
|
189 if self.flag_date is None: |
|
190 self.flag_date = datetime.datetime.now() |
|
191 super(CommentFlag, self).save(*args, **kwargs) |