forum/views/admin.py

   1 from datetime import datetime, timedelta
   2 import time
   3
   4 from django.shortcuts import render_to_response, get_object_or_404
   5 from django.core.urlresolvers import reverse
   6 from django.http import HttpResponseRedirect, HttpResponse, Http404
   7 from forum.http_responses import HttpResponseUnauthorized
   8 from django.template import RequestContext
   9 from django.utils.translation import ugettext as _
  10 from django.utils import simplejson
  11 from django.db import models
  12 from forum.settings.base import Setting
  13 from forum.forms import MaintenanceModeForm, PageForm
  14 from forum.settings.forms import SettingsSetForm
  15
  16 from forum.models import Question, Answer, User, Node, Action, Page
  17 from forum.actions import NewPageAction, EditPageAction, PublishAction
  18 from forum import settings
  19
  20 def super_user_required(fn):
  21     def wrapper(request, *args, **kwargs):
  22         if request.user.is_authenticated() and request.user.is_superuser:
  23             return fn(request, *args, **kwargs)
  24         else:
  25             return HttpResponseUnauthorized(request)
  26
  27     return wrapper
  28
  29 def admin_page(fn):
  30     @super_user_required
  31     def wrapper(request, *args, **kwargs):
  32         res = fn(request, *args, **kwargs)
  33         if isinstance(res, tuple):
  34             template, context = res
  35             context['basetemplate'] = settings.DJSTYLE_ADMIN_INTERFACE and "osqaadmin/djstyle_base.html" or "osqaadmin/base.html"
  36             context['allsets'] = Setting.sets
  37             context['othersets'] = sorted(
  38                     [s for s in Setting.sets.values() if not s.name in
  39                     ('basic', 'users', 'email', 'paths', 'extkeys', 'repgain', 'minrep', 'voting', 'badges', 'about', 'faq', 'sidebar',
  40                     'form', 'moderation', 'css', 'headandfoot', 'head', 'view', 'urls')]
  41                     , lambda s1, s2: s1.weight - s2.weight)
  42
  43             unsaved = request.session.get('previewing_settings', {})
  44             context['unsaved'] = set([getattr(settings, s).set.name for s in unsaved.keys() if hasattr(settings, s)])
  45
  46             return render_to_response(template, context, context_instance=RequestContext(request))
  47         else:
  48             return res
  49
  50     return wrapper
  51
  52 @admin_page
  53 def dashboard(request):
  54     return ('osqaadmin/dashboard.html', {
  55     'settings_pack': unicode(settings.SETTINGS_PACK),
  56     'statistics': get_statistics(),
  57     'recent_activity': get_recent_activity(),
  58     'flagged_posts': get_flagged_posts(),
  59     })
  60
  61 @super_user_required
  62 def interface_switch(request):
  63     if request.GET and request.GET.get('to', None) and request.GET['to'] in ('default', 'djstyle'):
  64         settings.DJSTYLE_ADMIN_INTERFACE.set_value(request.GET['to'] == 'djstyle')
  65
  66     return HttpResponseRedirect(reverse('admin_index'))
  67
  68 @admin_page
  69 def statistics(request):
  70     today = datetime.now()
  71     last_month = today - timedelta(days=30)
  72
  73     last_month_questions = Question.objects.filter_state(deleted=False).filter(added_at__gt=last_month
  74                                                                                ).order_by('added_at').values_list(
  75             'added_at', flat=True)
  76
  77     last_month_n_questions = Question.objects.filter_state(deleted=False).filter(added_at__lt=last_month).count()
  78     qgraph_data = simplejson.dumps([
  79     (time.mktime(d.timetuple()) * 1000, i + last_month_n_questions)
  80     for i, d in enumerate(last_month_questions)
  81     ])
  82
  83     last_month_users = User.objects.filter(date_joined__gt=last_month
  84                                            ).order_by('date_joined').values_list('date_joined', flat=True)
  85
  86     last_month_n_users = User.objects.filter(date_joined__lt=last_month).count()
  87
  88     ugraph_data = simplejson.dumps([
  89     (time.mktime(d.timetuple()) * 1000, i + last_month_n_users)
  90     for i, d in enumerate(last_month_users)
  91     ])
  92
  93     return 'osqaadmin/statistics.html', {
  94     'graphs': [
  95             {
  96             'id': 'questions_graph',
  97             'caption': _("Questions Graph"),
  98             'data': qgraph_data
  99             }, {
 100             'id': 'userss_graph',
 101             'caption': _("Users Graph"),
 102             'data': ugraph_data
 103             }
 104             ]
 105     }
 106
 107
 108 @admin_page
 109 def settings_set(request, set_name):
 110     set = Setting.sets.get(set_name, {})
 111     current_preview = request.session.get('previewing_settings', {})
 112
 113     if set is None:
 114         raise Http404
 115
 116     if request.POST:
 117         form = SettingsSetForm(set, data=request.POST, files=request.FILES)
 118
 119         if form.is_valid():
 120             if 'preview' in request.POST:
 121                 current_preview.update(form.cleaned_data)
 122                 request.session['previewing_settings'] = current_preview
 123
 124                 return HttpResponseRedirect(reverse('index'))
 125             else:
 126                 for s in set:
 127                     current_preview.pop(s.name, None)
 128
 129                 request.session['previewing_settings'] = current_preview
 130
 131                 if not 'reset' in request.POST:
 132                     form.save()
 133                     request.user.message_set.create(message=_("'%s' settings saved succesfully") % set_name)
 134
 135                     if set_name in ('minrep', 'badges', 'repgain'):
 136                         settings.SETTINGS_PACK.set_value("custom")
 137
 138                 return HttpResponseRedirect(reverse('admin_set', args=[set_name]))
 139     else:
 140         form = SettingsSetForm(set, unsaved=current_preview)
 141
 142     return 'osqaadmin/set.html', {
 143     'form': form,
 144     'markdown': set.markdown,
 145     }
 146
 147 @super_user_required
 148 def get_default(request, set_name, var_name):
 149     set = Setting.sets.get(set_name, None)
 150     if set is None: raise Http404
 151
 152     setting = dict([(s.name, s) for s in set]).get(var_name, None)
 153     if setting is None: raise Http404
 154
 155     setting.to_default()
 156
 157     if request.is_ajax():
 158         return HttpResponse(setting.default)
 159     else:
 160         return HttpResponseRedirect(reverse('admin_set', kwargs={'set_name': set_name}))
 161
 162
 163 def get_recent_activity():
 164     return Action.objects.order_by('-action_date')[0:30]
 165
 166 def get_flagged_posts():
 167     return Action.objects.filter(canceled=False, action_type="flag").order_by('-action_date')[0:30]
 168
 169 def get_statistics():
 170     return {
 171     'total_users': User.objects.all().count(),
 172     'users_last_24': User.objects.filter(date_joined__gt=(datetime.now() - timedelta(days=1))).count(),
 173     'total_questions': Question.objects.filter_state(deleted=False).count(),
 174     'questions_last_24': Question.objects.filter_state(deleted=False).filter(
 175             added_at__gt=(datetime.now() - timedelta(days=1))).count(),
 176     'total_answers': Answer.objects.filter_state(deleted=False).count(),
 177     'answers_last_24': Answer.objects.filter_state(deleted=False).filter(
 178             added_at__gt=(datetime.now() - timedelta(days=1))).count(),
 179     }
 180
 181 @super_user_required
 182 def go_bootstrap(request):
 183 #todo: this is the quick and dirty way of implementing a bootstrap mode
 184     try:
 185         from forum_modules.default_badges import settings as dbsets
 186         dbsets.POPULAR_QUESTION_VIEWS.set_value(100)
 187         dbsets.NOTABLE_QUESTION_VIEWS.set_value(200)
 188         dbsets.FAMOUS_QUESTION_VIEWS.set_value(300)
 189         dbsets.NICE_ANSWER_VOTES_UP.set_value(2)
 190         dbsets.NICE_QUESTION_VOTES_UP.set_value(2)
 191         dbsets.GOOD_ANSWER_VOTES_UP.set_value(4)
 192         dbsets.GOOD_QUESTION_VOTES_UP.set_value(4)
 193         dbsets.GREAT_ANSWER_VOTES_UP.set_value(8)
 194         dbsets.GREAT_QUESTION_VOTES_UP.set_value(8)
 195         dbsets.FAVORITE_QUESTION_FAVS.set_value(1)
 196         dbsets.STELLAR_QUESTION_FAVS.set_value(3)
 197         dbsets.DISCIPLINED_MIN_SCORE.set_value(3)
 198         dbsets.PEER_PRESSURE_MAX_SCORE.set_value(-3)
 199         dbsets.CIVIC_DUTY_VOTES.set_value(15)
 200         dbsets.PUNDIT_COMMENT_COUNT.set_value(10)
 201         dbsets.SELF_LEARNER_UP_VOTES.set_value(2)
 202         dbsets.STRUNK_AND_WHITE_EDITS.set_value(10)
 203         dbsets.ENLIGHTENED_UP_VOTES.set_value(2)
 204         dbsets.GURU_UP_VOTES.set_value(4)
 205         dbsets.NECROMANCER_UP_VOTES.set_value(2)
 206         dbsets.NECROMANCER_DIF_DAYS.set_value(30)
 207         dbsets.TAXONOMIST_USE_COUNT.set_value(5)
 208     except:
 209         pass
 210
 211     settings.REP_TO_VOTE_UP.set_value(0)
 212     settings.REP_TO_VOTE_DOWN.set_value(15)
 213     settings.REP_TO_FLAG.set_value(15)
 214     settings.REP_TO_COMMENT.set_value(0)
 215     settings.REP_TO_LIKE_COMMENT.set_value(0)
 216     settings.REP_TO_UPLOAD.set_value(0)
 217     settings.REP_TO_CREATE_TAGS.set_value(0)
 218     settings.REP_TO_CLOSE_OWN.set_value(60)
 219     settings.REP_TO_REOPEN_OWN.set_value(120)
 220     settings.REP_TO_RETAG.set_value(150)
 221     settings.REP_TO_EDIT_WIKI.set_value(200)
 222     settings.REP_TO_EDIT_OTHERS.set_value(400)
 223     settings.REP_TO_CLOSE_OTHERS.set_value(600)
 224     settings.REP_TO_DELETE_COMMENTS.set_value(400)
 225     settings.REP_TO_VIEW_FLAGS.set_value(30)
 226
 227     settings.INITIAL_REP.set_value(1)
 228     settings.MAX_REP_BY_UPVOTE_DAY.set_value(300)
 229     settings.REP_GAIN_BY_UPVOTED.set_value(15)
 230     settings.REP_LOST_BY_DOWNVOTED.set_value(1)
 231     settings.REP_LOST_BY_DOWNVOTING.set_value(0)
 232     settings.REP_GAIN_BY_ACCEPTED.set_value(25)
 233     settings.REP_GAIN_BY_ACCEPTING.set_value(5)
 234     settings.REP_LOST_BY_FLAGGED.set_value(2)
 235     settings.REP_LOST_BY_FLAGGED_3_TIMES.set_value(30)
 236     settings.REP_LOST_BY_FLAGGED_5_TIMES.set_value(100)
 237
 238     settings.SETTINGS_PACK.set_value("bootstrap")
 239
 240     request.user.message_set.create(message=_('Bootstrap mode enabled'))
 241     return HttpResponseRedirect(reverse('admin_index'))
 242
 243 @super_user_required
 244 def go_defaults(request):
 245     for setting in Setting.sets['badges']:
 246         setting.to_default()
 247     for setting in Setting.sets['minrep']:
 248         setting.to_default()
 249     for setting in Setting.sets['repgain']:
 250         setting.to_default()
 251
 252     settings.SETTINGS_PACK.set_value("default")
 253
 254     request.user.message_set.create(message=_('All values reverted to defaults'))
 255     return HttpResponseRedirect(reverse('admin_index'))
 256
 257
 258 @super_user_required
 259 def recalculate_denormalized(request):
 260     for n in Node.objects.all():
 261         n = n.leaf
 262         n.score = n.votes.aggregate(score=models.Sum('value'))['score']
 263         if not n.score: n.score = 0
 264         n.save()
 265
 266     for u in User.objects.all():
 267         u.reputation = u.reputes.aggregate(reputation=models.Sum('value'))['reputation']
 268         u.save()
 269
 270     request.user.message_set.create(message=_('All values recalculated'))
 271     return HttpResponseRedirect(reverse('admin_index'))
 272
 273 @admin_page
 274 def maintenance(request):
 275     if request.POST:
 276         if 'close' in request.POST or 'adjust' in request.POST:
 277             form = MaintenanceModeForm(request.POST)
 278
 279             if form.is_valid():
 280                 settings.MAINTAINANCE_MODE.set_value({
 281                 'allow_ips': form.cleaned_data['ips'],
 282                 'message': form.cleaned_data['message']})
 283
 284                 if 'close' in request.POST:
 285                     message = _('Maintenance mode enabled')
 286                 else:
 287                     message = _('Settings adjusted')
 288
 289                 request.user.message_set.create(message=message)
 290
 291                 return HttpResponseRedirect(reverse('admin_maintenance'))
 292         elif 'open' in request.POST:
 293             settings.MAINTAINANCE_MODE.set_value(None)
 294             request.user.message_set.create(message=_("Your site is now running normally"))
 295             return HttpResponseRedirect(reverse('admin_maintenance'))
 296     else:
 297         form = MaintenanceModeForm(initial={'ips': request.META['REMOTE_ADDR'],
 298                                             'message': _('Currently down for maintenance. We\'ll be back soon')})
 299
 300     return ('osqaadmin/maintenance.html', {'form': form, 'in_maintenance': settings.MAINTAINANCE_MODE.value is not None
 301                                            })
 302
 303
 304 @admin_page
 305 def flagged_posts(request):
 306     return ('osqaadmin/flagged_posts.html', {
 307     'flagged_posts': get_flagged_posts(),
 308     })
 309
 310 @admin_page
 311 def static_pages(request):
 312     pages = Page.objects.all()
 313
 314     return ('osqaadmin/static_pages.html', {
 315     'pages': pages,
 316     })
 317
 318 @admin_page
 319 def edit_page(request, id=None):
 320     if id:
 321         page = get_object_or_404(Page, id=id)
 322     else:
 323         page = None
 324
 325     if request.POST:
 326         form = PageForm(page, request.POST)
 327
 328         if form.is_valid():
 329             if form.has_changed():
 330                 if not page:
 331                     page = NewPageAction(user=request.user, ip=request.META['REMOTE_ADDR']).save(data=form.cleaned_data
 332                                                                                                  ).node
 333                 else:
 334                     EditPageAction(user=request.user, node=page, ip=request.META['REMOTE_ADDR']).save(
 335                             data=form.cleaned_data)
 336
 337             if ('publish' in request.POST) and (not page.published):
 338                 PublishAction(user=request.user, node=page, ip=request.META['REMOTE_ADDR']).save()
 339             elif ('unpublish' in request.POST) and page.published:
 340                 page.nstate.published.cancel(ip=request.META['REMOTE_ADDR'])
 341
 342             return HttpResponseRedirect(reverse('admin_edit_page', kwargs={'id': page.id}))
 343
 344     else:
 345         form = PageForm(page)
 346
 347     if page:
 348         published = page.published
 349     else:
 350         published = False
 351
 352     return ('osqaadmin/edit_page.html', {
 353     'page': page,
 354     'form': form,
 355     'published': published
 356     })
 357
 358 @admin_page
 359 def moderation(request):
 360     if request.POST:
 361         if not 'ids' in request.POST:
 362             verify = None
 363         else:
 364             sort = {
 365             'high-rep': '-reputation',
 366             'newer': '-date_joined',
 367             'older': 'date_joined',
 368             }.get(request.POST.get('sort'), None)
 369
 370             if sort:
 371                 try:
 372                     limit = int(request.POST['limit'])
 373                 except:
 374                     limit = 5
 375
 376                 verify = User.objects.order_by(sort)[:limit]
 377             else:
 378                 verify = None
 379
 380         if verify:
 381             possible_cheaters = []
 382             verify = User.objects.order_by(sort)[:5]
 383
 384             cheat_score_sort = lambda c1, c2: cmp(c2.fdata['fake_score'], c1.fdata['fake_score'])
 385
 386             for user in verify:
 387                 possible_fakes = []
 388                 affecters = User.objects.filter(actions__node__author=user, actions__canceled=False).annotate(
 389                         affect_count=models.Count('actions')).order_by('-affect_count')
 390                 user_ips = set(Action.objects.filter(user=user).values_list('ip', flat=True).distinct('ip'))
 391
 392                 for affecter in affecters:
 393                     if affecter == user:
 394                         continue
 395
 396                     data = {'affect_count': affecter.affect_count}
 397
 398                     total_actions = affecter.actions.filter(canceled=False).exclude(node=None).count()
 399                     ratio = (float(affecter.affect_count) / float(total_actions)) * 100
 400
 401                     if total_actions > 10 and ratio > 50:
 402                         data['total_actions'] = total_actions
 403                         data['action_ratio'] = ratio
 404
 405                         affecter_ips = set(
 406                                 Action.objects.filter(user=affecter).values_list('ip', flat=True).distinct('ip'))
 407                         cross_ips = len(user_ips & affecter_ips)
 408
 409                         data['cross_ip_count'] = cross_ips
 410                         data['total_ip_count'] = len(affecter_ips)
 411                         data['cross_ip_ratio'] = (float(data['cross_ip_count']) / float(data['total_ip_count'])) * 100
 412
 413                         if affecter.email_isvalid:
 414                             email_score = 0
 415                         else:
 416                             email_score = 50.0
 417
 418                         data['fake_score'] = ((data['cross_ip_ratio'] + data['action_ratio'] + email_score) / 100) * 4
 419
 420                         affecter.fdata = data
 421                         possible_fakes.append(affecter)
 422
 423                 if len(possible_fakes) > 0:
 424                     possible_fakes = sorted(possible_fakes, cheat_score_sort)
 425                     possible_cheaters.append((user, possible_fakes))
 426
 427             return ('osqaadmin/moderation.html', {'cheaters': possible_cheaters})
 428
 429     return ('osqaadmin/moderation.html', {})
 430
 431
 432