← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/python-django/jaunty

« back to all changes in this revision

Viewing changes to django/contrib/comments/views/moderation.py

  • Committer: Bazaar Package Importer
  • Author(s): Scott James Remnant, Eddy Mulyono
  • Date: 2008-09-16 12:18:47 UTC
  • mfrom: (1.1.5 upstream) (4.1.1 lenny)
  • Revision ID: james.westby@ubuntu.com-20080916121847-mg225rg5mnsdqzr0
Tags: 1.0-1ubuntu1
https://launchpad.net/bugs/264191
* Merge from Debian (LP: #264191), remaining changes:
  - Run test suite on build.

[Eddy Mulyono]
* Update patch to workaround network test case failures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
)