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 )