mediagoblin/moderation/views.py

   1 # GNU MediaGoblin -- federated, autonomous media hosting
   2 # Copyright (C) 2011, 2012 MediaGoblin contributors.  See AUTHORS.
   3 #
   4 # This program is free software: you can redistribute it and/or modify
   5 # it under the terms of the GNU Affero General Public License as published by
   6 # the Free Software Foundation, either version 3 of the License, or
   7 # (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU Affero General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Affero General Public License
  15 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17
  18 from mediagoblin.db.models import (MediaEntry, User,ReportBase, Privilege,
  19                                    UserBan)
  20 from mediagoblin.decorators import (require_admin_or_moderator_login,
  21                                     active_user_from_url, user_has_privilege,
  22                                     allow_reporting)
  23 from mediagoblin.tools.response import render_to_response, redirect
  24 from mediagoblin.moderation import forms as moderation_forms
  25 from mediagoblin.moderation.tools import (take_punitive_actions, \
  26     take_away_privileges, give_privileges, ban_user, unban_user, \
  27     parse_report_panel_settings)
  28 from math import ceil
  29
  30 @require_admin_or_moderator_login
  31 def moderation_media_processing_panel(request):
  32     '''
  33     Show the global media processing panel for this instance
  34     '''
  35     processing_entries = MediaEntry.query.filter_by(state = u'processing').\
  36         order_by(MediaEntry.created.desc())
  37
  38     # Get media entries which have failed to process
  39     failed_entries = MediaEntry.query.filter_by(state = u'failed').\
  40         order_by(MediaEntry.created.desc())
  41
  42     processed_entries = MediaEntry.query.filter_by(state = u'processed').\
  43         order_by(MediaEntry.created.desc()).limit(10)
  44
  45     # Render to response
  46     return render_to_response(
  47         request,
  48         'mediagoblin/moderation/media_panel.html',
  49         {'processing_entries': processing_entries,
  50          'failed_entries': failed_entries,
  51          'processed_entries': processed_entries})
  52
  53 @require_admin_or_moderator_login
  54 def moderation_users_panel(request):
  55     '''
  56     Show the global panel for monitoring users in this instance
  57     '''
  58     current_page = 1
  59     if len(request.args) > 0:
  60         form = moderation_forms.UserPanelSortingForm(request.args)
  61         if form.validate():
  62             current_page = form.p.data or 1
  63
  64     all_user_list = User.query
  65     user_list = all_user_list.order_by(
  66         User.created.desc()).offset(
  67             (current_page-1)*10).limit(10)
  68     last_page = int(ceil(all_user_list.count()/10.))
  69
  70     return render_to_response(
  71         request,
  72         'mediagoblin/moderation/user_panel.html',
  73         {'user_list': user_list,
  74          'current_page':current_page,
  75          'last_page':last_page})
  76
  77 @require_admin_or_moderator_login
  78 def moderation_users_detail(request):
  79     '''
  80     Shows details about a particular user.
  81     '''
  82     user = User.query.filter_by(username=request.matchdict['user']).first()
  83     active_reports = user.reports_filed_on.filter(
  84         ReportBase.resolved==None).limit(5)
  85     closed_reports = user.reports_filed_on.filter(
  86         ReportBase.resolved!=None).all()
  87     privileges = Privilege.query
  88     user_banned = UserBan.query.get(user.id)
  89     ban_form = moderation_forms.BanForm()
  90
  91     return render_to_response(
  92         request,
  93         'mediagoblin/moderation/user.html',
  94         {'user':user,
  95          'privileges': privileges,
  96          'reports':active_reports,
  97          'user_banned':user_banned,
  98          'ban_form':ban_form})
  99
 100 @require_admin_or_moderator_login
 101 @allow_reporting
 102 def moderation_reports_panel(request):
 103     '''
 104     Show the global panel for monitoring reports filed against comments or
 105         media entries for this instance.
 106     '''
 107     filters = []
 108     active_settings, closed_settings = {'current_page':1}, {'current_page':1}
 109
 110     if len(request.args) > 0:
 111         form = moderation_forms.ReportPanelSortingForm(request.args)
 112         if form.validate():
 113             filters = parse_report_panel_settings(form)
 114             active_settings['current_page'] = form.active_p.data or 1
 115             closed_settings['current_page'] = form.closed_p.data or 1
 116             filters = [
 117                getattr(ReportBase,key)==val
 118                for key,val in filters.viewitems()]
 119
 120     all_active = ReportBase.query.filter(
 121         ReportBase.resolved==None).filter(
 122         *filters)
 123     all_closed = ReportBase.query.filter(
 124         ReportBase.resolved!=None).filter(
 125         *filters)
 126
 127     # report_list and closed_report_list are the two lists of up to 10
 128     # items which are actually passed to the user in this request
 129     report_list = all_active.order_by(
 130         ReportBase.created.desc()).offset(
 131             (active_settings['current_page']-1)*10).limit(10)
 132     closed_report_list = all_closed.order_by(
 133         ReportBase.created.desc()).offset(
 134             (closed_settings['current_page']-1)*10).limit(10)
 135
 136     active_settings['last_page'] = int(ceil(all_active.count()/10.))
 137     closed_settings['last_page'] = int(ceil(all_closed.count()/10.))
 138     # Render to response
 139     return render_to_response(
 140         request,
 141         'mediagoblin/moderation/report_panel.html',
 142         {'report_list':report_list,
 143          'closed_report_list':closed_report_list,
 144          'active_settings':active_settings,
 145          'closed_settings':closed_settings})
 146
 147 @require_admin_or_moderator_login
 148 @allow_reporting
 149 def moderation_reports_detail(request):
 150     """
 151     This is the page an admin or moderator goes to see the details of a report.
 152     The report can be resolved or unresolved. This is also the page that a mod-
 153     erator would go to to take an action to resolve a report.
 154     """
 155     form = moderation_forms.ReportResolutionForm(request.form)
 156     report = ReportBase.query.get(request.matchdict['report_id'])
 157
 158     form.take_away_privileges.choices = [
 159         (s.privilege_name,s.privilege_name.title()) \
 160             for s in report.reported_user.all_privileges
 161     ]
 162
 163     if request.method == "POST" and form.validate() and not (
 164         not request.user.has_privilege(u'admin') and
 165         report.reported_user.has_privilege(u'admin')):
 166
 167         user = User.query.get(form.targeted_user.data)
 168         return take_punitive_actions(request, form, report, user)
 169
 170
 171     form.targeted_user.data = report.reported_user_id
 172
 173     return render_to_response(
 174         request,
 175         'mediagoblin/moderation/report.html',
 176         {'report':report,
 177          'form':form})
 178
 179 @user_has_privilege(u'admin')
 180 @active_user_from_url
 181 def give_or_take_away_privilege(request, url_user):
 182     '''
 183     A form action to give or take away a particular privilege from a user.
 184     Can only be used by an admin.
 185     '''
 186     form = moderation_forms.PrivilegeAddRemoveForm(request.form)
 187     if request.method == "POST" and form.validate():
 188         privilege = Privilege.query.filter(
 189             Privilege.privilege_name==form.privilege_name.data).one()
 190         if not take_away_privileges(
 191             url_user.username, form.privilege_name.data):
 192
 193             give_privileges(url_user.username, form.privilege_name.data)
 194         url_user.save()
 195
 196     return redirect(
 197         request,
 198         'mediagoblin.moderation.users_detail',
 199         user=url_user.username)
 200
 201 @user_has_privilege(u'admin')
 202 @active_user_from_url
 203 def ban_or_unban(request, url_user):
 204     """
 205     A page to ban or unban a user. Only can be used by an admin.
 206     """
 207     form = moderation_forms.BanForm(request.form)
 208     if request.method == "POST" and form.validate():
 209         already_banned = unban_user(url_user.id)
 210         same_as_requesting_user = (request.user.id == url_user.id)
 211         if not already_banned and not same_as_requesting_user:
 212             user_ban = ban_user(url_user.id,
 213                 expiration_date = form.user_banned_until.data,
 214                 reason = form.why_user_was_banned.data)
 215             user_ban.save()
 216     return redirect(
 217         request,
 218         'mediagoblin.moderation.users_detail',
 219         user=url_user.username)