It's now possible to start new threads.

misago/acl/permissions/threads.py

@@ -121,7 +121,6 @@ def make_forum_form(request, role, form):
                          ('can_approve', {'label': _("Can accept threads and posts")}),
                          ('can_edit_labels', {'label': _("Can edit thread labels")}),
                          ('can_see_changelog', {'label': _("Can see edits history")}),
-                         ('can_make_announcements', {'label': _("Can make announcements")}),
                          ('can_pin_threads', {'label': _("Can change threads weight")}),
                          ('can_edit_threads_posts', {'label': _("Can edit threads and posts")}),
                          ('can_move_threads_posts', {'label': _("Can move, merge and split threads and posts")}),
@@ -384,6 +383,13 @@ class ThreadsACL(BaseACL):
         except KeyError:
             return False
 
+    def can_close(self, forum):
+        try:
+            forum_role = self.acl[forum.pk]
+            return forum_role['can_close_threads']
+        except KeyError:
+            return False
+
     def can_protect(self, forum):
         try:
             forum_role = self.acl[forum.pk]
@@ -391,6 +397,13 @@ class ThreadsACL(BaseACL):
         except KeyError:
             return False
 
+    def can_pin_threads(self, forum):
+        try:
+            forum_role = self.acl[forum.pk]
+            return forum_role['can_pin_threads']
+        except KeyError:
+            return False
+
     def can_delete_thread(self, user, forum, thread, post):
         try:
             forum_role = self.acl[forum.pk]
@@ -560,7 +573,6 @@ def build_forums(acl, perms, forums, forum_roles):
                      'can_approve': False,
                      'can_edit_labels': False,
                      'can_see_changelog': False,
-                     'can_make_announcements': False,
                      'can_pin_threads': 0,
                      'can_edit_threads_posts': False,
                      'can_move_threads_posts': False,

misago/apps/forumbase/mixins.py

@@ -1,6 +1,9 @@
 from django import forms
+from django.core.urlresolvers import reverse
+from django.shortcuts import redirect
 from django.utils.translation import ungettext
 from misago.utils.strings import slugify
+from misago.utils.pagination import make_pagination
 
 class ValidateThreadNameMixin(object):
     def clean_thread_name(self):
@@ -18,4 +21,12 @@ class ValidateThreadNameMixin(object):
                                                   "Thread name cannot be longer than %(count)d characters.",
                                                   self.request.settings['thread_name_max']
                                                   ) % {'count': self.request.settings['thread_name_max']})
-        return data
+        return data
+
+
+class RedirectToPostMixin(object):
+    def redirect_to_post(self, link, 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:
+            return redirect(reverse(link, kwargs={'thread': self.thread.pk, 'slug': self.thread.slug, 'page': pagination['total']}) + ('#post-%s' % post.pk))
+        return redirect(reverse(link, kwargs={'thread': self.thread.pk, 'slug': self.thread.slug}) + ('#post-%s' % post.pk))

misago/apps/forumbase/posting.py

@@ -0,0 +1,85 @@
+from django.template import RequestContext
+from django.utils import timezone
+from misago.acl.exceptions import ACLError403, ACLError404
+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
+
+class PostingBaseView(object):
+    def __new__(cls, request, **kwargs):
+        obj = super(PostingBaseView, cls).__new__(cls)
+        return obj(request, **kwargs)
+
+    def _set_context(self):
+        self.set_context()
+        if self.forum.level:
+            self.parents = Forum.objects.forum_parents(self.forum.pk)
+
+    def watch_thread(self):
+        if self.request.user.subscribe_start:
+            try:
+                WatchedThread.objects.get(user=self.request.user, thread=self.thread)
+            except WatchedThread.DoesNotExist:
+                WatchedThread.objects.create(
+                                           user=self.request.user,
+                                           forum=self.forum,
+                                           thread=self.thread,
+                                           last_read=timezone.now(),
+                                           email=(self.request.user.subscribe_start == 2),
+                                           )
+
+    def __call__(self, request, **kwargs):
+        self.request = request
+        self.kwargs = kwargs
+        self.forum = None
+        self.thread = None
+        self.quote = None
+        self.post = None
+        self.parents = []
+        self.message = request.messages.get_message('threads')
+
+        post_preview = ''
+
+        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)
+
+                if 'preview' in request.POST:
+                    form.empty_errors()
+                    if form['post'].value():
+                        md, post_preview = post_markdown(request, form['post'].value())
+                    else:
+                        md, post_preview = None, None
+                else:
+                    if form.is_valid():
+                        self.post_form(form)
+                    else:
+                        message = Message(form.non_field_errors()[0], 'error')
+            else:
+                form = self.form_type(request=request, forum=self.forum, thread=self.thread)
+        except Forum.DoesNotExist:
+            return error404(request)
+        except ACLError403 as e:
+            return error403(request, unicode(e))
+        except ACLError404 as e:
+            return error404(request, unicode(e))
+
+        return request.theme.render_to_response(('%s/posting.html' % self.templates_prefix),
+                                                {
+                                                 'action': self.action,
+                                                 'message': self.message,
+                                                 'forum': self.forum,
+                                                 'thread': self.thread,
+                                                 'quote': self.quote,
+                                                 'post': self.post,
+                                                 'parents': self.parents,
+                                                 'preview': post_preview,
+                                                 'form': FormLayout(form),
+                                                 },
+                                                context_instance=RequestContext(request));

misago/apps/oldthreads/views/posting.py

@@ -17,45 +17,6 @@ from misago.utils.translation import ugettext_lazy
 from misago.apps.threads.forms import PostForm
 from misago.apps.threads.views.base import BaseView
 
-class PostingBaseView(BaseView):
-    def __call__(self, request, **kwargs):
-        self.request = request
-
-        # Empty context attributes
-        self.forum = None
-        self.thread = None
-        self.quote = None
-        self.post = None
-
-        # Let inheriting class  set context
-        self.set_context()
-
-        # And set forum parents for render
-        self.parents = Forum.objects.forum_parents(self.forum.pk, True)
-
-        # Create form instance
-        
-
-    def set_context(self):
-        raise NotImplementedError(u"\"set_context\" method should be implemented in inheriting objects.")
-
-
-class PostingNewThreadView(PostingBaseView):
-    pass
-
-
-class PostingEditThreadView(PostingBaseView):
-    pass
-
-
-class PostingNewReplyView(PostingBaseView):
-    pass
-
-
-class PostingEditReplyView(PostingBaseView):
-    pass
-
-
 class PostingView(BaseView):
     def fetch_target(self, kwargs):
         if self.mode == 'new_thread':
@@ -198,7 +159,7 @@ class PostingView(BaseView):
                     if self.mode == 'edit_thread':
                         thread.name = form.cleaned_data['thread_name']
                         thread.slug = slugify(form.cleaned_data['thread_name'])
-                thread.previous_last = thread.last 
+                thread.previous_last = thread.last
 
                 # Create new message
                 if self.mode in ['new_thread', 'new_post', 'new_post_quick']:

misago/apps/threads/posting/__init__.py

@@ -0,0 +1,4 @@
+from misago.apps.threads.posting.newthread import NewThreadView
+from misago.apps.threads.posting.editthread import EditThreadView
+from misago.apps.threads.posting.newreply import NewReplyView
+from misago.apps.threads.posting.editreply import EditReplyView

misago/apps/threads/posting/editreply.py

@@ -0,0 +1,16 @@
+from django.core.urlresolvers import reverse
+from django.shortcuts import redirect
+from django.utils import timezone
+from django.utils.translation import ugettext as _
+from itertools import chain
+from misago.apps.forumbase.mixins import RedirectToPostMixin
+from misago.apps.forumbase.posting import PostingBaseView
+from misago.markdown import post_markdown
+from misago.messages import Message
+from misago.models import Forum, Thread, Post
+from misago.utils.strings import slugify
+from misago.apps.threads.forms import NewThreadForm
+from misago.apps.threads.mixins import TypeMixin
+
+class EditReplyView(PostingBaseView, TypeMixin, RedirectToPostMixin):
+    pass

misago/apps/threads/posting/editthread.py

@@ -0,0 +1,16 @@
+from django.core.urlresolvers import reverse
+from django.shortcuts import redirect
+from django.utils import timezone
+from django.utils.translation import ugettext as _
+from itertools import chain
+from misago.apps.forumbase.mixins import RedirectToPostMixin
+from misago.apps.forumbase.posting import PostingBaseView
+from misago.markdown import post_markdown
+from misago.messages import Message
+from misago.models import Forum, Thread, Post
+from misago.utils.strings import slugify
+from misago.apps.threads.forms import NewThreadForm
+from misago.apps.threads.mixins import TypeMixin
+
+class EditThreadView(PostingBaseView, TypeMixin, RedirectToPostMixin):
+    pass

misago/apps/threads/posting/forms.py

@@ -0,0 +1,54 @@
+from django import forms
+from django.utils.translation import ugettext_lazy as _
+from misago.apps.forumbase.mixins import ValidateThreadNameMixin
+from misago.forms import Form
+from misago.validators import validate_sluggable
+
+class PostingForm(Form):
+    post = forms.CharField(widget=forms.Textarea)
+
+    def __init__(self, data=None, file=None, request=None, forum=None, thread=None, *args, **kwargs):
+        self.forum = forum
+        self.thread = thread
+        super(PostingForm, self).__init__(data, file, request=request, *args, **kwargs)
+
+    def set_extra_fields(self):
+        # Can we change threads states?
+        if self.request.acl.threads.can_pin_threads(self.forum):
+            thread_weight = []
+            if (not self.thread or self.thread.weight < 2) and self.request.acl.threads.can_pin_threads(self.forum) == 2:
+                thread_weight.append((2, _("Announcement")))
+            if (not self.thread or self.thread.weight == 0) and self.request.acl.threads.can_pin_threads(self.forum):
+                thread_weight.append((1, _("Sticky")))
+            if (not self.thread or self.thread.weight != 0):
+                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)
+
+        # 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")}))
+            else:
+                self.layout[0][1].append(('close_thread', {'label': 'BALLS', 'inline': _("Close Thread")}))
+
+
+class NewThreadForm(PostingForm, ValidateThreadNameMixin):
+    def finalize_form(self):
+        self.layout = [
+                       [
+                        None,
+                        [
+                         ('thread_name', {'label': _("Thread Name")}),
+                         ('post', {'label': _("Post Content")}),
+                         ]
+                        ]
+                       ]
+
+        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()

misago/apps/threads/posting/newreply.py

@@ -0,0 +1,16 @@
+from django.core.urlresolvers import reverse
+from django.shortcuts import redirect
+from django.utils import timezone
+from django.utils.translation import ugettext as _
+from itertools import chain
+from misago.apps.forumbase.mixins import RedirectToPostMixin
+from misago.apps.forumbase.posting import PostingBaseView
+from misago.markdown import post_markdown
+from misago.messages import Message
+from misago.models import Forum, Thread, Post
+from misago.utils.strings import slugify
+from misago.apps.threads.forms import NewThreadForm
+from misago.apps.threads.mixins import TypeMixin
+
+class NewReplyView(PostingBaseView, TypeMixin, RedirectToPostMixin):
+    pass

misago/apps/threads/posting/newthread.py

@@ -0,0 +1,105 @@
+from django.core.urlresolvers import reverse
+from django.shortcuts import redirect
+from django.utils import timezone
+from django.utils.translation import ugettext as _
+from itertools import chain
+from misago.apps.forumbase.mixins import RedirectToPostMixin
+from misago.apps.forumbase.posting import PostingBaseView
+from misago.markdown import post_markdown
+from misago.messages import Message
+from misago.models import Forum, Thread, Post
+from misago.utils.strings import slugify
+from misago.apps.threads.forms import NewThreadForm
+from misago.apps.threads.mixins import TypeMixin
+
+class NewThreadView(PostingBaseView, TypeMixin, RedirectToPostMixin):
+    action = 'new_thread'
+    form_type = NewThreadForm
+
+    def set_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 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)
+
+        # Create empty thread
+        self.thread = Thread.objects.create(
+                                            forum=self.forum,
+                                            name=form.cleaned_data['thread_name'],
+                                            slug=slugify(form.cleaned_data['thread_name']),
+                                            start=now,
+                                            last=now,
+                                            moderated=moderation,
+                                            score=self.request.settings['thread_ranking_initial_score'],
+                                            replies=1,
+                                            replies_moderated=int(moderation),
+                                            )
+
+        # Create our post
+        md, post_preparsed = post_markdown(self.request, form.cleaned_data['post'])
+        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,
+                                        moderated=moderation,
+                                        )
+
+        # Update thread stats to contain this post
+        self.thread.new_start_post(self.post)
+        self.thread.new_last_post(self.post)
+
+        # Set thread status
+        if 'close_thread' in form.cleaned_data:
+            self.thread.closed = True
+        if 'thread_weight' in form.cleaned_data:
+            self.thread.weight = form.cleaned_data['thread_weight']
+
+        # 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
+            self.request.monitor['posts'] = int(self.request.monitor['posts']) + 1
+            self.forum.threads += 1
+            self.forum.posts += 1
+            self.forum.new_last_thread(self.thread)
+            self.forum.save(force_update=True)
+
+        # 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)
+
+        # Notify mentioned
+        if md.mentions:
+            self.post.notify_mentioned(self.request, md.mentions)
+            self.post.save(force_update=True)
+
+        # Set thread watch status
+        self.watch_thread()
+
+        # Set flash and redirect user to his post
+        if moderation:
+            self.request.messages.set_flash(Message(_("New thread has been posted. It will be hidden from other members until moderator reviews it.")), 'success', 'threads')
+        else:
+            self.request.messages.set_flash(Message(_("New thread has been posted.")), 'success', 'threads')
+        return redirect(reverse('thread', kwargs={'thread': self.thread.pk, 'slug': self.thread.slug}) + ('#post-%s' % self.post.pk))

misago/apps/threads/urls.py

@@ -1,12 +1,16 @@
 from django.conf.urls import patterns, url
 
-urlpatterns = patterns('misago.apps.threads.views',
-    url(r'^forum/(?P<slug>(\w|-)+)-(?P<forum>\d+)/$', 'ThreadsListView', name="forum"),
-    url(r'^forum/(?P<slug>(\w|-)+)-(?P<forum>\d+)/(?P<page>\d+)/$', 'ThreadsListView', name="forum"),
+urlpatterns = patterns('misago.apps.threads',
+    url(r'^forum/(?P<slug>(\w|-)+)-(?P<forum>\d+)/$', 'list.ThreadsListView', name="forum"),
+    url(r'^forum/(?P<slug>(\w|-)+)-(?P<forum>\d+)/(?P<page>\d+)/$', 'list.ThreadsListView', name="forum"),
+    url(r'^forum/(?P<slug>(\w|-)+)-(?P<forum>\d+)/new/$', 'posting.NewThreadView', name="thread_start"),
+    url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/edit/$', 'posting.EditThreadView', name="thread_edit"),
+    url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/reply/$', 'posting.NewReplyView', name="thread_reply"),
+    url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/(?P<quote>\d+)/reply/$', 'posting.NewReplyView', name="thread_reply"),
+    url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/(?P<post>\d+)/edit/$', 'posting.EditReplyView', name="post_edit"),
 )
 
 urlpatterns += patterns('misago.apps.errors',
-    url(r'^forum/(?P<slug>(\w|-)+)-(?P<forum>\d+)/new/$', 'error_not_implemented', name="thread_new"),
     url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/$', 'error_not_implemented', name="thread"),
     url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/last/$', 'error_not_implemented', name="thread_last"),
     url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/find-(?P<post>\d+)/$', 'error_not_implemented', name="thread_find"),
@@ -19,10 +23,7 @@ urlpatterns += patterns('misago.apps.errors',
     url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/unwatch/$', 'error_not_implemented', name="thread_unwatch"),
     url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/unwatch/email/$', 'error_not_implemented', name="thread_unwatch_email"),
     url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/(?P<page>\d+)/$', 'error_not_implemented', name="thread"),
-    url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/reply/$', 'error_not_implemented', name="thread_reply", kwargs={'mode': 'new_post'}),
     url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/(?P<quote>\d+)/reply/$', 'error_not_implemented', name="thread_reply"),
-    url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/edit/$', 'error_not_implemented', name="thread_edit"),
-    url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/(?P<post>\d+)/edit/$', 'error_not_implemented', name="post_edit"),
     url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/delete/$', 'error_not_implemented', name="thread_delete", kwargs={'mode': 'delete_thread'}),
     url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/hide/$', 'error_not_implemented', name="thread_hide", kwargs={'mode': 'hide_thread'}),
     url(r'^thread/(?P<slug>(\w|-)+)-(?P<thread>\d+)/(?P<post>\d+)/delete/$', 'error_not_implemented', name="post_delete", kwargs={'mode': 'delete_post'}),

misago/forms/layouts.py

@@ -12,9 +12,13 @@ class FormLayout(object):
 
         self.multipart_form = scaffold_fields.multipart_form
         self.fieldsets = scaffold_fieldsets.fieldsets
-        self.fields = scaffold_fields.fields
         self.hidden = scaffold_fields.hidden
 
+        self.fields = {}
+        for fieldset in self.fieldsets:
+            for field in fieldset['fields']:
+                self.fields[field['id']] = field
+
 
 class FormFields(object):
     """
@@ -168,7 +172,7 @@ class FormFields(object):
             # Select
             if widget_name == 'Select':
                 blueprint['widget'] = 'select'
-                if not blueprint['value']:
+                if not blueprint['has_value']:
                     blueprint['value'] = None
 
             # NullBooleanSelect
@@ -182,8 +186,6 @@ class FormFields(object):
             # RadioSelect
             if widget_name == 'RadioSelect':
                 blueprint['widget'] = 'radio_select'
-                if not blueprint['value']:
-                    blueprint['value'] = u''
 
             # CheckboxSelectMultiple
             if widget_name == 'CheckboxSelectMultiple':

misago/models/forummodel.py

@@ -189,6 +189,16 @@ class Forum(MPTTModel):
             return att in self.attrs.split()
         return False
 
+    def new_last_thread(self, thread):
+        self.last_thread = thread
+        self.last_thread_name = thread.name
+        self.last_thread_slug = thread.slug
+        self.last_thread_date = thread.last
+        self.last_poster = thread.last_poster
+        self.last_poster_name = thread.last_poster_name
+        self.last_poster_slug = thread.last_poster_slug
+        self.last_poster_style = thread.last_poster_style
+
     def sync(self):
         self.threads = self.thread_set.filter(moderated=False).filter(deleted=False).count()
         self.posts = self.post_set.filter(moderated=False).count()

misago/models/threadmodel.py

@@ -86,6 +86,24 @@ class Thread(models.Model):
     def get_date(self):
         return self.start
 
+    def new_start_post(self, post):
+        self.start = post.date
+        self.start_post = post
+        self.start_poster = post.user
+        self.start_poster_name = post.user.username
+        self.start_poster_slug = post.user.username_slug
+        if post.user.rank_id and post.user.rank.style:
+            self.start_poster_style = post.user.rank.style
+
+    def new_last_post(self, post):
+        self.last = post.date
+        self.last_post = post
+        self.last_poster = post.user
+        self.last_poster_name = post.user.username
+        self.last_poster_slug = post.user.username_slug
+        if post.user.rank_id and post.user.rank.style:
+            self.last_poster_style = post.user.rank.style
+
     def move_to(self, move_to):
         move_thread.send(sender=self, move_to=move_to)
         self.forum = move_to

misago/templatetags/utils.py

@@ -0,0 +1,11 @@
+from coffin.template import Library
+
+register = Library()
+
+
+@register.object(name='intersect')
+def intersect(list_a, list_b):
+    for i in list_a:
+        if i in list_b:
+            return True
+    return False

templates/cranefly/announcements/list.html

@@ -27,7 +27,7 @@
   <div class="forum-threads-extra extra-top">
     {{ pager() }}
     {% if user.is_authenticated() and acl.threads.can_start_threads(forum) %}
-    <a href="{% url 'thread_new' forum=forum.pk, slug=forum.slug %}" class="btn btn-inverse pull-right"><i class="icon-plus"></i> {% trans %}New Thread{% endtrans %}</a>
+    <a href="{% url 'thread_start' forum=forum.pk, slug=forum.slug %}" class="btn btn-inverse pull-right"><i class="icon-plus"></i> {% trans %}New Thread{% endtrans %}</a>
     {% endif %}
   </div>
 
@@ -117,7 +117,7 @@
   <div class="forum-threads-extra">
     {{ pager() }}
     {% if user.is_authenticated() and acl.threads.can_start_threads(forum) %}
-    <a href="{% url 'thread_new' forum=forum.pk, slug=forum.slug %}" class="btn btn-inverse pull-right"><i class="icon-plus"></i> {% trans %}New Thread{% endtrans %}</a>
+    <a href="{% url 'thread_start' forum=forum.pk, slug=forum.slug %}" class="btn btn-inverse pull-right"><i class="icon-plus"></i> {% trans %}New Thread{% endtrans %}</a>
     {% elif not user.is_authenticated() and not user.is_crawler() %}
     <p class="lead threads-signin-message"><a href="{% url 'sign_in' %}">{% trans %}Sign in or register to start threads.{% endtrans %}</a></p>
     {% endif %}

templates/cranefly/threads/list.html

@@ -67,7 +67,7 @@
   <div class="forum-threads-extra extra-top">
     {{ pager() }}
     {% if user.is_authenticated() and acl.threads.can_start_threads(forum) %}
-    <a href="{% url 'thread_new' forum=forum.pk, slug=forum.slug %}" class="btn btn-inverse pull-right"><i class="icon-plus"></i> {% trans %}New Thread{% endtrans %}</a>
+    <a href="{% url 'thread_start' forum=forum.pk, slug=forum.slug %}" class="btn btn-inverse pull-right"><i class="icon-plus"></i> {% trans %}New Thread{% endtrans %}</a>
     {% endif %}
   </div>
 
@@ -157,7 +157,7 @@
   <div class="forum-threads-extra">
     {{ pager() }}
     {% if user.is_authenticated() and acl.threads.can_start_threads(forum) %}
-    <a href="{% url 'thread_new' forum=forum.pk, slug=forum.slug %}" class="btn btn-inverse pull-right"><i class="icon-plus"></i> {% trans %}New Thread{% endtrans %}</a>
+    <a href="{% url 'thread_start' forum=forum.pk, slug=forum.slug %}" class="btn btn-inverse pull-right"><i class="icon-plus"></i> {% trans %}New Thread{% endtrans %}</a>
     {% elif not user.is_authenticated() and not user.is_crawler() %}
     <p class="lead threads-signin-message"><a href="{% url 'sign_in' %}">{% trans %}Sign in or register to start threads.{% endtrans %}</a></p>
     {% endif %}

templates/cranefly/threads/posting.html

@@ -64,9 +64,25 @@
             <h4>Message Body</h4>
             {% endif %}
             {{ editor.editor(form.fields.post, get_button(), rows=8, extra=get_extra()) }}
-            {% if 'edit_reason' in form.fields %}
+            {% if intersect(form.fields, ('edit_reason', 'thread_weight', 'close_thread')) %}
             <hr>
+            {% if 'edit_reason' in form.fields %}
             {{ form_theme.row_widget(form.fields.edit_reason, width=8) }}
+            {% endif %}
+
+            {% if intersect(form.fields, ('thread_weight', 'close_thread')) %}
+            <div class="control-group">
+              <label class="control-label">{% trans %}Thread Status{% endtrans %}:</label>
+              <div class="controls">
+                {% if 'thread_weight' in form.fields %}
+                {{ form_theme.input_radio_select(form.fields.thread_weight, width=8) }}
+                {% endif %}
+                {% if 'close_thread' in form.fields %}
+                {{ form_theme.input_checkbox(form.fields.close_thread, width=8) }}
+                {% endif %}
+              </div>
+            </div>
+            {% endif %}
 
             <div class="form-actions">
               <button type="submit" class="btn btn-primary">{{ get_button() }}</button>
@@ -82,35 +98,6 @@
 </div>
 {% endblock %}
 
-{% block content %}
-<div class="page-header">
-  <ul class="breadcrumb">
-    {{ self.breadcrumb() }}</li>
-  </ul>
-  <h1>{{ get_title() }} <small>{% if thread %}{{ thread.name }}{% else %}{{ forum.name }}{% endif %}</small></h1>
-  {% if thread %}
-  <ul class="unstyled thread-info">
-    {{ get_info() }}
-  </ul>
-  {%- endif %}
-</div>
-{% if message %}{{ macros.draw_message(message, 'alert-form') }}{% endif %}
-{% if preview %}
-<div class="well" style="margin: 0px; margin-bottom: 32px; padding: 12px;">
-  <div class="markdown">
-    {{ preview|markdown_final|safe }}
-  </div>
-</div>
-<hr>
-{% endif %}
-<form action="{{ get_action() }}" method="post">
-  <input type="hidden" name="{{ csrf_id }}" value="{{ csrf_token }}">
-  {% if 'thread_name' in form.fields %}{{ form_theme.row_widget(form.fields.thread_name) }}{% endif %}
-  {% if 'edit_reason' in form.fields %}{{ form_theme.row_widget(form.fields.edit_reason) }}{% endif %}
-  {{ editor.editor(form.fields.post, get_button(), rows=8, extra=get_extra()) }}
-</form>
-{% endblock %}
-
 {% block stylesheets %}{{ super() }}
 <link href="{{ STATIC_URL }}cranefly/highlight/styles/monokai.css" rel="stylesheet">
 {% endblock %}
@@ -127,30 +114,30 @@
 
 
 {% macro get_action() -%}
-{% if mode == 'new_thread' -%}
-{% url 'thread_new' forum=forum.pk, slug=forum.slug %}
-{%- elif mode == 'edit_thread' -%}
+{% if action == 'new_thread' -%}
+{% url 'thread_start' forum=forum.pk, slug=forum.slug %}
+{%- elif action == 'edit_thread' -%}
 {% url 'thread_edit' thread=thread.pk, slug=thread.slug %}
-{%- elif mode in ['new_post', 'new_post_quick'] -%}
+{%- elif action in 'new_post' -%}
 {%- if quote -%}
 {% url 'thread_reply' thread=thread.pk, slug=thread.slug, quote=quote.pk %}
 {%- else -%}
 {% url 'thread_reply' thread=thread.pk, slug=thread.slug %}
 {%- endif -%}
-{%- elif mode == 'edit_post' -%}
+{%- elif action == 'edit_post' -%}
 {% url 'post_edit' thread=thread.pk, slug=thread.slug, post=post.pk %}
 {%- endif %}
 {%- endmacro %}
 
 
 {% macro get_title() -%}
-{% if mode == 'new_thread' -%}
+{% if action == 'new_thread' -%}
 {% trans %}Post New Thread{% endtrans %}
-{%- elif mode == 'edit_thread' -%}
+{%- elif action == 'edit_thread' -%}
 {% trans %}Edit Thread{% endtrans %}
-{%- elif mode in ['new_post', 'new_post_quick'] -%}
+{%- elif action in ['new_post', 'new_post_quick'] -%}
 {% trans %}Post New Reply{% endtrans %}
-{%- elif mode == 'edit_post' -%}
+{%- elif action == 'edit_post' -%}
 {% trans %}Edit Reply{% endtrans %}
 {%- endif %}
 {%- endmacro %}