forum/views/commands.py

   1 import datetime
   2 from django.conf import settings
   3 from django.core.exceptions import ObjectDoesNotExist
   4 from django.utils import simplejson
   5 from django.http import HttpResponse, HttpResponseRedirect, HttpResponseForbidden
   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.forms import CloseForm
  11 from django.core.urlresolvers import reverse
  12 from django.contrib.auth.decorators import login_required
  13 from forum.utils.decorators import ajax_method, ajax_login_required
  14 from decorators import command
  15 import logging
  16
  17 class NotEnoughRepPointsException(Exception):
  18     def __init__(self, action):
  19         super(NotEnoughRepPointsException, self).__init__(
  20             _("""
  21             Sorry, but you don't have enough reputation points to %(action)s.<br />
  22             Please check the <a href'%(faq_url)s'>faq</a>
  23             """ % {'action': action, 'faq_url': reverse('faq')})
  24         )
  25
  26 class CannotDoOnOwnException(Exception):
  27     def __init__(self, action):
  28         super(CannotDoOnOwnException, self).__init__(
  29             _("""
  30             Sorry but you cannot %(action)s your own post.<br />
  31             Please check the <a href'%(faq_url)s'>faq</a>
  32             """ % {'action': action, 'faq_url': reverse('faq')})
  33         )
  34
  35 class AnonymousNotAllowedException(Exception):
  36     def __init__(self, action):
  37         super(AnonymousNotAllowedException, self).__init__(
  38             _("""
  39             Sorry but anonymous users cannot %(action)s.<br />
  40             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(Exception):
  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 />
  49             The limit is %(limit)s per day..<br />
  50             Please check the <a href'%(faq_url)s'>faq</a>
  51             """ % {'action': action, 'limit': limit, 'faq_url': reverse('faq')})
  52         )
  53
  54 class CannotDoubleActionException(Exception):
  55     def __init__(self, action):
  56         super(CannotDoubleActionException, self).__init__(
  57             _("""
  58             Sorry, but you cannot %(action)s twice the same post.<br />
  59             Please check the <a href'%(faq_url)s'>faq</a>
  60             """ % {'action': action, 'faq_url': reverse('faq')})
  61         )
  62
  63
  64 @command
  65 def vote_post(request, id, vote_type):
  66     post = get_object_or_404(Node, id=id).leaf
  67     vote_score = vote_type == 'up' and 1 or -1
  68     user = request.user
  69
  70     if not user.is_authenticated():
  71         raise AnonymousNotAllowedException(_('vote'))
  72
  73     if user == post.author:
  74         raise CannotDoOnOwnException(_('vote'))
  75
  76     if not (vote_type == 'up' and user.can_vote_up() or user.can_vote_down()):
  77         raise NotEnoughRepPointsException(vote_type == 'up' and _('upvote') or _('downvote'))
  78
  79     user_vote_count_today = user.get_vote_count_today()
  80
  81     if user_vote_count_today >= int(settings.MAX_VOTES_PER_DAY):
  82         raise NotEnoughLeftException(_('votes'), str(settings.MAX_VOTES_PER_DAY))
  83
  84     try:
  85         vote = post.votes.get(canceled=False, user=user)
  86
  87         if vote.voted_at < datetime.datetime.now() - datetime.timedelta(days=int(settings.DENY_UNVOTE_DAYS)):
  88             raise Exception(
  89                     _("Sorry but you cannot cancel a vote after %(ndays)d %(tdays)s from the original vote") %
  90                     {'ndays': int(settings.DENY_UNVOTE_DAYS), 'tdays': ungettext('day', 'days', int(settings.DENY_UNVOTE_DAYS))}
  91             )
  92
  93         vote.cancel()
  94         vote_type = 'none'
  95     except ObjectDoesNotExist:
  96         #there is no vote yet
  97         vote = Vote(user=user, node=post, vote=vote_score)
  98         vote.save()
  99
 100     response = {
 101         'commands': {
 102             'update_post_score': [id, vote.vote * (vote_type == 'none' and -1 or 1)],
 103             'update_user_post_vote': [id, vote_type]
 104         }
 105     }
 106
 107     votes_left = int(settings.MAX_VOTES_PER_DAY) - user_vote_count_today + (vote_type == 'none' and -1 or 1)
 108
 109     if int(settings.START_WARN_VOTES_LEFT) >= votes_left:
 110         response['message'] = _("You have %(nvotes)s %(tvotes)s left today.") % \
 111                     {'nvotes': votes_left, 'tvotes': ungettext('vote', 'votes', votes_left)}
 112
 113     return response
 114
 115 @command
 116 def flag_post(request, id):
 117     post = get_object_or_404(Node, id=id)
 118     user = request.user
 119
 120     if not user.is_authenticated():
 121         raise AnonymousNotAllowedException(_('flag posts'))
 122
 123     if user == post.author:
 124         raise CannotDoOnOwnException(_('flag'))
 125
 126     if not (user.can_flag_offensive(post)):
 127         raise NotEnoughRepPointsException(_('flag posts'))
 128
 129     user_flag_count_today = user.get_flagged_items_count_today()
 130
 131     if user_flag_count_today >= int(settings.MAX_FLAGS_PER_DAY):
 132         raise NotEnoughLeftException(_('flags'), str(settings.MAX_FLAGS_PER_DAY))
 133
 134     try:
 135         post.flaggeditems.get(user=user)
 136         raise CannotDoubleActionException(_('flag'))
 137     except ObjectDoesNotExist:
 138         flag = FlaggedItem(user=user, content_object=post)
 139         flag.save()
 140
 141     return {}
 142
 143 @command
 144 def like_comment(request, id):
 145     comment = get_object_or_404(Comment, id=id)
 146     user = request.user
 147
 148     if not user.is_authenticated():
 149         raise AnonymousNotAllowedException(_('like comments'))
 150
 151     if user == comment.user:
 152         raise CannotDoOnOwnException(_('like'))
 153
 154     if not user.can_like_comment(comment):
 155         raise NotEnoughRepPointsException( _('like comments'))
 156
 157     try:
 158         like = LikedComment.active.get(comment=comment, user=user)
 159         like.cancel()
 160         likes = False
 161     except ObjectDoesNotExist:
 162         like = LikedComment(comment=comment, user=user)
 163         like.save()
 164         likes = True
 165
 166     return {
 167         'commands': {
 168             'update_comment_score': [comment.id, likes and 1 or -1],
 169             'update_likes_comment_mark': [comment.id, likes and 'on' or 'off']
 170         }
 171     }
 172
 173 @command
 174 def delete_comment(request, id):
 175     comment = get_object_or_404(Comment, id=id)
 176     user = request.user
 177
 178     if not user.is_authenticated():
 179         raise AnonymousNotAllowedException(_('delete comments'))
 180
 181     if not user.can_delete_comment(comment):
 182         raise NotEnoughRepPointsException( _('delete comments'))
 183
 184     comment.mark_deleted(user)
 185
 186     return {
 187         'commands': {
 188             'remove_comment': [comment.id],
 189         }
 190     }
 191
 192 @command
 193 def mark_favorite(request, id):
 194     question = get_object_or_404(Question, id=id)
 195
 196     if not request.user.is_authenticated():
 197         raise AnonymousNotAllowedException(_('mark a question as favorite'))
 198
 199     try:
 200         favorite = FavoriteQuestion.objects.get(question=question, user=request.user)
 201         favorite.delete()
 202         added = False
 203     except ObjectDoesNotExist:
 204         favorite = FavoriteQuestion(question=question, user=request.user)
 205         favorite.save()
 206         added = True
 207
 208     return {
 209         'commands': {
 210             'update_favorite_count': [added and 1 or -1],
 211             'update_favorite_mark': [added and 'on' or 'off']
 212         }
 213     }
 214
 215 @command
 216 def comment(request, id):
 217     post = get_object_or_404(Node, id=id)
 218     user = request.user
 219
 220     if not user.is_authenticated():
 221         raise AnonymousNotAllowedException(_('comment'))
 222
 223     if not request.method == 'POST':
 224         raise Exception(_("Invalid request"))
 225
 226     if 'id' in request.POST:
 227         comment = get_object_or_404(Comment, id=request.POST['id'])
 228
 229         if not user.can_edit_comment(comment):
 230             raise NotEnoughRepPointsException( _('edit comments'))
 231     else:
 232         if not user.can_comment(post):
 233             raise NotEnoughRepPointsException( _('comment'))
 234
 235         comment = Comment(parent=post)
 236
 237     comment_text = request.POST.get('comment', '').strip()
 238
 239     if not len(comment_text):
 240         raise Exception(_("Comment is empty"))
 241
 242     if not len(comment_text) > settings.FORM_MIN_COMMENT_BODY:
 243         raise Exception(_("Comment must be at least %s characters" % settings.FORM_MIN_COMMENT_BODY))
 244
 245     comment.create_revision(user, body=comment_text)
 246
 247     if comment.active_revision.revision == 1:
 248         return {
 249             'commands': {
 250                 'insert_comment': [
 251                     id, comment.id, comment_text, user.username, user.get_profile_url(), reverse('delete_comment', kwargs={'id': comment.id})
 252                 ]
 253             }
 254         }
 255     else:
 256         return {
 257             'commands': {
 258                 'update_comment': [comment.id, comment.comment]
 259             }
 260         }
 261
 262
 263 @command
 264 def accept_answer(request, id):
 265     user = request.user
 266
 267     if not user.is_authenticated():
 268         raise AnonymousNotAllowedException(_('accept answers'))
 269
 270     answer = get_object_or_404(Answer, id=id)
 271     question = answer.question
 272
 273     if not user.can_accept_answer(answer):
 274         raise Exception(_("Sorry but only the question author can accept an answer"))
 275
 276     commands = {}
 277
 278     if answer.accepted:
 279         answer.unmark_accepted(user)
 280         commands['unmark_accepted'] = [answer.id]
 281     else:
 282         if question.accepted_answer is not None:
 283             accepted = question.accepted_answer
 284             accepted.unmark_accepted(user)
 285             commands['unmark_accepted'] = [accepted.id]
 286
 287         answer.mark_accepted(user)
 288         commands['mark_accepted'] = [answer.id]
 289
 290     return {'commands': commands}
 291
 292 @command
 293 def delete_post(request, id):
 294     post = get_object_or_404(Node, id=id)
 295     user = request.user
 296
 297     if not user.is_authenticated():
 298         raise AnonymousNotAllowedException(_('delete posts'))
 299
 300     if not (user.can_delete_post(post)):
 301         raise NotEnoughRepPointsException(_('delete posts'))
 302
 303     post.mark_deleted(user)
 304
 305     return {
 306         'commands': {
 307                 'mark_deleted': [post.node_type, id]
 308             }
 309     }
 310
 311 @command
 312 def subscribe(request, id):
 313     question = get_object_or_404(Question, id=id)
 314
 315     try:
 316         subscription = QuestionSubscription.objects.get(question=question, user=request.user)
 317         subscription.delete()
 318         subscribed = False
 319     except:
 320         subscription = QuestionSubscription(question=question, user=request.user, auto_subscription=False)
 321         subscription.save()
 322         subscribed = True
 323
 324     return {
 325         'commands': {
 326                 'set_subscription_button': [subscribed and _('unsubscribe me') or _('subscribe me')],
 327                 'set_subscription_status': ['']
 328             }
 329     }
 330
 331 #internally grouped views - used by the tagging system
 332 @ajax_login_required
 333 def mark_tag(request, tag=None, **kwargs):#tagging system
 334     action = kwargs['action']
 335     ts = MarkedTag.objects.filter(user=request.user, tag__name=tag)
 336     if action == 'remove':
 337         logging.debug('deleting tag %s' % tag)
 338         ts.delete()
 339     else:
 340         reason = kwargs['reason']
 341         if len(ts) == 0:
 342             try:
 343                 t = Tag.objects.get(name=tag)
 344                 mt = MarkedTag(user=request.user, reason=reason, tag=t)
 345                 mt.save()
 346             except:
 347                 pass
 348         else:
 349             ts.update(reason=reason)
 350     return HttpResponse(simplejson.dumps(''), mimetype="application/json")
 351
 352 def matching_tags(request):
 353     if len(request.GET['q']) == 0:
 354        raise Exception(_("Invalid request"))
 355
 356     possible_tags = Tag.objects.filter(name__istartswith = request.GET['q'])
 357     tag_output = ''
 358     for tag in possible_tags:
 359         tag_output += (tag.name + "|" + tag.name + "." + tag.used_count.__str__() + "\n")
 360
 361     return HttpResponse(tag_output, mimetype="text/plain")
 362
 363 @ajax_login_required
 364 def ajax_toggle_ignored_questions(request):#ajax tagging and tag-filtering system
 365     if request.user.hide_ignored_questions:
 366         new_hide_setting = False
 367     else:
 368         new_hide_setting = True
 369     request.user.hide_ignored_questions = new_hide_setting
 370     request.user.save()
 371
 372 @ajax_method
 373 def ajax_command(request):#refactor? view processing ajax commands - note "vote" and view others do it too
 374     if 'command' not in request.POST:
 375         return HttpResponseForbidden(mimetype="application/json")
 376     if request.POST['command'] == 'toggle-ignored-questions':
 377         return ajax_toggle_ignored_questions(request)
 378
 379 @login_required
 380 def close(request, id):#close question
 381     """view to initiate and process
 382     question close
 383     """
 384     question = get_object_or_404(Question, id=id)
 385     if not request.user.can_close_question(question):
 386         return HttpResponseForbidden()
 387     if request.method == 'POST':
 388         form = CloseForm(request.POST)
 389         if form.is_valid():
 390             reason = form.cleaned_data['reason']
 391             question.closed = True
 392             question.closed_by = request.user
 393             question.closed_at = datetime.datetime.now()
 394             question.close_reason = reason
 395             question.save()
 396         return HttpResponseRedirect(question.get_absolute_url())
 397     else:
 398         form = CloseForm()
 399         return render_to_response('close.html', {
 400             'form' : form,
 401             'question' : question,
 402             }, context_instance=RequestContext(request))
 403
 404 @login_required
 405 def reopen(request, id):#re-open question
 406     """view to initiate and process
 407     question close
 408     """
 409     question = get_object_or_404(Question, id=id)
 410     # open question
 411     if not request.user.can_reopen_question(question):
 412         return HttpResponseForbidden()
 413     if request.method == 'POST' :
 414         Question.objects.filter(id=question.id).update(closed=False,
 415             closed_by=None, closed_at=None, close_reason=None)
 416         return HttpResponseRedirect(question.get_absolute_url())
 417     else:
 418         return render_to_response('reopen.html', {
 419             'question' : question,
 420             }, context_instance=RequestContext(request))
 421
 422 #osqa-user communication system
 423 def read_message(request):#marks message a read
 424     if request.method == "POST":
 425         if request.POST['formdata'] == 'required':
 426             request.session['message_silent'] = 1
 427             if request.user.is_authenticated():
 428                 request.user.delete_messages()
 429     return HttpResponse('')
 430
 431