1 from django import template |
1 from django import template |
2 from django.conf import settings |
2 from django.conf import settings |
3 from django.shortcuts import get_object_or_404, render_to_response |
3 from django.shortcuts import get_object_or_404, render_to_response |
4 from django.contrib.auth.decorators import login_required, permission_required |
4 from django.contrib.auth.decorators import login_required, permission_required |
5 from utils import next_redirect, confirmation_view |
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 |
6 from django.contrib import comments |
9 from django.contrib.comments import signals |
7 from django.contrib.comments import signals |
|
8 from django.views.decorators.csrf import csrf_protect |
10 |
9 |
11 #@login_required |
10 @csrf_protect |
|
11 @login_required |
12 def flag(request, comment_id, next=None): |
12 def flag(request, comment_id, next=None): |
13 """ |
13 """ |
14 Flags a comment. Confirmation on GET, action on POST. |
14 Flags a comment. Confirmation on GET, action on POST. |
15 |
15 |
16 Templates: `comments/flag.html`, |
16 Templates: `comments/flag.html`, |
20 """ |
20 """ |
21 comment = get_object_or_404(comments.get_model(), pk=comment_id, site__pk=settings.SITE_ID) |
21 comment = get_object_or_404(comments.get_model(), pk=comment_id, site__pk=settings.SITE_ID) |
22 |
22 |
23 # Flag on POST |
23 # Flag on POST |
24 if request.method == 'POST': |
24 if request.method == 'POST': |
25 flag, created = comments.models.CommentFlag.objects.get_or_create( |
25 perform_flag(request, comment) |
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) |
26 return next_redirect(request.POST.copy(), next, flag_done, c=comment.pk) |
38 |
27 |
39 # Render a form on GET |
28 # Render a form on GET |
40 else: |
29 else: |
41 return render_to_response('comments/flag.html', |
30 return render_to_response('comments/flag.html', |
42 {'comment': comment, "next": next}, |
31 {'comment': comment, "next": next}, |
43 template.RequestContext(request) |
32 template.RequestContext(request) |
44 ) |
33 ) |
45 flag = login_required(flag) |
|
46 |
34 |
47 #@permission_required("comments.delete_comment") |
35 @csrf_protect |
|
36 @permission_required("comments.can_moderate") |
48 def delete(request, comment_id, next=None): |
37 def delete(request, comment_id, next=None): |
49 """ |
38 """ |
50 Deletes a comment. Confirmation on GET, action on POST. Requires the "can |
39 Deletes a comment. Confirmation on GET, action on POST. Requires the "can |
51 moderate comments" permission. |
40 moderate comments" permission. |
52 |
41 |
58 comment = get_object_or_404(comments.get_model(), pk=comment_id, site__pk=settings.SITE_ID) |
47 comment = get_object_or_404(comments.get_model(), pk=comment_id, site__pk=settings.SITE_ID) |
59 |
48 |
60 # Delete on POST |
49 # Delete on POST |
61 if request.method == 'POST': |
50 if request.method == 'POST': |
62 # Flag the comment as deleted instead of actually deleting it. |
51 # Flag the comment as deleted instead of actually deleting it. |
63 flag, created = comments.models.CommentFlag.objects.get_or_create( |
52 perform_delete(request, comment) |
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) |
53 return next_redirect(request.POST.copy(), next, delete_done, c=comment.pk) |
78 |
54 |
79 # Render a form on GET |
55 # Render a form on GET |
80 else: |
56 else: |
81 return render_to_response('comments/delete.html', |
57 return render_to_response('comments/delete.html', |
82 {'comment': comment, "next": next}, |
58 {'comment': comment, "next": next}, |
83 template.RequestContext(request) |
59 template.RequestContext(request) |
84 ) |
60 ) |
85 delete = permission_required("comments.can_moderate")(delete) |
|
86 |
61 |
87 #@permission_required("comments.can_moderate") |
62 @csrf_protect |
|
63 @permission_required("comments.can_moderate") |
88 def approve(request, comment_id, next=None): |
64 def approve(request, comment_id, next=None): |
89 """ |
65 """ |
90 Approve a comment (that is, mark it as public and non-removed). Confirmation |
66 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. |
67 on GET, action on POST. Requires the "can moderate comments" permission. |
92 |
68 |
98 comment = get_object_or_404(comments.get_model(), pk=comment_id, site__pk=settings.SITE_ID) |
74 comment = get_object_or_404(comments.get_model(), pk=comment_id, site__pk=settings.SITE_ID) |
99 |
75 |
100 # Delete on POST |
76 # Delete on POST |
101 if request.method == 'POST': |
77 if request.method == 'POST': |
102 # Flag the comment as approved. |
78 # Flag the comment as approved. |
103 flag, created = comments.models.CommentFlag.objects.get_or_create( |
79 perform_approve(request, comment) |
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) |
80 return next_redirect(request.POST.copy(), next, approve_done, c=comment.pk) |
121 |
81 |
122 # Render a form on GET |
82 # Render a form on GET |
123 else: |
83 else: |
124 return render_to_response('comments/approve.html', |
84 return render_to_response('comments/approve.html', |
125 {'comment': comment, "next": next}, |
85 {'comment': comment, "next": next}, |
126 template.RequestContext(request) |
86 template.RequestContext(request) |
127 ) |
87 ) |
128 |
88 |
129 approve = permission_required("comments.can_moderate")(approve) |
89 # The following functions actually perform the various flag/aprove/delete |
|
90 # actions. They've been broken out into seperate functions to that they |
|
91 # may be called from admin actions. |
|
92 |
|
93 def perform_flag(request, comment): |
|
94 """ |
|
95 Actually perform the flagging of a comment from a request. |
|
96 """ |
|
97 flag, created = comments.models.CommentFlag.objects.get_or_create( |
|
98 comment = comment, |
|
99 user = request.user, |
|
100 flag = comments.models.CommentFlag.SUGGEST_REMOVAL |
|
101 ) |
|
102 signals.comment_was_flagged.send( |
|
103 sender = comment.__class__, |
|
104 comment = comment, |
|
105 flag = flag, |
|
106 created = created, |
|
107 request = request, |
|
108 ) |
|
109 |
|
110 def perform_delete(request, comment): |
|
111 flag, created = comments.models.CommentFlag.objects.get_or_create( |
|
112 comment = comment, |
|
113 user = request.user, |
|
114 flag = comments.models.CommentFlag.MODERATOR_DELETION |
|
115 ) |
|
116 comment.is_removed = True |
|
117 comment.save() |
|
118 signals.comment_was_flagged.send( |
|
119 sender = comment.__class__, |
|
120 comment = comment, |
|
121 flag = flag, |
|
122 created = created, |
|
123 request = request, |
|
124 ) |
130 |
125 |
131 |
126 |
132 #@permission_required("comments.can_moderate") |
127 def perform_approve(request, comment): |
133 def moderation_queue(request): |
128 flag, created = comments.models.CommentFlag.objects.get_or_create( |
134 """ |
129 comment = comment, |
135 Displays a list of unapproved comments to be approved. |
130 user = request.user, |
|
131 flag = comments.models.CommentFlag.MODERATOR_APPROVAL, |
|
132 ) |
136 |
133 |
137 Templates: `comments/moderation_queue.html` |
134 comment.is_removed = False |
138 Context: |
135 comment.is_public = True |
139 comments |
136 comment.save() |
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 |
137 |
162 """ |
138 signals.comment_was_flagged.send( |
163 qs = comments.get_model().objects.filter(is_public=False, is_removed=False) |
139 sender = comment.__class__, |
164 paginator = Paginator(qs, 100) |
140 comment = comment, |
|
141 flag = flag, |
|
142 created = created, |
|
143 request = request, |
|
144 ) |
165 |
145 |
166 try: |
146 # Confirmation views. |
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 |
147 |
193 flag_done = confirmation_view( |
148 flag_done = confirmation_view( |
194 template = "comments/flagged.html", |
149 template = "comments/flagged.html", |
195 doc = 'Displays a "comment was flagged" success page.' |
150 doc = 'Displays a "comment was flagged" success page.' |
196 ) |
151 ) |