Post new reply

misago/apps/threads/posting.py

@@ -9,11 +9,8 @@ from misago.apps.threads.mixins import TypeMixin
 class NewThreadView(NewThreadBaseView, TypeMixin):
     action = 'new_thread'
 
-    def set_context(self):
+    def set_forum_context(self):
         self.forum = Forum.objects.get(pk=self.kwargs.get('forum'), type='forum')
-        self.request.acl.forums.allow_forum_view(self.forum)
-        self.proxy = Forum.objects.parents_aware_forum(self.forum)
-        self.request.acl.threads.allow_new_threads(self.proxy)
 
     def response(self):
         if self.post.moderated:
@@ -25,16 +22,6 @@ class NewThreadView(NewThreadBaseView, TypeMixin):
 
 class EditThreadView(EditThreadBaseView, TypeMixin):
     action = 'edit_thread'
-
-    def set_context(self):
-        self.thread = Thread.objects.get(pk=self.kwargs.get('thread'))
-        self.forum = self.thread.forum
-        self.proxy = Forum.objects.parents_aware_forum(self.forum)
-        self.request.acl.forums.allow_forum_view(self.forum)
-        self.request.acl.threads.allow_thread_view(self.request.user, self.thread)
-        self.post = self.thread.start_post
-        self.request.acl.threads.allow_post_view(self.request.user, self.thread, self.post)
-        self.request.acl.threads.allow_thread_edit(self.request.user, self.proxy, self.thread, self.post)
     
     def response(self):
         self.request.messages.set_flash(Message(_("Your thread has been edited.")), 'success', 'threads_%s' % self.post.pk)
@@ -44,15 +31,12 @@ class EditThreadView(EditThreadBaseView, TypeMixin):
 class NewReplyView(NewReplyBaseView, TypeMixin):
     action = 'new_reply'
 
-    def set_context(self):
-        pass
-
     def response(self):
         if self.post.moderated:
-            request.messages.set_flash(Message(_("Your reply has been posted. It will be hidden from other members until moderator reviews it.")), 'success', 'threads_%s' % self.post.pk)
+            self.request.messages.set_flash(Message(_("Your reply has been posted. It will be hidden from other members until moderator reviews it.")), 'success', 'threads_%s' % self.post.pk)
         else:
-            request.messages.set_flash(Message(_("Your reply has been posted.")), 'success', 'threads_%s' % self.post.pk)
-        return self.redirect_to_post(post)
+            self.request.messages.set_flash(Message(_("Your reply has been posted.")), 'success', 'threads_%s' % self.post.pk)
+        return self.redirect_to_post(self.post)
 
 
 class EditReplyView(EditReplyBaseView, TypeMixin):

misago/apps/threadtype/base.py

@@ -1,5 +1,6 @@
 from django.core.urlresolvers import reverse
 from django.shortcuts import redirect
+from misago.models import Forum, Thread, Post
 from misago.utils.pagination import make_pagination
 
 class ViewBase(object):
@@ -7,6 +8,19 @@ class ViewBase(object):
         obj = super(ViewBase, cls).__new__(cls)
         return obj(request, **kwargs)
         
+    def set_forum_context(self):
+        pass
+
+    def set_thread_context(self):
+        self.thread = Thread.objects.get(pk=self.kwargs.get('thread'))
+        self.forum = self.thread.forum
+        self.proxy = Forum.objects.parents_aware_forum(self.forum)
+        self.request.acl.forums.allow_forum_view(self.forum)
+        self.request.acl.threads.allow_thread_view(self.request.user, self.thread)
+
+    def set_post_contex(self):
+        pass
+
     def redirect_to_post(self, post):
         pagination = make_pagination(0, self.request.acl.threads.filter_posts(self.request, self.thread, self.thread.post_set).filter(id__lte=post.pk).count(), self.request.settings.posts_per_page)
         if pagination['total'] > 1:

misago/apps/threadtype/mixins.py

@@ -19,3 +19,15 @@ class ValidateThreadNameMixin(object):
                                                   self.request.settings['thread_name_max']
                                                   ) % {'count': self.request.settings['thread_name_max']})
         return data
+
+
+class ValidatePostLengthMixin(object):
+    def clean_post(self):
+        data = self.cleaned_data['post']
+        if len(data) < self.request.settings['post_length_min']:
+            raise forms.ValidationError(ungettext(
+                                                  "Post content cannot be empty.",
+                                                  "Post content cannot be shorter than %(count)d characters.",
+                                                  self.request.settings['post_length_min']
+                                                  ) % {'count': self.request.settings['post_length_min']})
+        return data

misago/apps/threadtype/posting/base.py

@@ -5,10 +5,13 @@ from misago.apps.errors import error403, error404
 from misago.forms import FormLayout
 from misago.markdown import post_markdown
 from misago.messages import Message
-from misago.models import Forum, WatchedThread
+from misago.models import Forum, Thread, WatchedThread
 from misago.apps.threadtype.base import ViewBase
+from misago.apps.threadtype.thread.forms import QuickReplyForm
 
 class PostingBaseView(ViewBase):
+    allow_quick_reply = False
+
     def form_initial_data(self):
         return {}
 
@@ -36,6 +39,16 @@ class PostingBaseView(ViewBase):
                                     post_content=old_post,
                                     )
 
+    def notify_users(self):
+        try:
+            if self.quote and self.quote.user_id:
+                del self.md.mentions[self.quote.user.username_slug]
+        except KeyError:
+            pass
+        if self.md.mentions:
+            self.post.notify_mentioned(self.request, self.md.mentions)
+            self.post.save(force_update=True)
+
     def watch_thread(self):
         if self.request.user.subscribe_start:
             try:
@@ -60,15 +73,22 @@ class PostingBaseView(ViewBase):
         self.message = request.messages.get_message('threads')
 
         post_preview = ''
+        form = None
 
         try:
             self._set_context()
             if request.method == 'POST':
-                try:
-                    form = self.form_type(request.POST, request.FILE, request=request, forum=self.forum, thread=self.thread)
-                except AttributeError:
-                    form = self.form_type(request.POST, request=request, forum=self.forum, thread=self.thread)
-
+                # Create correct form instance
+                if self.allow_quick_reply and 'quick_reply' in request.POST:
+                    form = QuickReplyForm(request.POST, request=request)
+                if not form or 'preview' in request.POST or not form.is_valid():
+                    # Override "quick reply" form with full one
+                    try:
+                        form = self.form_type(request.POST, request.FILE, request=request, forum=self.forum, thread=self.thread)
+                    except AttributeError:
+                        form = self.form_type(request.POST, request=request, forum=self.forum, thread=self.thread)
+                
+                # Handle specific submit
                 if 'preview' in request.POST:
                     form.empty_errors()
                     if form['post'].value():
@@ -79,9 +99,10 @@ class PostingBaseView(ViewBase):
                     if form.is_valid():
                         self.post_form(form)
                         self.watch_thread()
+                        self.notify_users()
                         return self.response()
                     else:
-                        message = Message(form.non_field_errors()[0], 'error')
+                        self.message = Message(form.non_field_errors()[0], 'error')
             else:
                 form = self.form_type(request=request, forum=self.forum, thread=self.thread, initial=self.form_initial_data())
         except Forum.DoesNotExist:

misago/apps/threadtype/posting/editthread.py

@@ -1,18 +1,18 @@
-from datetime import timedelta
-from django.core.urlresolvers import reverse
-from django.shortcuts import redirect
 from django.utils import timezone
-from django.utils.translation import ugettext as _
 from misago.apps.threadtype.posting.base import PostingBaseView
 from misago.apps.threadtype.posting.forms import EditThreadForm
 from misago.markdown import post_markdown
-from misago.messages import Message
-from misago.models import Forum, Thread, Post
 from misago.utils.strings import slugify
 
 class EditThreadBaseView(PostingBaseView):
     form_type = EditThreadForm
 
+    def set_context(self):
+        self.set_thread_context()
+        self.post = self.thread.start_post
+        self.request.acl.threads.allow_post_view(self.request.user, self.thread, self.post)
+        self.request.acl.threads.allow_thread_edit(self.request.user, self.proxy, self.thread, self.post)
+        
     def form_initial_data(self):
         return {
                 'thread_name': self.thread.name,

misago/apps/threadtype/posting/forms.py

@@ -1,11 +1,11 @@
 from django import forms
 from django.conf import settings
 from django.utils.translation import ugettext_lazy as _
-from misago.apps.threadtype.mixins import ValidateThreadNameMixin
+from misago.apps.threadtype.mixins import ValidateThreadNameMixin, ValidatePostLengthMixin
 from misago.forms import Form
 from misago.validators import validate_sluggable
 
-class PostingForm(Form):
+class PostingForm(Form, ValidatePostLengthMixin):
     post = forms.CharField(widget=forms.Textarea)
 
     def __init__(self, data=None, file=None, request=None, forum=None, thread=None, *args, **kwargs):
@@ -13,7 +13,16 @@ class PostingForm(Form):
         self.thread = thread
         super(PostingForm, self).__init__(data, file, request=request, *args, **kwargs)
 
-    def set_extra_fields(self):
+    def finalize_form(self):
+        self.layout = [
+                       [
+                        None,
+                        [
+                         ('post', {'label': _("Post Content")}),
+                         ]
+                        ]
+                       ]
+
         # Can we change threads states?
         if (self.request.acl.threads.can_pin_threads(self.forum) >= self.thread.weight and
                 self.request.acl.threads.can_pin_threads(self.forum)):
@@ -24,35 +33,37 @@ class PostingForm(Form):
             thread_weight.append((0, _("Standard")))
             if thread_weight:
                 self.layout[0][1].append(('thread_weight', {'label': _("Thread Importance")}))
-                self.fields['thread_weight'] = forms.TypedChoiceField(widget=forms.RadioSelect, choices=thread_weight, coerce=int, initial=0)
+                self.fields['thread_weight'] = forms.TypedChoiceField(widget=forms.RadioSelect,
+                                                                      choices=thread_weight,
+                                                                      required=False,
+                                                                      coerce=int,
+                                                                      initial=(self.thread.weight if self.thread else 0))
 
         # Can we lock threads?
         if self.request.acl.threads.can_close(self.forum):
             self.fields['close_thread'] = forms.BooleanField(required=False)
             if self.thread and self.thread.closed:
-                self.layout[0][1].append(('close_thread', {'label': 'NOEZ', 'inline': _("Open Thread")}))
+                self.layout[0][1].append(('close_thread', {'inline': _("Open Thread")}))
             else:
-                self.layout[0][1].append(('close_thread', {'label': 'BALLS', 'inline': _("Close Thread")}))
+                self.layout[0][1].append(('close_thread', {'inline': _("Close Thread")}))
+
+    def clean_thread_weight(self):
+        data = self.cleaned_data['thread_weight']
+        if not data:
+            if self.thread:
+                return self.thread.weight
+            return 0
+        return data
 
 
 class NewThreadForm(PostingForm, ValidateThreadNameMixin):
     def finalize_form(self):
-        self.layout = [
-                       [
-                        None,
-                        [
-                         ('thread_name', {'label': _("Thread Name")}),
-                         ('post', {'label': _("Post Content")}),
-                         ]
-                        ]
-                       ]
-
+        super(NewThreadForm, self).finalize_form()
+        self.layout[0][1].append(('thread_name', {'label': _("Thread Name")}))
         self.fields['thread_name'] = forms.CharField(max_length=self.request.settings['thread_name_max'],
                                                      validators=[validate_sluggable(_("Thread name must contain at least one alpha-numeric character."),
                                                                                     _("Thread name is too long. Try shorter name."))])
 
-        self.set_extra_fields()
-
 
 class EditThreadForm(NewThreadForm, ValidateThreadNameMixin):
     def finalize_form(self):
@@ -60,3 +71,13 @@ class EditThreadForm(NewThreadForm, ValidateThreadNameMixin):
         self.fields['edit_reason'] = forms.CharField(max_length=255, required=False, help_text=_("Optional reason for editing this thread."))
         self.layout[0][1].append(('edit_reason', {'label': _("Edit Reason")}))
 
+
+class NewReplyForm(PostingForm):
+    pass
+
+
+class EditReplyForm(PostingForm):
+    def finalize_form(self):
+        super(EditThreadForm, self).finalize_form()
+        self.fields['edit_reason'] = forms.CharField(max_length=255, required=False, help_text=_("Optional reason for editing this reply."))
+        self.layout[0][1].append(('edit_reason', {'label': _("Edit Reason")}))

misago/apps/threadtype/posting/newreply.py

@@ -1,2 +1,135 @@
-class NewReplyBaseView(object):
-    pass
+from datetime import timedelta
+from django.utils import timezone
+from django.utils.translation import ugettext as _
+from misago.markdown import post_markdown
+from misago.models import Post
+from misago.utils.datesformats import date
+from misago.utils.translation import ugettext_lazy
+from misago.apps.threadtype.posting.base import PostingBaseView
+from misago.apps.threadtype.posting.forms import NewReplyForm
+
+class NewReplyBaseView(PostingBaseView):
+    allow_quick_reply = True
+    form_type = NewReplyForm
+
+    def set_context(self):
+        self.set_thread_context()
+        self.request.acl.threads.allow_reply(self.proxy, self.thread)
+        if self.kwargs.get('quote'):
+            self.quote = Post.objects.get(id=self.kwargs.get('quote'))
+            self.request.acl.threads.allow_post_view(self.request.user, self.thread, self.quote)
+
+    def form_initial_data(self):
+        if self.quote:
+            quote_post = []
+            if self.quote.user:
+                quote_post.append('@%s' % self.quote.user.username)
+            else:
+                quote_post.append('@%s' % self.quote.user_name)
+            for line in self.quote.post.splitlines():
+                quote_post.append('> %s' % line)
+            quote_post.append('\r\n')
+            return {'post': '\r\n'.join(quote_post)}
+        return {}
+
+    def post_form(self, form):
+        now = timezone.now()
+        moderation = (not self.request.acl.threads.acl[self.forum.pk]['can_approve']
+                      and self.request.acl.threads.acl[self.forum.pk]['can_start_threads'] == 1)
+
+        self.thread.previous_last = self.thread.last
+        self.md, post_preparsed = post_markdown(self.request, form.cleaned_data['post'])
+
+        # Count merge diff and see if we are merging
+        merge_diff = (now - self.thread.last)
+        merge_diff = (merge_diff.days * 86400) + merge_diff.seconds
+        if (self.request.settings.post_merge_time
+                and merge_diff < (self.request.settings.post_merge_time * 60)
+                and self.thread.last_poster_id == self.request.user.id
+                and self.thread.last_post.moderated == moderation):
+            merged = True
+            self.post = self.thread.last_post
+            self.post.date = now
+            self.post.post = '%s\n\n- - -\n**%s**\n%s' % (self.post.post, _("Added on %(date)s:") % {'date': date(now, 'SHORT_DATETIME_FORMAT')}, form.cleaned_data['post'])
+            self.md, self.post.post_preparsed = post_markdown(self.request, self.post.post)
+            self.post.save(force_update=True)
+        else:
+            # Create new post
+            merged = False
+            self.post = Post.objects.create(
+                                            forum=self.forum,
+                                            thread=self.thread,
+                                            user=self.request.user,
+                                            user_name=self.request.user.username,
+                                            ip=self.request.session.get_ip(self.request),
+                                            agent=self.request.META.get('HTTP_USER_AGENT'),
+                                            post=form.cleaned_data['post'],
+                                            post_preparsed=post_preparsed,
+                                            date=now,
+                                            merge=self.thread.merges,
+                                            moderated=moderation,
+                                        )
+
+        # Update thread data and score?
+        if not merged:
+            if not moderation:
+                self.thread.new_last_post(self.post)
+                self.thread.replies += 1
+            else:
+                self.thread.replies_moderated += 1
+
+            # Increase thread score
+            if self.thread.last_poster_id != self.request.user.pk:
+                self.thread.score += self.request.settings['thread_ranking_reply_score']
+
+        # Set thread status
+        if 'close_thread' in form.cleaned_data:
+            self.thread.closed = form.cleaned_data['close_thread']
+        if 'thread_weight' in form.cleaned_data:
+            self.thread.weight = form.cleaned_data['thread_weight']
+
+        # Save updated thread
+        self.thread.save(force_update=True)
+
+        # Update forum and monitor
+        if not moderation and not merged:
+            self.request.monitor['posts'] = int(self.request.monitor['posts']) + 1
+            self.forum.posts += 1
+            self.forum.new_last_thread(self.thread)
+            self.forum.save(force_update=True)
+        
+        # Reward user for posting new reply?
+        if not moderation and not merged and (not self.request.user.last_post
+                or self.request.user.last_post < timezone.now() - timedelta(seconds=self.request.settings['score_reward_new_post_cooldown'])):
+            self.request.user.score += self.request.settings['score_reward_new_post']
+
+        # Update user
+        if not moderation and not merged:
+            self.request.user.threads += 1
+            self.request.user.posts += 1
+        self.request.user.last_post = now
+        self.request.user.save(force_update=True)
+
+        # Set "closed" checkpoint, either due to thread limit or posters wish
+        if (self.request.settings.thread_length > 0
+                and not merged and not moderation and not self.thread.closed
+                and self.thread.replies >= self.request.settings.thread_length):
+            self.thread.closed = True
+            self.post.set_checkpoint(self.request, 'limit')
+        elif 'close_thread' in form.cleaned_data and form.cleaned_data['close_thread']:
+            if self.thread.closed:
+                self.thread.last_post.set_checkpoint(self.request, 'closed')
+            else:
+                self.thread.last_post.set_checkpoint(self.request, 'opened')
+
+        # Notify user we quoted?
+        if (self.quote and self.quote.user_id and not merged
+                and self.quote.user_id != self.request.user.pk
+                and not self.quote.user.is_ignoring(self.request.user)):
+            alert = self.quote.user.alert(ugettext_lazy("%(username)s has replied to your post in thread %(thread)s").message)
+            alert.profile('username', self.request.user)
+            alert.post('thread', self.thread, self.post)
+            alert.save_all()
+
+        # E-mail users about new response
+        self.thread.email_watchers(self.request, self.post)

misago/apps/threadtype/posting/newthread.py

@@ -1,18 +1,20 @@
 from datetime import timedelta
-from django.core.urlresolvers import reverse
-from django.shortcuts import redirect
 from django.utils import timezone
-from django.utils.translation import ugettext as _
 from misago.apps.threadtype.posting.base import PostingBaseView
 from misago.apps.threadtype.posting.forms import NewThreadForm
 from misago.markdown import post_markdown
-from misago.messages import Message
 from misago.models import Forum, Thread, Post
 from misago.utils.strings import slugify
 
 class NewThreadBaseView(PostingBaseView):
     form_type = NewThreadForm
 
+    def set_context(self):
+        self.set_forum_context()
+        self.request.acl.forums.allow_forum_view(self.forum)
+        self.proxy = Forum.objects.parents_aware_forum(self.forum)
+        self.request.acl.threads.allow_new_threads(self.proxy)
+
     def post_form(self, form):
         now = timezone.now()
         moderation = (not self.request.acl.threads.acl[self.forum.pk]['can_approve']
@@ -27,8 +29,6 @@ class NewThreadBaseView(PostingBaseView):
                                             last=now,
                                             moderated=moderation,
                                             score=self.request.settings['thread_ranking_initial_score'],
-                                            replies=1,
-                                            replies_moderated=int(moderation),
                                             )
 
         # Create our post
@@ -59,11 +59,6 @@ class NewThreadBaseView(PostingBaseView):
         # Finally save complete thread
         self.thread.save(force_update=True)
 
-        # Reward user for posting new thread?
-        if (not self.request.user.last_post
-                or self.request.user.last_post < timezone.now() - timedelta(seconds=self.request.settings['score_reward_new_post_cooldown'])):
-            self.request.user.score += self.request.settings['score_reward_new_thread']
-
         # Update forum monitor
         if not moderation:
             self.request.monitor['threads'] = int(self.request.monitor['threads']) + 1
@@ -73,12 +68,17 @@ class NewThreadBaseView(PostingBaseView):
             self.forum.new_last_thread(self.thread)
             self.forum.save(force_update=True)
 
+        # Reward user for posting new thread?
+        if not moderation and (not self.request.user.last_post
+                or self.request.user.last_post < timezone.now() - timedelta(seconds=self.request.settings['score_reward_new_post_cooldown'])):
+            self.request.user.score += self.request.settings['score_reward_new_thread']
+
         # Update user
         if not moderation:
             self.request.user.threads += 1
             self.request.user.posts += 1
-            self.request.user.last_post = now
-            self.request.user.save(force_update=True)
+        self.request.user.last_post = now
+        self.request.user.save(force_update=True)
 
         # Notify mentioned
         if md.mentions:

misago/apps/threadtype/thread/forms.py

@@ -1,5 +1,6 @@
 from django import forms
 from misago.forms import Form
+from misago.apps.threadtype.mixins import ValidatePostLengthMixin
 
-class QuickReplyForm(Form):
+class QuickReplyForm(Form, ValidatePostLengthMixin):
     post = forms.CharField(widget=forms.Textarea)

misago/apps/threadtype/thread/views.py

@@ -3,6 +3,7 @@ from django.core.urlresolvers import reverse
 from django.forms import ValidationError
 from django.shortcuts import redirect
 from django.template import RequestContext
+from django.utils import timezone
 from django.utils.translation import ugettext as _
 from misago.acl.exceptions import ACLError403, ACLError404
 from misago.apps.errors import error403, error404

misago/forms/forms.py

@@ -13,14 +13,18 @@ class Form(forms.Form):
     error_source = None
 
     def __init__(self, data=None, file=None, request=None, *args, **kwargs):
+        self.form_finalized = False
         self.request = request
 
-        # Extract request from first argument
+        # Extract request from first arguments
         if data != None:
             super(Form, self).__init__(data, file, *args, **kwargs)
         else:
             super(Form, self).__init__(*args, **kwargs)
 
+        # Let forms do mumbo-jumbo with fields removing
+        self.ensure_finalization()
+
         # Kill captcha fields
         try:
             if self.request.settings['bots_registration'] != 'recaptcha' or self.request.session.get('captcha_passed'):
@@ -37,8 +41,10 @@ class Form(forms.Form):
         except KeyError:
             pass
 
-        # Let forms do mumbo-jumbo with fields removing
-        self.finalize_form()
+    def ensure_finalization(self):
+        if not self.form_finalized:
+            self.form_finalized = True
+            self.finalize_form()
 
     def finalize_form(self):
         pass
@@ -47,6 +53,7 @@ class Form(forms.Form):
         """
         Trim inputs and strip newlines
         """
+        self.ensure_finalization()
         self.data = self.data.copy()
         for key, field in self.fields.iteritems():
             try:

misago/forms/layouts.py

@@ -18,7 +18,6 @@ class FormLayout(object):
             self.fields = {}
             for fieldset in self.fieldsets:
                 for field in fieldset['fields']:
-                    print field['id']
                     self.fields[field['id']] = field
         else:
             self.fields = scaffold_fields.fields

misago/models/threadmodel.py

@@ -148,7 +148,7 @@ class Thread(models.Model):
     def email_watchers(self, request, post):
         from misago.acl.builder import acl
         from misago.acl.exceptions import ACLError403, ACLError404
-        from misago.models import ThreadRead
+        from misago.models import ThreadRead, WatchedThread
 
         for watch in WatchedThread.objects.filter(thread=self).filter(email=True).filter(last_read__gte=self.previous_last):
             user = watch.user

templates/cranefly/threads/posting.html

@@ -13,6 +13,7 @@
 {% for parent in parents %}
 <li><a href="{{ parent.type|url(forum=parent.pk, slug=parent.slug) }}">{{ parent.name }}</a> <span class="divider"><i class="icon-chevron-right"></i></span></li>
 {% endfor %}
+<li><a href="{{ forum.type|url(forum=forum.pk, slug=forum.slug) }}">{{ forum.name }}</a> <span class="divider"><i class="icon-chevron-right"></i></span></li>
 {% if thread %}<li><a href="{% url 'thread' thread=thread.pk, slug=thread.slug %}">{{ thread.name }}</a> <span class="divider"><i class="icon-chevron-right"></i></span></li>{% endif %}
 <li class="active">{{ get_title() }}
 {%- endblock %}
@@ -135,16 +136,16 @@
 {% trans %}Post New Thread{% endtrans %}
 {%- elif action == 'edit_thread' -%}
 {% trans %}Edit Thread{% endtrans %}
-{%- elif action in ['new_post', 'new_post_quick'] -%}
+{%- elif action == 'new_reply' -%}
 {% trans %}Post New Reply{% endtrans %}
-{%- elif action == 'edit_post' -%}
+{%- elif action == 'edit_reply' -%}
 {% trans %}Edit Reply{% endtrans %}
 {%- endif %}
 {%- endmacro %}
 
 
 {% macro get_info() -%}
-{% if mode == 'edit_post' -%}
+{% if action == 'edit_reply' -%}
     {% if post.moderated %}<li><i class="icon-eye-close"></i> {% trans %}Not Reviewed{% endtrans %}</li>{% endif %}
     <li><i class="icon-time"></i> {{ post.date|reltimesince }}</li>
     <li><i class="icon-user"></i> {% if post.user %}<a href="{% url 'user' user=post.user.pk, username=post.user.username_slug %}">{{ post.user.username }}</a>{% else %}{{ post.user_name }}{% endif %}</li>
@@ -167,9 +168,9 @@
 
 
 {% macro get_button() -%}
-{% if mode == 'new_thread' -%}
+{% if action == 'new_thread' -%}
 {% trans %}Post Thread{% endtrans %}
-{%- elif mode in ['new_post', 'new_post_quick'] -%}
+{%- elif action == 'new_reply' -%}
 {% trans %}Post Reply{% endtrans %}
 {%- else -%}
 {% trans %}Save Changes{% endtrans %}