forum/views/commands.py

   1 import datetime
   2 from forum import settings
   3 from django.core.exceptions import ObjectDoesNotExist
   4 from django.utils import simplejson
   5 from django.http import HttpResponse, HttpResponseRedirect, Http404
   6 from django.shortcuts import get_object_or_404, render_to_response
   7 from django.utils.translation import ungettext, ugettext as _
   8 from django.template import RequestContext
   9 from forum.models import *
  10 from forum.models.node import NodeMetaClass
  11 from forum.actions import *
  12 from django.core.urlresolvers import reverse
  13 from django.contrib.auth.decorators import login_required
  14 from forum.utils.decorators import ajax_method, ajax_login_required
  15 from decorators import command, CommandException, RefreshPageCommand
  16 from forum.modules import decorate
  17 from forum import settings
  18 import logging
  19
  20 class NotEnoughRepPointsException(CommandException):
  21     def __init__(self, action):
  22         super(NotEnoughRepPointsException, self).__init__(
  23                 _(
  24                         """Sorry, but you don't have enough reputation points to %(action)s.<br />Please check the <a href='%(faq_url)s'>faq</a>"""
  25                         ) % {'action': action, 'faq_url': reverse('faq')}
  26                 )
  27
  28 class CannotDoOnOwnException(CommandException):
  29     def __init__(self, action):
  30         super(CannotDoOnOwnException, self).__init__(
  31                 _(
  32                         """Sorry but you cannot %(action)s your own post.<br />Please check the <a href='%(faq_url)s'>faq</a>"""
  33                         ) % {'action': action, 'faq_url': reverse('faq')}
  34                 )
  35
  36 class AnonymousNotAllowedException(CommandException):
  37     def __init__(self, action):
  38         super(AnonymousNotAllowedException, self).__init__(
  39                 _(
  40                         """Sorry but anonymous users cannot %(action)s.<br />Please login or create an account <a href='%(signin_url)s'>here</a>."""
  41                         ) % {'action': action, 'signin_url': reverse('auth_signin')}
  42                 )
  43
  44 class NotEnoughLeftException(CommandException):
  45     def __init__(self, action, limit):
  46         super(NotEnoughLeftException, self).__init__(
  47                 _(
  48                         """Sorry, but you don't have enough %(action)s left for today..<br />The limit is %(limit)s per day..<br />Please check the <a href='%(faq_url)s'>faq</a>"""
  49                         ) % {'action': action, 'limit': limit, 'faq_url': reverse('faq')}
  50                 )
  51
  52 class CannotDoubleActionException(CommandException):
  53     def __init__(self, action):
  54         super(CannotDoubleActionException, self).__init__(
  55                 _(
  56                         """Sorry, but you cannot %(action)s twice the same post.<br />Please check the <a href='%(faq_url)s'>faq</a>"""
  57                         ) % {'action': action, 'faq_url': reverse('faq')}
  58                 )
  59
  60
  61 @decorate.withfn(command)
  62 def vote_post(request, id, vote_type):
  63     post = get_object_or_404(Node, id=id).leaf
  64     user = request.user
  65
  66     if not user.is_authenticated():
  67         raise AnonymousNotAllowedException(_('vote'))
  68
  69     if user == post.author:
  70         raise CannotDoOnOwnException(_('vote'))
  71
  72     if not (vote_type == 'up' and user.can_vote_up() or user.can_vote_down()):
  73         raise NotEnoughRepPointsException(vote_type == 'up' and _('upvote') or _('downvote'))
  74
  75     user_vote_count_today = user.get_vote_count_today()
  76
  77     if user_vote_count_today >= int(settings.MAX_VOTES_PER_DAY):
  78         raise NotEnoughLeftException(_('votes'), str(settings.MAX_VOTES_PER_DAY))
  79
  80     new_vote_cls = (vote_type == 'up') and VoteUpAction or VoteDownAction
  81     score_inc = 0
  82
  83     old_vote = VoteAction.get_action_for(node=post, user=user)
  84
  85     if old_vote:
  86         if old_vote.action_date < datetime.datetime.now() - datetime.timedelta(days=int(settings.DENY_UNVOTE_DAYS)):
  87             raise CommandException(
  88                     _("Sorry but you cannot cancel a vote after %(ndays)d %(tdays)s from the original vote") %
  89                     {'ndays': int(settings.DENY_UNVOTE_DAYS),
  90                      'tdays': ungettext('day', 'days', int(settings.DENY_UNVOTE_DAYS))}
  91                     )
  92
  93         old_vote.cancel(ip=request.META['REMOTE_ADDR'])
  94         score_inc += (old_vote.__class__ == VoteDownAction) and 1 or -1
  95
  96     if old_vote.__class__ != new_vote_cls:
  97         new_vote_cls(user=user, node=post, ip=request.META['REMOTE_ADDR']).save()
  98         score_inc += (new_vote_cls == VoteUpAction) and 1 or -1
  99     else:
 100         vote_type = "none"
 101
 102     response = {
 103     'commands': {
 104     'update_post_score': [id, score_inc],
 105     'update_user_post_vote': [id, vote_type]
 106     }
 107     }
 108
 109     votes_left = (int(settings.MAX_VOTES_PER_DAY) - user_vote_count_today) + (vote_type == 'none' and -1 or 1)
 110
 111     if int(settings.START_WARN_VOTES_LEFT) >= votes_left:
 112         response['message'] = _("You have %(nvotes)s %(tvotes)s left today.") % \
 113                     {'nvotes': votes_left, 'tvotes': ungettext('vote', 'votes', votes_left)}
 114
 115     return response
 116
 117 @decorate.withfn(command)
 118 def flag_post(request, id):
 119     if not request.POST:
 120         return render_to_response('node/report.html', {'types': settings.FLAG_TYPES})
 121
 122     post = get_object_or_404(Node, id=id)
 123     user = request.user
 124
 125     if not user.is_authenticated():
 126         raise AnonymousNotAllowedException(_('flag posts'))
 127
 128     if user == post.author:
 129         raise CannotDoOnOwnException(_('flag'))
 130
 131     if not (user.can_flag_offensive(post)):
 132         raise NotEnoughRepPointsException(_('flag posts'))
 133
 134     user_flag_count_today = user.get_flagged_items_count_today()
 135
 136     if user_flag_count_today >= int(settings.MAX_FLAGS_PER_DAY):
 137         raise NotEnoughLeftException(_('flags'), str(settings.MAX_FLAGS_PER_DAY))
 138
 139     try:
 140         current = FlagAction.objects.get(canceled=False, user=user, node=post)
 141         raise CommandException(
 142                 _("You already flagged this post with the following reason: %(reason)s") % {'reason': current.extra})
 143     except ObjectDoesNotExist:
 144         reason = request.POST.get('prompt', '').strip()
 145
 146         if not len(reason):
 147             raise CommandException(_("Reason is empty"))
 148
 149         FlagAction(user=user, node=post, extra=reason, ip=request.META['REMOTE_ADDR']).save()
 150
 151     return {'message': _("Thank you for your report. A moderator will review your submission shortly.")}
 152
 153 @decorate.withfn(command)
 154 def like_comment(request, id):
 155     comment = get_object_or_404(Comment, id=id)
 156     user = request.user
 157
 158     if not user.is_authenticated():
 159         raise AnonymousNotAllowedException(_('like comments'))
 160
 161     if user == comment.user:
 162         raise CannotDoOnOwnException(_('like'))
 163
 164     if not user.can_like_comment(comment):
 165         raise NotEnoughRepPointsException( _('like comments'))
 166
 167     like = VoteAction.get_action_for(node=comment, user=user)
 168
 169     if like:
 170         like.cancel(ip=request.META['REMOTE_ADDR'])
 171         likes = False
 172     else:
 173         VoteUpCommentAction(node=comment, user=user, ip=request.META['REMOTE_ADDR']).save()
 174         likes = True
 175
 176     return {
 177     'commands': {
 178     'update_post_score': [comment.id, likes and 1 or -1],
 179     'update_user_post_vote': [comment.id, likes and 'up' or 'none']
 180     }
 181     }
 182
 183 @decorate.withfn(command)
 184 def delete_comment(request, id):
 185     comment = get_object_or_404(Comment, id=id)
 186     user = request.user
 187
 188     if not user.is_authenticated():
 189         raise AnonymousNotAllowedException(_('delete comments'))
 190
 191     if not user.can_delete_comment(comment):
 192         raise NotEnoughRepPointsException( _('delete comments'))
 193
 194     if not comment.nis.deleted:
 195         DeleteAction(node=comment, user=user, ip=request.META['REMOTE_ADDR']).save()
 196
 197     return {
 198     'commands': {
 199     'remove_comment': [comment.id],
 200     }
 201     }
 202
 203 @decorate.withfn(command)
 204 def mark_favorite(request, id):
 205     question = get_object_or_404(Question, id=id)
 206
 207     if not request.user.is_authenticated():
 208         raise AnonymousNotAllowedException(_('mark a question as favorite'))
 209
 210     try:
 211         favorite = FavoriteAction.objects.get(canceled=False, node=question, user=request.user)
 212         favorite.cancel(ip=request.META['REMOTE_ADDR'])
 213         added = False
 214     except ObjectDoesNotExist:
 215         FavoriteAction(node=question, user=request.user, ip=request.META['REMOTE_ADDR']).save()
 216         added = True
 217
 218     return {
 219     'commands': {
 220     'update_favorite_count': [added and 1 or -1],
 221     'update_favorite_mark': [added and 'on' or 'off']
 222     }
 223     }
 224
 225 @decorate.withfn(command)
 226 def comment(request, id):
 227     post = get_object_or_404(Node, id=id)
 228     user = request.user
 229
 230     if not user.is_authenticated():
 231         raise AnonymousNotAllowedException(_('comment'))
 232
 233     if not request.method == 'POST':
 234         raise CommandException(_("Invalid request"))
 235
 236     comment_text = request.POST.get('comment', '').strip()
 237
 238     if not len(comment_text):
 239         raise CommandException(_("Comment is empty"))
 240
 241     if len(comment_text) < settings.FORM_MIN_COMMENT_BODY:
 242         raise CommandException(_("At least %d characters required on comment body.") % settings.FORM_MIN_COMMENT_BODY)
 243
 244     if len(comment_text) > settings.FORM_MAX_COMMENT_BODY:
 245         raise CommandException(_("No more than %d characters on comment body.") % settings.FORM_MAX_COMMENT_BODY)
 246
 247     if 'id' in request.POST:
 248         comment = get_object_or_404(Comment, id=request.POST['id'])
 249
 250         if not user.can_edit_comment(comment):
 251             raise NotEnoughRepPointsException( _('edit comments'))
 252
 253         comment = ReviseAction(user=user, node=comment, ip=request.META['REMOTE_ADDR']).save(
 254                 data=dict(text=comment_text)).node
 255     else:
 256         if not user.can_comment(post):
 257             raise NotEnoughRepPointsException( _('comment'))
 258
 259         comment = CommentAction(user=user, ip=request.META['REMOTE_ADDR']).save(
 260                 data=dict(text=comment_text, parent=post)).node
 261
 262     if comment.active_revision.revision == 1:
 263         return {
 264         'commands': {
 265         'insert_comment': [
 266                 id, comment.id, comment.comment, user.decorated_name, user.get_profile_url(),
 267                 reverse('delete_comment', kwargs={'id': comment.id}),
 268                 reverse('node_markdown', kwargs={'id': comment.id})
 269                 ]
 270         }
 271         }
 272     else:
 273         return {
 274         'commands': {
 275         'update_comment': [comment.id, comment.comment]
 276         }
 277         }
 278
 279 @decorate.withfn(command)
 280 def node_markdown(request, id):
 281     user = request.user
 282
 283     if not user.is_authenticated():
 284         raise AnonymousNotAllowedException(_('accept answers'))
 285
 286     node = get_object_or_404(Node, id=id)
 287     return HttpResponse(node.body, mimetype="text/plain")
 288
 289
 290 @decorate.withfn(command)
 291 def accept_answer(request, id):
 292     user = request.user
 293
 294     if not user.is_authenticated():
 295         raise AnonymousNotAllowedException(_('accept answers'))
 296
 297     answer = get_object_or_404(Answer, id=id)
 298     question = answer.question
 299
 300     if not user.can_accept_answer(answer):
 301         raise CommandException(_("Sorry but only the question author can accept an answer"))
 302
 303     commands = {}
 304
 305     if answer.nis.accepted:
 306         answer.nstate.accepted.cancel(user, ip=request.META['REMOTE_ADDR'])
 307         commands['unmark_accepted'] = [answer.id]
 308     else:
 309         accepted = question.accepted_answer
 310
 311         if accepted:
 312             accepted.nstate.accepted.cancel(user, ip=request.META['REMOTE_ADDR'])
 313             commands['unmark_accepted'] = [accepted.id]
 314
 315         AcceptAnswerAction(node=answer, user=user, ip=request.META['REMOTE_ADDR']).save()
 316         commands['mark_accepted'] = [answer.id]
 317
 318     return {'commands': commands}
 319
 320 @decorate.withfn(command)
 321 def delete_post(request, id):
 322     post = get_object_or_404(Node, id=id)
 323     user = request.user
 324
 325     if not user.is_authenticated():
 326         raise AnonymousNotAllowedException(_('delete posts'))
 327
 328     if not (user.can_delete_post(post)):
 329         raise NotEnoughRepPointsException(_('delete posts'))
 330
 331     ret = {'commands': {}}
 332
 333     if post.nis.deleted:
 334         post.nstate.deleted.cancel(user, ip=request.META['REMOTE_ADDR'])
 335         ret['commands']['unmark_deleted'] = [post.node_type, id]
 336     else:
 337         DeleteAction(node=post, user=user, ip=request.META['REMOTE_ADDR']).save()
 338
 339         ret['commands']['mark_deleted'] = [post.node_type, id]
 340
 341     return ret
 342
 343 @decorate.withfn(command)
 344 def close(request, id, close):
 345     if close and not request.POST:
 346         return render_to_response('node/report.html', {'types': settings.CLOSE_TYPES})
 347
 348     question = get_object_or_404(Question, id=id)
 349     user = request.user
 350
 351     if not user.is_authenticated():
 352         raise AnonymousNotAllowedException(_('close questions'))
 353
 354     if question.nis.closed:
 355         if not user.can_reopen_question(question):
 356             raise NotEnoughRepPointsException(_('reopen questions'))
 357
 358         question.nstate.closed.cancel(user, ip=request.META['REMOTE_ADDR'])
 359     else:
 360         if not request.user.can_close_question(question):
 361             raise NotEnoughRepPointsException(_('close questions'))
 362
 363         reason = request.POST.get('prompt', '').strip()
 364
 365         if not len(reason):
 366             raise CommandException(_("Reason is empty"))
 367
 368         CloseAction(node=question, user=user, extra=reason, ip=request.META['REMOTE_ADDR']).save()
 369
 370     return RefreshPageCommand()
 371
 372 @decorate.withfn(command)
 373 def wikify(request, id):
 374     node = get_object_or_404(Node, id=id)
 375     user = request.user
 376
 377     if not user.is_authenticated():
 378         raise AnonymousNotAllowedException(_('mark posts as community wiki'))
 379
 380     if node.nis.wiki:
 381         if not user.can_cancel_wiki(node):
 382             raise NotEnoughRepPointsException(_('cancel a community wiki post'))
 383
 384         if node.nstate.wiki.action_type == "wikify":
 385             node.nstate.wiki.cancel()
 386         else:
 387             node.nstate.wiki = None
 388     else:
 389         if not user.can_wikify(node):
 390             raise NotEnoughRepPointsException(_('mark posts as community wiki'))
 391
 392         WikifyAction(node=node, user=user, ip=request.META['REMOTE_ADDR']).save()
 393
 394     return RefreshPageCommand()
 395
 396 @decorate.withfn(command)
 397 def convert_to_comment(request, id):
 398     user = request.user
 399     answer = get_object_or_404(Answer, id=id)
 400     question = answer.question
 401
 402     if not request.POST:
 403         description = lambda a: _("Answer by %(uname)s: %(snippet)s...") % {'uname': a.author.username,
 404                                                                             'snippet': a.summary[:10]}
 405         nodes = [(question.id, _("Question"))]
 406         [nodes.append((a.id, description(a))) for a in
 407          question.answers.filter_state(deleted=False).exclude(id=answer.id)]
 408
 409         return render_to_response('node/convert_to_comment.html', {'answer': answer, 'nodes': nodes})
 410
 411     if not user.is_authenticated():
 412         raise AnonymousNotAllowedException(_("convert answers to comments"))
 413
 414     if not user.can_convert_to_comment(answer):
 415         raise NotEnoughRepPointsException(_("convert answers to comments"))
 416
 417     try:
 418         new_parent = Node.objects.get(id=request.POST.get('under', None))
 419     except:
 420         raise CommandException(_("That is an invalid post to put the comment under"))
 421
 422     if not (new_parent == question or (new_parent.node_type == 'answer' and new_parent.parent == question)):
 423         raise CommandException(_("That is an invalid post to put the comment under"))
 424
 425     AnswerToCommentAction(user=user, node=answer, ip=request.META['REMOTE_ADDR']).save(data=dict(new_parent=new_parent))
 426
 427     return RefreshPageCommand()
 428
 429 @decorate.withfn(command)
 430 def subscribe(request, id):
 431     question = get_object_or_404(Question, id=id)
 432
 433     try:
 434         subscription = QuestionSubscription.objects.get(question=question, user=request.user)
 435         subscription.delete()
 436         subscribed = False
 437     except:
 438         subscription = QuestionSubscription(question=question, user=request.user, auto_subscription=False)
 439         subscription.save()
 440         subscribed = True
 441
 442     return {
 443     'commands': {
 444     'set_subscription_button': [subscribed and _('unsubscribe me') or _('subscribe me')],
 445     'set_subscription_status': ['']
 446     }
 447     }
 448
 449 #internally grouped views - used by the tagging system
 450 @ajax_login_required
 451 def mark_tag(request, tag=None, **kwargs):#tagging system
 452     action = kwargs['action']
 453     ts = MarkedTag.objects.filter(user=request.user, tag__name=tag)
 454     if action == 'remove':
 455         logging.debug('deleting tag %s' % tag)
 456         ts.delete()
 457     else:
 458         reason = kwargs['reason']
 459         if len(ts) == 0:
 460             try:
 461                 t = Tag.objects.get(name=tag)
 462                 mt = MarkedTag(user=request.user, reason=reason, tag=t)
 463                 mt.save()
 464             except:
 465                 pass
 466         else:
 467             ts.update(reason=reason)
 468     return HttpResponse(simplejson.dumps(''), mimetype="application/json")
 469
 470 def matching_tags(request):
 471     if len(request.GET['q']) == 0:
 472         raise CommandException(_("Invalid request"))
 473
 474     possible_tags = Tag.active.filter(name__istartswith = request.GET['q'])
 475     tag_output = ''
 476     for tag in possible_tags:
 477         tag_output += (tag.name + "|" + tag.name + "." + tag.used_count.__str__() + "\n")
 478
 479     return HttpResponse(tag_output, mimetype="text/plain")
 480
 481 def related_questions(request):
 482     if request.POST and request.POST.get('title', None):
 483         return HttpResponse(simplejson.dumps(
 484                 [dict(title=q.title, url=q.get_absolute_url(), score=q.score, summary=q.summary)
 485                  for q in Question.objects.search(request.POST['title']).filter_state(deleted=False)[0:10]]),
 486                             mimetype="application/json")
 487     else:
 488         raise Http404()
 489
 490
 491
 492
 493
 494
 495