app/django/contrib/comments/views/moderation.py

   1 from django import template
   2 from django.conf import settings
   3 from django.shortcuts import get_object_or_404, render_to_response
   4 from django.contrib.auth.decorators import login_required, permission_required
   5 from utils import next_redirect, confirmation_view
   6 from django.core.paginator import Paginator, InvalidPage
   7 from django.http import Http404
   8 from django.contrib import comments
   9 from django.contrib.comments import signals
  10
  11 #@login_required
  12 def flag(request, comment_id, next=None):
  13     """
  14     Flags a comment. Confirmation on GET, action on POST.
  15
  16     Templates: `comments/flag.html`,
  17     Context:
  18         comment
  19             the flagged `comments.comment` object
  20     """
  21     comment = get_object_or_404(comments.get_model(), pk=comment_id, site__pk=settings.SITE_ID)
  22
  23     # Flag on POST
  24     if request.method == 'POST':
  25         flag, created = comments.models.CommentFlag.objects.get_or_create(
  26             comment = comment,
  27             user    = request.user,
  28             flag    = comments.models.CommentFlag.SUGGEST_REMOVAL
  29         )
  30         signals.comment_was_flagged.send(
  31             sender  = comment.__class__,
  32             comment = comment,
  33             flag    = flag,
  34             created = created,
  35             request = request,
  36         )
  37         return next_redirect(request.POST.copy(), next, flag_done, c=comment.pk)
  38
  39     # Render a form on GET
  40     else:
  41         return render_to_response('comments/flag.html',
  42             {'comment': comment, "next": next},
  43             template.RequestContext(request)
  44         )
  45 flag = login_required(flag)
  46
  47 #@permission_required("comments.delete_comment")
  48 def delete(request, comment_id, next=None):
  49     """
  50     Deletes a comment. Confirmation on GET, action on POST. Requires the "can
  51     moderate comments" permission.
  52
  53     Templates: `comments/delete.html`,
  54     Context:
  55         comment
  56             the flagged `comments.comment` object
  57     """
  58     comment = get_object_or_404(comments.get_model(), pk=comment_id, site__pk=settings.SITE_ID)
  59
  60     # Delete on POST
  61     if request.method == 'POST':
  62         # Flag the comment as deleted instead of actually deleting it.
  63         flag, created = comments.models.CommentFlag.objects.get_or_create(
  64             comment = comment,
  65             user    = request.user,
  66             flag    = comments.models.CommentFlag.MODERATOR_DELETION
  67         )
  68         comment.is_removed = True
  69         comment.save()
  70         signals.comment_was_flagged.send(
  71             sender  = comment.__class__,
  72             comment = comment,
  73             flag    = flag,
  74             created = created,
  75             request = request,
  76         )
  77         return next_redirect(request.POST.copy(), next, delete_done, c=comment.pk)
  78
  79     # Render a form on GET
  80     else:
  81         return render_to_response('comments/delete.html',
  82             {'comment': comment, "next": next},
  83             template.RequestContext(request)
  84         )
  85 delete = permission_required("comments.can_moderate")(delete)
  86
  87 #@permission_required("comments.can_moderate")
  88 def approve(request, comment_id, next=None):
  89     """
  90     Approve a comment (that is, mark it as public and non-removed). Confirmation
  91     on GET, action on POST. Requires the "can moderate comments" permission.
  92
  93     Templates: `comments/approve.html`,
  94     Context:
  95         comment
  96             the `comments.comment` object for approval
  97     """
  98     comment = get_object_or_404(comments.get_model(), pk=comment_id, site__pk=settings.SITE_ID)
  99
 100     # Delete on POST
 101     if request.method == 'POST':
 102         # Flag the comment as approved.
 103         flag, created = comments.models.CommentFlag.objects.get_or_create(
 104             comment = comment,
 105             user    = request.user,
 106             flag    = comments.models.CommentFlag.MODERATOR_APPROVAL,
 107         )
 108
 109         comment.is_removed = False
 110         comment.is_public = True
 111         comment.save()
 112
 113         signals.comment_was_flagged.send(
 114             sender  = comment.__class__,
 115             comment = comment,
 116             flag    = flag,
 117             created = created,
 118             request = request,
 119         )
 120         return next_redirect(request.POST.copy(), next, approve_done, c=comment.pk)
 121
 122     # Render a form on GET
 123     else:
 124         return render_to_response('comments/approve.html',
 125             {'comment': comment, "next": next},
 126             template.RequestContext(request)
 127         )
 128
 129 approve = permission_required("comments.can_moderate")(approve)
 130
 131
 132 #@permission_required("comments.can_moderate")
 133 def moderation_queue(request):
 134     """
 135     Displays a list of unapproved comments to be approved.
 136
 137     Templates: `comments/moderation_queue.html`
 138     Context:
 139         comments
 140             Comments to be approved (paginated).
 141         empty
 142             Is the comment list empty?
 143         is_paginated
 144             Is there more than one page?
 145         results_per_page
 146             Number of comments per page
 147         has_next
 148             Is there a next page?
 149         has_previous
 150             Is there a previous page?
 151         page
 152             The current page number
 153         next
 154             The next page number
 155         pages
 156             Number of pages
 157         hits
 158             Total number of comments
 159         page_range
 160             Range of page numbers
 161
 162     """
 163     qs = comments.get_model().objects.filter(is_public=False, is_removed=False)
 164     paginator = Paginator(qs, 100)
 165
 166     try:
 167         page = int(request.GET.get("page", 1))
 168     except ValueError:
 169         raise Http404
 170
 171     try:
 172         comments_per_page = paginator.page(page)
 173     except InvalidPage:
 174         raise Http404
 175
 176     return render_to_response("comments/moderation_queue.html", {
 177         'comments' : comments_per_page.object_list,
 178         'empty' : page == 1 and paginator.count == 0,
 179         'is_paginated': paginator.num_pages > 1,
 180         'results_per_page': 100,
 181         'has_next': comments_per_page.has_next(),
 182         'has_previous': comments_per_page.has_previous(),
 183         'page': page,
 184         'next': page + 1,
 185         'previous': page - 1,
 186         'pages': paginator.num_pages,
 187         'hits' : paginator.count,
 188         'page_range' : paginator.page_range
 189     }, context_instance=template.RequestContext(request))
 190
 191 moderation_queue = permission_required("comments.can_moderate")(moderation_queue)
 192
 193 flag_done = confirmation_view(
 194     template = "comments/flagged.html",
 195     doc = 'Displays a "comment was flagged" success page.'
 196 )
 197 delete_done = confirmation_view(
 198     template = "comments/deleted.html",
 199     doc = 'Displays a "comment was deleted" success page.'
 200 )
 201 approve_done = confirmation_view(
 202     template = "comments/approved.html",
 203     doc = 'Displays a "comment was approved" success page.'
 204 )