Source Code for Module django.contrib.comments.views.comments

  1  from django.core import validators 
  2  from django import oldforms 
  3  from django.core.mail import mail_admins, mail_managers 
  4  from django.http import Http404 
  5  from django.core.exceptions import ObjectDoesNotExist 
  6  from django.shortcuts import render_to_response 
  7  from django.template import RequestContext 
  8  from django.contrib.comments.models import Comment, FreeComment, RATINGS_REQUIRED, RATINGS_OPTIONAL, IS_PUBLIC 
  9  from django.contrib.contenttypes.models import ContentType 
 10  from django.contrib.auth.forms import AuthenticationForm 
 11  from django.http import HttpResponseRedirect 
 12  from django.utils.text import normalize_newlines 
 13  from django.conf import settings 
 14  from django.utils.translation import ungettext, ugettext as _ 
 15  from django.utils.encoding import smart_unicode 
 16  import base64, datetime 
 17   
 18  COMMENTS_PER_PAGE = 20 
 19   
 20 -class PublicCommentManipulator(AuthenticationForm): 
 21      "Manipulator that handles public registered comments" 
 22 -    def __init__(self, user, ratings_required, ratings_range, num_rating_choices): 
 23          AuthenticationForm.__init__(self) 
 24          self.ratings_range, self.num_rating_choices = ratings_range, num_rating_choices 
 25          choices = [(c, c) for c in ratings_range] 
 26          def get_validator_list(rating_num): 
 27              if rating_num <= num_rating_choices: 
 28                  return [validators.RequiredIfOtherFieldsGiven(['rating%d' % i for i in range(1, 9) if i != rating_num], _("This rating is required because you've entered at least one other rating."))] 
 29              else: 
 30                  return [] 
 31          self.fields.extend([ 
 32              oldforms.LargeTextField(field_name="comment", max_length=3000, is_required=True, 
 33                  validator_list=[self.hasNoProfanities]), 
 34              oldforms.RadioSelectField(field_name="rating1", choices=choices, 
 35                  is_required=ratings_required and num_rating_choices > 0, 
 36                  validator_list=get_validator_list(1), 
 37              ), 
 38              oldforms.RadioSelectField(field_name="rating2", choices=choices, 
 39                  is_required=ratings_required and num_rating_choices > 1, 
 40                  validator_list=get_validator_list(2), 
 41              ), 
 42              oldforms.RadioSelectField(field_name="rating3", choices=choices, 
 43                  is_required=ratings_required and num_rating_choices > 2, 
 44                  validator_list=get_validator_list(3), 
 45              ), 
 46              oldforms.RadioSelectField(field_name="rating4", choices=choices, 
 47                  is_required=ratings_required and num_rating_choices > 3, 
 48                  validator_list=get_validator_list(4), 
 49              ), 
 50              oldforms.RadioSelectField(field_name="rating5", choices=choices, 
 51                  is_required=ratings_required and num_rating_choices > 4, 
 52                  validator_list=get_validator_list(5), 
 53              ), 
 54              oldforms.RadioSelectField(field_name="rating6", choices=choices, 
 55                  is_required=ratings_required and num_rating_choices > 5, 
 56                  validator_list=get_validator_list(6), 
 57              ), 
 58              oldforms.RadioSelectField(field_name="rating7", choices=choices, 
 59                  is_required=ratings_required and num_rating_choices > 6, 
 60                  validator_list=get_validator_list(7), 
 61              ), 
 62              oldforms.RadioSelectField(field_name="rating8", choices=choices, 
 63                  is_required=ratings_required and num_rating_choices > 7, 
 64                  validator_list=get_validator_list(8), 
 65              ), 
 66          ]) 
 67          if user.is_authenticated(): 
 68              self["username"].is_required = False 
 69              self["username"].validator_list = [] 
 70              self["password"].is_required = False 
 71              self["password"].validator_list = [] 
 72              self.user_cache = user 
 73   
 74 -    def hasNoProfanities(self, field_data, all_data): 
 75          if settings.COMMENTS_ALLOW_PROFANITIES: 
 76              return 
 77          return validators.hasNoProfanities(field_data, all_data) 
 78   
 79 -    def get_comment(self, new_data): 
 80          "Helper function" 
 81          return Comment(None, self.get_user_id(), new_data["content_type_id"], 
 82              new_data["object_id"], new_data.get("headline", "").strip(), 
 83              new_data["comment"].strip(), new_data.get("rating1", None), 
 84              new_data.get("rating2", None), new_data.get("rating3", None), 
 85              new_data.get("rating4", None), new_data.get("rating5", None), 
 86              new_data.get("rating6", None), new_data.get("rating7", None), 
 87              new_data.get("rating8", None), new_data.get("rating1", None) is not None, 
 88              datetime.datetime.now(), new_data["is_public"], new_data["ip_address"], False, settings.SITE_ID) 
 89   
 90 -    def save(self, new_data): 
 91          today = datetime.date.today() 
 92          c = self.get_comment(new_data) 
 93          for old in Comment.objects.filter(content_type__id__exact=new_data["content_type_id"], 
 94              object_id__exact=new_data["object_id"], user__id__exact=self.get_user_id()): 
 95              # Check that this comment isn't duplicate. (Sometimes people post 
 96              # comments twice by mistake.) If it is, fail silently by pretending 
 97              # the comment was posted successfully. 
 98              if old.submit_date.date() == today and old.comment == c.comment \ 
 99                  and old.rating1 == c.rating1 and old.rating2 == c.rating2 \ 
100                  and old.rating3 == c.rating3 and old.rating4 == c.rating4 \ 
101                  and old.rating5 == c.rating5 and old.rating6 == c.rating6 \ 
102                  and old.rating7 == c.rating7 and old.rating8 == c.rating8: 
103                  return old 
104              # If the user is leaving a rating, invalidate all old ratings. 
105              if c.rating1 is not None: 
106                  old.valid_rating = False 
107                  old.save() 
108          c.save() 
109          # If the commentor has posted fewer than COMMENTS_FIRST_FEW comments, 
110          # send the comment to the managers. 
111          if self.user_cache.comment_set.count() <= settings.COMMENTS_FIRST_FEW: 
112              message = ungettext('This comment was posted by a user who has posted fewer than %(count)s comment:\n\n%(text)s', 
113                  'This comment was posted by a user who has posted fewer than %(count)s comments:\n\n%(text)s', settings.COMMENTS_FIRST_FEW) % \ 
114                  {'count': settings.COMMENTS_FIRST_FEW, 'text': c.get_as_text()} 
115              mail_managers("Comment posted by rookie user", message) 
116          if settings.COMMENTS_SKETCHY_USERS_GROUP and settings.COMMENTS_SKETCHY_USERS_GROUP in [g.id for g in self.user_cache.groups.all()]: 
117              message = _('This comment was posted by a sketchy user:\n\n%(text)s') % {'text': c.get_as_text()} 
118              mail_managers("Comment posted by sketchy user (%s)" % self.user_cache.username, c.get_as_text()) 
119          return c 
120   
121 -class PublicFreeCommentManipulator(oldforms.Manipulator): 
122      "Manipulator that handles public free (unregistered) comments" 
123 -    def __init__(self): 
124          self.fields = ( 
125              oldforms.TextField(field_name="person_name", max_length=50, is_required=True, 
126                  validator_list=[self.hasNoProfanities]), 
127              oldforms.LargeTextField(field_name="comment", max_length=3000, is_required=True, 
128                  validator_list=[self.hasNoProfanities]), 
129          ) 
130   
131 -    def hasNoProfanities(self, field_data, all_data): 
132          if settings.COMMENTS_ALLOW_PROFANITIES: 
133              return 
134          return validators.hasNoProfanities(field_data, all_data) 
135   
136 -    def get_comment(self, new_data): 
137          "Helper function" 
138          return FreeComment(None, new_data["content_type_id"], 
139              new_data["object_id"], new_data["comment"].strip(), 
140              new_data["person_name"].strip(), datetime.datetime.now(), new_data["is_public"], 
141              new_data["ip_address"], False, settings.SITE_ID) 
142   
143 -    def save(self, new_data): 
144          today = datetime.date.today() 
145          c = self.get_comment(new_data) 
146          # Check that this comment isn't duplicate. (Sometimes people post 
147          # comments twice by mistake.) If it is, fail silently by pretending 
148          # the comment was posted successfully. 
149          for old_comment in FreeComment.objects.filter(content_type__id__exact=new_data["content_type_id"], 
150              object_id__exact=new_data["object_id"], person_name__exact=new_data["person_name"], 
151              submit_date__year=today.year, submit_date__month=today.month, 
152              submit_date__day=today.day): 
153              if old_comment.comment == c.comment: 
154                  return old_comment 
155          c.save() 
156          return c 
157   
158 -def post_comment(request, extra_context=None, context_processors=None): 
159      """ 
160      Post a comment 
161   
162      Redirects to the `comments.comments.comment_was_posted` view upon success. 
163   
164      Templates: `comment_preview` 
165      Context: 
166          comment 
167              the comment being posted 
168          comment_form 
169              the comment form 
170          options 
171              comment options 
172          target 
173              comment target 
174          hash 
175              security hash (must be included in a posted form to succesfully 
176              post a comment). 
177          rating_options 
178              comment ratings options 
179          ratings_optional 
180              are ratings optional? 
181          ratings_required 
182              are ratings required? 
183          rating_range 
184              range of ratings 
185          rating_choices 
186              choice of ratings 
187      """ 
188      if extra_context is None: extra_context = {} 
189      if not request.POST: 
190          raise Http404, _("Only POSTs are allowed") 
191      try: 
192          options, target, security_hash = request.POST['options'], request.POST['target'], request.POST['gonzo'] 
193      except KeyError: 
194          raise Http404, _("One or more of the required fields wasn't submitted") 
195      photo_options = request.POST.get('photo_options', '') 
196      rating_options = normalize_newlines(request.POST.get('rating_options', '')) 
197      if Comment.objects.get_security_hash(options, photo_options, rating_options, target) != security_hash: 
198          raise Http404, _("Somebody tampered with the comment form (security violation)") 
199      # Now we can be assured the data is valid. 
200      if rating_options: 
201          rating_range, rating_choices = Comment.objects.get_rating_options(base64.decodestring(rating_options)) 
202      else: 
203          rating_range, rating_choices = [], [] 
204      content_type_id, object_id = target.split(':') # target is something like '52:5157' 
205      try: 
206          obj = ContentType.objects.get(pk=content_type_id).get_object_for_this_type(pk=object_id) 
207      except ObjectDoesNotExist: 
208          raise Http404, _("The comment form had an invalid 'target' parameter -- the object ID was invalid") 
209      option_list = options.split(',') # options is something like 'pa,ra' 
210      new_data = request.POST.copy() 
211      new_data['content_type_id'] = content_type_id 
212      new_data['object_id'] = object_id 
213      new_data['ip_address'] = request.META.get('REMOTE_ADDR') 
214      new_data['is_public'] = IS_PUBLIC in option_list 
215      manipulator = PublicCommentManipulator(request.user, 
216          ratings_required=RATINGS_REQUIRED in option_list, 
217          ratings_range=rating_range, 
218          num_rating_choices=len(rating_choices)) 
219      errors = manipulator.get_validation_errors(new_data) 
220      # If user gave correct username/password and wasn't already logged in, log them in 
221      # so they don't have to enter a username/password again. 
222      if manipulator.get_user() and not manipulator.get_user().is_authenticated() and 'password' in new_data and manipulator.get_user().check_password(new_data['password']): 
223          from django.contrib.auth import login 
224          login(request, manipulator.get_user()) 
225      if errors or 'preview' in request.POST: 
226          class CommentFormWrapper(oldforms.FormWrapper): 
227              def __init__(self, manipulator, new_data, errors, rating_choices): 
228                  oldforms.FormWrapper.__init__(self, manipulator, new_data, errors) 
229                  self.rating_choices = rating_choices 
230              def ratings(self): 
231                  field_list = [self['rating%d' % (i+1)] for i in range(len(rating_choices))] 
232                  for i, f in enumerate(field_list): 
233                      f.choice = rating_choices[i] 
234                  return field_list 
235          comment = errors and '' or manipulator.get_comment(new_data) 
236          comment_form = CommentFormWrapper(manipulator, new_data, errors, rating_choices) 
237          return render_to_response('comments/preview.html', { 
238              'comment': comment, 
239              'comment_form': comment_form, 
240              'options': options, 
241              'target': target, 
242              'hash': security_hash, 
243              'rating_options': rating_options, 
244              'ratings_optional': RATINGS_OPTIONAL in option_list, 
245              'ratings_required': RATINGS_REQUIRED in option_list, 
246              'rating_range': rating_range, 
247              'rating_choices': rating_choices, 
248          }, context_instance=RequestContext(request, extra_context, context_processors)) 
249      elif 'post' in request.POST: 
250          # If the IP is banned, mail the admins, do NOT save the comment, and 
251          # serve up the "Thanks for posting" page as if the comment WAS posted. 
252          if request.META['REMOTE_ADDR'] in settings.BANNED_IPS: 
253              mail_admins("Banned IP attempted to post comment", smart_unicode(request.POST) + "\n\n" + str(request.META)) 
254          else: 
255              manipulator.do_html2python(new_data) 
256              comment = manipulator.save(new_data) 
257          return HttpResponseRedirect("../posted/?c=%s:%s" % (content_type_id, object_id)) 
258      else: 
259          raise Http404, _("The comment form didn't provide either 'preview' or 'post'") 
260   
261 -def post_free_comment(request, extra_context=None, context_processors=None): 
262      """ 
263      Post a free comment (not requiring a log in) 
264   
265      Redirects to `comments.comments.comment_was_posted` view on success. 
266   
267      Templates: `comment_free_preview` 
268      Context: 
269          comment 
270              comment being posted 
271          comment_form 
272              comment form object 
273          options 
274              comment options 
275          target 
276              comment target 
277          hash 
278              security hash (must be included in a posted form to succesfully 
279              post a comment). 
280      """ 
281      if extra_context is None: extra_context = {} 
282      if not request.POST: 
283          raise Http404, _("Only POSTs are allowed") 
284      try: 
285          options, target, security_hash = request.POST['options'], request.POST['target'], request.POST['gonzo'] 
286      except KeyError: 
287          raise Http404, _("One or more of the required fields wasn't submitted") 
288      if Comment.objects.get_security_hash(options, '', '', target) != security_hash: 
289          raise Http404, _("Somebody tampered with the comment form (security violation)") 
290      content_type_id, object_id = target.split(':') # target is something like '52:5157' 
291      content_type = ContentType.objects.get(pk=content_type_id) 
292      try: 
293          obj = content_type.get_object_for_this_type(pk=object_id) 
294      except ObjectDoesNotExist: 
295          raise Http404, _("The comment form had an invalid 'target' parameter -- the object ID was invalid") 
296      option_list = options.split(',') 
297      new_data = request.POST.copy() 
298      new_data['content_type_id'] = content_type_id 
299      new_data['object_id'] = object_id 
300      new_data['ip_address'] = request.META['REMOTE_ADDR'] 
301      new_data['is_public'] = IS_PUBLIC in option_list 
302      manipulator = PublicFreeCommentManipulator() 
303      errors = manipulator.get_validation_errors(new_data) 
304      if errors or 'preview' in request.POST: 
305          comment = errors and '' or manipulator.get_comment(new_data) 
306          return render_to_response('comments/free_preview.html', { 
307              'comment': comment, 
308              'comment_form': oldforms.FormWrapper(manipulator, new_data, errors), 
309              'options': options, 
310              'target': target, 
311              'hash': security_hash, 
312          }, context_instance=RequestContext(request, extra_context, context_processors)) 
313      elif 'post' in request.POST: 
314          # If the IP is banned, mail the admins, do NOT save the comment, and 
315          # serve up the "Thanks for posting" page as if the comment WAS posted. 
316          if request.META['REMOTE_ADDR'] in settings.BANNED_IPS: 
317              from django.core.mail import mail_admins 
318              mail_admins("Practical joker", smart_unicode(request.POST) + "\n\n" + str(request.META)) 
319          else: 
320              manipulator.do_html2python(new_data) 
321              comment = manipulator.save(new_data) 
322          return HttpResponseRedirect("../posted/?c=%s:%s" % (content_type_id, object_id)) 
323      else: 
324          raise Http404, _("The comment form didn't provide either 'preview' or 'post'") 
325   
326 -def comment_was_posted(request, extra_context=None, context_processors=None): 
327      """ 
328      Display "comment was posted" success page 
329   
330      Templates: `comment_posted` 
331      Context: 
332          object 
333              The object the comment was posted on 
334      """ 
335      if extra_context is None: extra_context = {} 
336      obj = None 
337      if 'c' in request.GET: 
338          content_type_id, object_id = request.GET['c'].split(':') 
339          try: 
340              content_type = ContentType.objects.get(pk=content_type_id) 
341              obj = content_type.get_object_for_this_type(pk=object_id) 
342          except ObjectDoesNotExist: 
343              pass 
344      return render_to_response('comments/posted.html', {'object': obj}, 
345          context_instance=RequestContext(request, extra_context, context_processors)) 
346